欢迎使用实时数据库帮助手册

Navigation: »No topics above this level«

欢迎使用实时数据库帮助手册

 Return to chapter overview

本文档的内容是根据数据的采集流程进行划分，其中基本介绍和开始使用有助于用户更全面的了解本产品。其余部分针对各个流程进行详细的阐述，用户可根据个人需求有选择的进行浏览。

欢迎使用实时数据库帮助手册1 | 基本介绍 介绍了iHyperDB的基本概念、功能及系统结构。
欢迎使用实时数据库帮助手册2 | 开始使用 介绍iHyperDB系统的环境要求，使用户能够快速掌握系统的安装、如何启动以及如何关闭等。
欢迎使用实时数据库帮助手册3 | 系统管理 介绍iHyperDB的系统管理平台如何实现iHyperDB的可视化集中配置和管理。《系统管理》主要介绍采集（客户端缓存）、数据转储、报警、权限管理、数据源配置、数据查询、数字量状态集等。
欢迎使用实时数据库帮助手册4 | 数据采集 主要介绍采集客户端的OPC采集器和关系数据库采集器等，并详细介绍了用来配置采集器相关功能模块的采集器配置工具。
欢迎使用实时数据库帮助手册5 | 数据展示 方式包含：电子表格、组态展示、门户展示等。
欢迎使用实时数据库帮助手册6 | 数据分析与处理 主要介绍了如何使用iHyperDB提供的工具，对采集上来的实时数据进行分析与处理。
欢迎使用实时数据库帮助手册4 | 数据存储 主要介绍了存储引擎、网络管理和数据的转储。
欢迎使用实时数据库帮助手册7 | 数据接口 主要介绍如何在iHyperDB的平台上进行定制化的二次开发，本章节主要介绍了iHyperDB提供的数据接口，其中SDK包括C#，Java，C++程序语言编写的接口。通过二次开发，用户可以实现各自行业定制版本。
欢迎使用实时数据库帮助手册8 | 典型案例 主要介绍了iHyperDB中一些典型的应用案例，例如如何实现一个报警、如何通过组态展示实时数据，如何通过二次开发实现定制化需求。
欢迎使用实时数据库帮助手册9 | 常见问题 我们收集了在使用 iHyperDB中常见的一些问题，若您在使用中遇到了自己不能解决的问题，可以先查看这儿，看看有没有您需要的答案。
欢迎使用实时数据库帮助手册9 | 常见错误码 iHyperDB有相对完善的日志系统，且对系统中的每种错误都定义了错误码，在日志查看或界面错误提示框中可以看到系统的错误码，其对应的解释可以通过Excel中的错误码查询界面来获取。《常见错误码》列出了用户在使用过程中较常见到的错误码。
欢迎使用实时数据库帮助手册10 | 产品支持 若您遇到问题后，在我们的联机帮助中没有找到理想的答案。我们提供了联系 iHyperDB技术支持的方式，您可以很方便的从技术支持工程师那里获得相应的技术支持与服务。


基本介绍

Navigation: »No topics above this level«

基本介绍

 Return to chapter overview

宝信分布式高性能实时数据库软件——iHyperDB是上海宝信软件股份有限公司研发的，具有自主知识产权的实时历史数据库系统，它融合了宝信多年在工控领域的研发积累，及实际工程项目中的实践经验。iHyperDB采用了当前最新的开发技术，技术水平位居世界前列，具备高性能、高可靠性、高容量、跨平台、可扩展等特点，在工控领域具有连接生产控制系统与信息管理系统的桥梁作用。

iHyperDB是High Performance Real-Time Database System的简称，是集工业数据采集、存储、处理和分析等多种功能为一体的实时、历史过程数据管理系统，是开发实时数据采集系统、实时控制系统、CIMS系统和流程分析系统的支撑软件。

iHyperDB从技术、设计、开发、维护等各个方面保证系统的先进性，为用户提供了先进、全面的生产数据管理方案，是现在企业信息化必不可少的基础组件。

iHyperDB可以在企业中完成控制系统的监控，使系统得到先进和优化控制，为企业的生产管理和调度、数据分析、决策支持及远程在线浏览提供数据服务和多种数据管理功能，从而成为企业信息化的基础数据平台。

本章主要给读者介绍了iHyperDB的基本概念、功能及系统结构，同时，也介绍了用户使用iHyperDB系统时需要了解的一些基本概念与定义。

本章节主要内容如下：

uiHyperDB是什么

u环境要求

u性能指标


iHyperDB是什么

Navigation: 基本介绍 >

iHyperDB是什么

 Return to chapter overview

iHyperDB的功能

iHyperDB作为一款通用实时数据库系统，具备采集、存储、检索、分析、接口及可视化六大功能模块，各功能如下图所示：

采集

iHyperDB-Collector-采集器：iHyperDB基础架构的最底层组件，提供了数据采集功能并将其存储到iHyperDB中。iHyperDB-Collector采集器将采集分布在不同位置，存在于不同供应商的设备之中的数据，打破企业现已形成的众多的数据孤岛。此外，数据源可能只提供当前值或最少量的历史信息，通过采集软件汇总到iHyperDB后，用户就能够访问当前和历史数据。

iHyperDB-Collector包括如下产品组件：

vhdBuffer缓存

v数采机采集客户端

v关系型数据库数据采集器

存储

iHyperDB-Storage是一个实时数据存档和分发引擎。iHyperDB-Storage可将各种截然不同的源（例如，企业系统、数据库和运营数据源）中的所有相关数据整合至一个系统中，确保根据角色为个体指定适当的访问权限，并以统一方式将这些数据交付给企业中所有级别的用户。

iHyperDB-Storage包括如下产品组件：

vhdKernel内核

v数据源组织架构数据库

v冗余热备

检索

为用户提供了不同的方法来查找所需的信息。 用户可以根据特定的tag 属性、事件、通知搜索数据，也可以使用iHyperDB的特定功能和产品根据背景或通过 OLEDB 等标准协议搜索数据。 包括:

v电子表格系统

v数据源组织结构检索

v实时、历史数据检索

分析

为iHyperDB基础架构提供了实时分析能力，并允许用户分析和聚合实时/历史数据及事件，使之成为用户自定义的可操作信息或关键绩效指标 (KPI)。这些分析功能可与其他用户共享，并在站点或企业之中部署。

分析系统包括：

v表达式计算

v统计过程质量控制

v分析批处理

v数据报警等

接口

接口包括：

v基于SQL的数据访问ODBC

vOPC Server

vSDK (Java、C#、C++)

vCOM（支持VB、VC调用）

vExcel插件公式

v等等方式让用户能通过各种方式访问iHyperDB存储的实时历史记录。

可视化

让用户能随时随地了解iHyperDB存储的实时历史记录,可视化包括:

vWeb门户

v组态画面（包括趋势、历史回放等控件）

vExcel表格等

iHyperDB的特点

1.高速稳定的海量工业数据存储容器宝信实时数据库采用了从采集端到内核的三级压缩技术，大大降低了过程数据的冗余度，从而具备了常年海量工艺数据的存储能力。

2.丰富多样的数据展示分析平台宝信实时数据库为用户提供表格化、图形化、动画、文字、报表等形式的数据展示方案，将大大加速用户商业决策的过程。

3.友好易用的二次开发平台宝信实时数据库封装了简单易用的服务接口，为用户及二次开发人员提供了快速定制非标准协议数据采集器的能力。


iHyperDB常见网络结构

Navigation: 基本介绍 >

iHyperDB常见网络结构

 Return to chapter overview

iHyperDB实时数据库常见的网络方案有：

u分布式冗余架构

u内外网结构

u单机结构

u双机冷备

u双机热备

u单机双网卡冗余

u分布式冗余架构

iHyperDB分布式系统完整的系统架构如下图。整个系统由一对冗余的配置服务器和N对冗余的数据节点服务器构成。

iHyperDB数据采集：系统可通过多种方式获取数据，比如：iCentroView数据转储、OPC或Modbus采集器、iCG采集器等。

iHyperDB数据存储：由配置服务器根据数据负载均衡原则，根据各数据节点服务器的情况自主判断，并将数据存储在适合的数据节点服务器上。

iHyperDB数据同步：iHyperDB支持软件冗余与自动数据同步。有关配置详见：从单机到双机热备冗余的升级。

u内外网结构

iHyperDB支持内外网结构，如下图。iHyperDB数据库支持多网卡配置，支持多网段客户端访问。有关配置详见：配置修改--单机版配置改为内外网。

u单机结构

当然，整个庞大的系统也可以简化配置安装，使之适用于小系统，可以舍弃服务器冗余，舍弃多组服务器结构，由一台服务器兼配置服务器、数据节点服务器功能。如下图：（图例所示IP地址为举例说明，并非指定IP地址。下面多图同为示例。）

u双机冷备

对于某些采用硬件实现一组服务器冗余的系统而言，主备服务器的安装采用单机模式，共享磁盘阵列作为数据文件存放位置。主备机IP地址相同、各种数据库配置参数相同，完全镜像安装，同一时刻只能有一台服务器在线。

u双机热备

有关配置详见：从单机到双机热备冗余的升级。

u单机双网卡冗余

有关配置详见：配置修改--单机版配置修改为单机双网冗余。


环境要求

Navigation: 基本介绍 >

环境要求

 Return to chapter overview

u客户端支持的操作系统

Windows7，Windows8.1, Windows10，Windows11。

u服务端支持的操作系统

Linux：内核2.6及以上，推荐RedHat Linux 7,CentOS7。

Windows：Windows2008Server， Windows2012Server (推荐R2及以上版本)、Windows

Server2016, WindowsServer2019 WindowsServer2022 64位系统。

Unix: Oracle Solaris 11.2, HP-UX 11.31。

其他：银河麒麟v10

u网络连接

RJ-45以太网传输速率100Mbps以上,推荐1Gbps及以上。

服务器需对外开放端口5673（配置中心服务端口）和5678（数据节点服务端口）,可根据配置修改。

u关系数据库（可选，不使用数据转储功能时不需要）

SQLServer2005及以上，MySQL 5.5及以上，Oracle10g及以上版本。

u数据报表（可选，不使用Excel插件功能时不需要）

Microsoft Excel 2003，2007，2010，2013，2016。


性能指标

Navigation: 基本介绍 >

性能指标

 Return to chapter overview

典型应用环境的性能指标

服务端硬件推荐配置:

CPU：非信创 Xeon(R) Gold 6326 64核

信创 C86 海光7280

信创 ARM 鲲鹏920 64核

内存：DDR4

容量 256G

频率 >=3200MHz

硬盘：SSD 固态硬盘容量102400G，接口M2

顺序读 >= 4000 MB/s

顺序写 >= 3000 MB/s

随机读>= 700K IOPS

随机写>= 600K IOPS

网卡：万兆级

在如上典型环境下的相关性能指标

 | 指标 | 值 | 备注
1 | Tag点规模 | 50万 | 单数据节点容量限制，多数据节点可线性扩展。
2 | 每秒写入历史数据记录数 | 400万 | 每秒可支持的总写历史记录数
3 | 每秒写入实时数据记录数 | 1000万 | 每秒可支持的内核总写记录数
4 | 每秒查询历史数据记录数 | 600万 | 多个客户端并发查询历史总读记录数
5 | 每秒查询实时数据记录数 | 1000万 | 多个客户端并发查询实时总读记录数
6 | 并发读写客户端数 | 2000 | 可以支持并发读写总连接数。


开始使用

Navigation: »No topics above this level«

开始使用

 Return to chapter overview

《开始使用》主要介绍的环境要求和如何在windows下的安装等。具体可见：

u环境要求

u安装和卸载

u许可证的申请和使用说明

u系统启动和关闭

u客户端应用介绍


安装和卸载

Navigation: 开始使用 >

安装和卸载

 Return to chapter overview

本章介绍数据库的安装和卸载。

为了更好地理解数据库安装、配置时需要填写的配置服务器、数据节点服务器的主机/备机IP，请先阅读“iHyperDB常见网络结构”这一章节。

本章内容包括：

uWindows系统下的安装

u卸载实时数据库

u部署双机热备

u部署单机双网冗余

u从单机到双机热备冗余的升级

u配置修改--单机版本机IP地址修改

u配置修改--单机版配置改为单机双网冗余

u配置修改--单机版配置改为内外网

uHPUX版本使用说明


Windows系统下的安装

Navigation: 开始使用 > 安装和卸载 >

Windows系统下的安装

 Return to chapter overview

安装文件说明:

 | 文件名 | 说明
1 | iHyperDB_ServerInstall.exe iHyperDB_ServerInstall_x64.exe | 数据库服务器安装程序，主程序。
2 | iHyperDB_DataNode.exe iHyperDB_DataNode_x64.exe | 数据节点服务器安装程序，通常主程序完成安装后，会自动运行此项。
3 | iHyperDB_Client.exe iHyperDB_Client_x64.exe | 客户端安装程序。
4 | userhelp.chm | 帮助手册
5 | win32_hdSDK3.zip win64_hdSDK3.zip | SDK开发包安装程序
6 | hd3OPCServer.exe | OPC Server安装包

搭建同一平台的iHyperDB服务端及客户端版本（包括补丁），必须完全一致，不支持混装。

1.数据库服务端的安装步骤

2.数据库客户端的安装步骤

本章以Windows32位简体中文版为例，介绍单机安装步骤。

1.数据库服务端的安装步骤

1)运行主安装程序 iHyperDB_ServerInstall.exe

2)选择安装位置，推荐安装在非C盘，C盘留给操作系统。

3)选择是否为配置中心部署主备双机冗余服务器。

缺省选“否”，安装为单机系统；单机安装完成后可以通过修改主备冗余配置，而改为双机冗余系统，详见从单机到双机热备冗余的升级。

选“是”，则安装为双机冗余系统；详细配置安装过程详见双机热备冗余系统安装。

4)设置配置中心服务器的ip地址和端口，默认识别是本机的ip地址，端口默认5673。

5)进入正在安装的画面。

1、缺省不勾选“重启计算机”，选择重启则有利于配置中心的初始化。

2、勾选“本机安装数据节点”继续安装数据节点服务。若为分布式数据库设计方案安装，配置中心和数据节点服务应安装在不同服务器上，需去掉第二个勾选，将数据节点服务安装至其他服务器。

3、手动安装数据节点服务，请选择安装文件“iHyperDB_DataNode.exe”。

6)安装数据节点服务

7)系统提示（系统安装必须在所有数据库的进程都停止的状态下），点击“确定”继续安装。

8)选择安装位置

9)选择安装选件包“大数据采集器”，此采集器可将iHD数据送往宝信大数据软件产品。勾选，大数据采集器安装过程，参见大数据采集器整体安装说明；不勾选，日后再安装，参见大数据采集器单独安装说明。

10)数据节点服务端口（建议选用默认5678端口号）及数据文件路径设置（位置可自定义，但建议此四个路径安装至同一目录下，方便日后手工备份管理。）

11)数据节点服务运行参数配置

参数说明：

内存缓冲区大小：为数据节点服务对内存的占用量，安装建议：不要大于系统剩余内存的1/3。

硬盘数据文件大小：即单个数据文件的大小，必须是内存缓冲区大小的整倍数（至少2倍以上）。如不是整倍数，可能导致服务无法正常启动。

硬盘数据文件个数：请根据剩余磁盘量计算。

系统数据文件最终占用磁盘空间大小＝硬盘数据文件大小×文件个数。当文件个数写满后，会循环覆盖。

例如：如上图配置安装后，系统第3组数据文件写满后，会重新覆盖写第1组。若第1组数据文件没有及时备份，将会导致数据遗失。

1、文件个数待系统安装完成后，还可在“数据节点服务管理工具-系统参数”中修改，其他两项参数则不可修改。

2、如果硬盘空间很大，也不推荐单个数据文件过大。当前（2017年经验数据）项目应用经验：数据文件大小设置为50G，当系统一组数据文件写满，系统自动生成第二组数据文件时，准备时间过长，导致实时数据来不及存放。对于没有缓存的采集器而言，这段数据文件准备时期的采集数据将会丢失。

3、这三个参数非常重要！！！当你进行系统恢复、重装时，新安装的数据库必须与旧数据库，保持此三个参数完全一致。系统安装完毕，此三个参数可以在文件“系统安装目录\config\servercfg.xml”中读到。如下图：

4.如需多线程查询历史记录，则需修改CPUNum参数，推荐配置为CPU核数的两倍，如下图：

12)单服务器、分布式服务器部署选项

单服务器安装，直接点击“下一步”。

多服务器安装，需指明本数据节点服务器的IP，以及本组的配置中心服务器主/备机的IP、端口号。

13)数据节点服务器安装页面

建议安装成系统服务，重启计算机令配置生效。

系统安装完毕，首次启动，实时数据库内核服务进程会保持“启动中”状态，直至首个归档数据文件完成初始化创建工作，请耐心等待。

因首个数据文件创建与所设置的单个数据文件大小、磁盘读写效率有关。如不放心，可至\Data\Archive文件夹下观察首个数据文件“1.dat”，其文件大小是否在持续增长中？如是，则一切正常。待该文件增长至系统安装时设定的数据文件大小，内核服务就会完成启动，并显示“正在运行”字样。

异常情况，请查阅常见问题分析——安装常见问题。

2.数据库客户端的安装步骤

1)运行客户端安装程序iHyperDB_Client.exe

2)选择安装路径

3)选择可选插件，点击“继续安装”，如下图。

Excel插件

勾选Excel插件，则安装Excel插件包。

1、先装Excel，后装此插件包；

2、安装32位的iHyperDB，必须选装32位的Excel，安装64位的iHyperDB，必须选装64位的Excel，版本需对应。

组态配置与展示

若项目平台搭建还选用了本公司的iCV或CVS组态产品，建议不要安装此“组态配置与展示”插件，而选择安装iCV或CVS安装包内的iHyperDB插件包。此处安装的组态插件包，是为没有选购本公司的iCV或CVS组态产品的项目提供一个简单的组态开发界面的组件包。

如果需要iHDB组态的安装说明，请参照 组态展示中的安装部署。

最后点击“安装完成”，至此完成全部安装。


卸载实时数据库

Navigation: 开始使用 > 安装和卸载 >

卸载实时数据库

 Return to chapter overview

建议在卸载之前对数据(一般是数据节点安装目录下的Data文件夹)和配置（iHyperDB\config文件夹）做相应备份。

卸载方式：

1.执行安装目录下的Uninstall.exe；

2.从windows开始菜单执行“卸载”快捷链接。

卸载步骤：

1.在windows开始菜单中单击实时数据库的“卸载”快捷链接，运行卸载程序。弹出窗，如下图：

2.卸载目录为自动加载（卸载程序会自动找到iHD的安装路径），点击“卸载”，进入卸载程序。

卸载过程，根据实际需要选择是否保留原数据及配置文件夹。

3.卸载完成，建议重启系统。


双机热备冗余系统安装

Navigation: 开始使用 > 安装和卸载 >

双机热备冗余系统安装

 Return to chapter overview

本章以Windows32位简体中文版为例，介绍双机热备冗余系统安装步骤。

双机热备网络结构说明请参考“iHyperDB常见网络结构”章节。

本案例中服务器安装参数：

 | 配置中心 主机安装参数 | 配置中心 备机安装参数 | 分布式 数据节点 单机/主机安装参数 | 分布式 数据节点 备机安装参数
操作系统 | Windows 中文版 | Windows 中文版 | Windows 中文版 | Windows 中文版
安装数据库版本 | iHyperDB 3.6.1 win32中文版 | iHyperDB 3.6.1 win32中文版 | iHyperDB 3.6.1 win32中文版 | iHyperDB 3.6.1 win32中文版
网段1 IP | 168.2.9.94（主机网卡1） | 168.2.9.95（备机网卡1） | 168.2.9.96（主机网卡1） | 168.2.9.97（备机网卡1）
网段2 IP | 192.168.128.1（主机网卡2） | 192.168.128.2（备机网卡2） | 192.168.128.3（主机网卡2） | 192.168.128.4（备机网卡2）
网络检测IP | 168.2.9.200 | 168.2.9.200 |  |

整个安装配置过程：

u安装冗余配置中心服务

u安装冗余数据节点服务

u安装数据库客户端

u数据库首次启动及数据节点服务管理工具的使用

u客户端系统管理工具的使用

u安装冗余配置中心服务（主备机安装步骤相同）

1.运行主安装程序 iHyperDB_ServerInstall.exe

2.选择安装路径

3.选择“是”，安装主备冗余服务器；

4.主备冗余配置中心参数设置；

参数说明：

v主服务器IP、端口：填写主机网段1 IP，端口缺省为5673。

v备服务器IP、端口：填写备机网段1 IP，端口缺省为5673。

v网络检测IP：第三方验证地址，通常建议为网关。建议勾选此项并配置第三方检测地址。勾选并配置此选项，当主备服务器断网时，可以根据第三方判断是主机断网还是备机断网；不勾选，当主备服务器断网时，会出现双主现象，不过不用担心，网络恢复正常后会立即恢复正常。

对于双网冗余服务器配置，可以在主备机IP地址参数填写处，以“网段1 IP/网段2 IP”方式填写双网卡IP地址，如下图：

5.完成冗余配置服务安装

1、缺省不勾选“重启计算机”，选择重启则有利于配置中心的初始化。

2、勾选“本机安装数据节点”继续安装数据节点服务。若为分布式数据库设计方案安装，配置中心和数据节点服务应安装在不同服务器上，需去掉第二个勾选，将数据节点服务安装至其他服务器。

3、手动安装数据节点服务，请选择安装文件“iHyperDB_DataNode.exe”。

u安装冗余数据节点服务（主备机安装步骤相同）

1.运行数据节点安装程序iHyperDB_DataNode.exe

2.选择安装路径，可根据需要自行选择目标文件夹。

3.数据节点服务安装参数配置，详见Windows系统下的安装相关参数说明。

4.选择可选项，如项目中没有同时选用本公司的大数据软件，可不必勾选“大数据采集转发服务”，直接进入“下一步”。

5.选择此数据节点服务所对应的配置中心服务所在地址。

单服务器安装，即数据节点服务与配置中心服务安装在同一台机器上（数据节点IP同配置中心IP），直接点击“下一步”。分布式数据节点也可待单服务器方式安装完毕，再手动进行配置添加，详见手动添加数据节点主备配置说明。

多服务器安装，即数据节点为分布式服务器安装，需指明本数据节点服务器的IP，以及本组数据节点服务器所对应的配置中心服务器主/备机的IP、端口号。

6.建议选择“安装为系统服务”方式，点击“完成”，重启后完成安装。

u安装数据库客户端（无论安装于主备机还是其他同网段机器，其安装步骤均相同。）

数据库客户端安装步骤详见Windows系统下的安装——数据库客户端的安装步骤。

u数据库首次启动及数据节点服务管理工具的使用

1.首次启动

重启后，系统将进入自动创建数据文件阶段。首次启动，实时数据库内核服务进程会保持“启动中”状态，直至首个归档数据文件完成初始化创建工作，请耐心等待。

因首个数据文件创建与所设置的单个数据文件大小、磁盘读写效率有关。如不放心，可至\Data\Archive文件夹下观察首个数据文件“1.dat”，其文件大小是否在持续增长中？如是，则一切正常。待该文件增长至系统安装时设定的数据文件大小，内核服务就会完成启动，并显示“正在运行”字样。

内核服务运行状态可以在数据节点服务管理工具中查看。

异常情况，请查阅常见问题分析——安装常见问题。

2.数据节点服务管理工具的使用

首次启动后，可在主备机上打开数据节点服务管理工具，数据节点管理工具快捷链接可在开始菜单可以找到，如下图所示：

启动主备机上所有服务。

u客户端系统管理工具的使用

1.运行系统管理工具，如下图：

2.首次登陆运行系统管理工具，点击“修改”，修改服务连接配置如下图：

缺省用户名密码均为：admin。

3.点击系统管理平台的数据节点配置图标，手动添加数据节点主备配置，如下图：

4.配置数据节点主备服务器IP及双网IP配置（单网格式：网段1 IP；双网格式：网段1 IP/网段2 IP），如下图：

点击“确定”，冗余数据节点添加完毕，查看数据节点的hdKernel状态是否正常启动完成。至此双机热备冗余配置安装完成。


部署单机双网冗余

Navigation: 开始使用 > 安装和卸载 >

部署单机双网冗余

 Return to chapter overview

本章以Windows32位简体中文版为例，介绍部署单机双网冗余的步骤。

单机双网(卡)冗余网络结构说明请参考“iHyperDB常见网络结构”章节。

本案例中服务器安装参数：

 | 服务器安装参数 | 客户端安装参数
操作系统 | Windows 中文版 | Windows 中文版
安装数据库版本 | iHyperDB 3.6.1 win32中文版 | iHyperDB 3.6.1 win32中文版 客户端
网段1 IP | 168.2.9.94（服务器网卡1） |
网段2 IP | 168.2.237.54（服务器网卡2） |
备注 |  | 客户端的网络连接可以访问到服务器的两个网段。或者这两个网段的客户端，分别访问对应网段的服务器地址。

1.运行配置中心安装程序：iHyperDB_ServerInstall.exe。

选择安装位置说明略，详见Windows系统下的安装章节。

配置中心部署主备双机冗余服务器：选择“是”，如下图：

填写主备服务器IP,

请注意在这一步将主服务器IP和备服务器IP配置分别配置为服务器的2个IP地址168.2.9.94和168.2.237.54,并且不要勾选网络检测IP。

2.运行数据节点安装程序：iHyperDB_DataNode.exe。

参数填写说明，详见Windows系统下的安装章节。

本机IP可选择168.2.9.94和168.2.237.54中的任意一个。

安装之后点击安装完成。

3.运行实时数据库客户端安装程序：iHyperDB_Client.exe。

勾选excel插件，点击安装完成插件的安装。

4.在服务器上打开数据节点服务管理工具，启动所有服务。（数据节点管理工具在开始菜单可以找到。）

注意：第一次启动hdKernel，启动状态会显示为“正在启动”，这是因为第5步添加数据节点还没有完成。完成第5步，hdKernel的启动就会完成。

5.打开客户端机器上的系统管理工具，连接到服务器的主备2个IP地址，添加数据节点，配置数据节点主备为服务器的2个IP地址168.2.9.94和168.2.237.54。

勾选“状态”，弹出登录口令输入窗。

缺省用户名/密码为：admin/admin，点击“确定”。

点击系统管理平台的“数据节点配置”图标：

点击“数据节点配置”的“添加”按钮，添加一个数据节点，设置数据节点的主机地址和备机地址，点击“确定”，数据节点test添加成功。

至此，冗余数据节点添加成功。此时可查看数据节点hdKernel状态已变为“正常”（注意：第一次启动时因需要创建数据文件，需要一定耗时，根据配置的文件大小从几十秒到几分钟不等）。

6.单机双网冗余部署完成，所有登录此服务器的客户端均需要同时连接服务器的2个地址，即可实现双网冗余的功能。配置修改步骤参考第5步。


从单机到双机热备冗余的升级

Navigation: 开始使用 > 安装和卸载 >

从单机到双机热备冗余的升级

 Return to chapter overview

从单机到双机热备冗余的升级操作方式分以下两种版本：

v3.2-3.5版本升级操作
v3.6以上版本升级操作

实时数据库v3.2-3.5版本升级操作方法

双机热备网络结构说明请参考“iHyperDB常见网络结构”。

对于已经部署并运行的单机（机器为A）项目，升级为双机热备（机器为A和B）步骤如下:

1.打开系统管理工具，连接到A并配置数据节点将A和B作为数据节点主备地址；

2.机器A上所有服务重启；

3.机器A上的实时数据库升级到最新版本；

4.机器B上新安装实时数据库的最新版本，包括配置中心和数据节点；

4.1.机器B安装配置中心，选择“配置中心部署双机冗余服务器”，配置主备配置中心地址，不要勾选“执行PostgreSQL初始配置”，示意图如下：

4.2.机器B上安装数据节点，配置“内存缓存区大小”“硬盘数据文件大小”和“硬盘数据文件个数”，注意这几个参数必须要与机器A上配置的参数完全一致，如果不知道机器A配置的参数可以打开机器A安装目录config/ServerCfg.xml查看；

选择多服务器，分布式节点部署，配置本机IP和配置中心主备地址。

机器B上的配置中心和数据节点都安装完成。

关闭机器A的实时数据库的后台服务。

A机器上打开PostgreSQL客户端将数据库备份成文件**.backup，并将该备份文件拷贝到机器B上。

修改机器A上安装目录下config/ConfigCenter.xml中主备配置中心地址如下

修改机器A上安装目录下config/ServerCfg.xml中主备配置中心的配置项如下

拷贝机器A的安装目录下config/Config.db和config/Alarm.db到机器B的安装目录下的config目录覆盖原文件。

拷贝机器A的安装目录下Data文件夹到机器B的安装目录下覆盖原文件夹。

机器B打开PostgreSQL客户端恢复 A机器上拷贝过来的备份文件

启动机器A和机器B上实时数据库服务，服务端的主备升级完成。

下面是客户端主要功能模块的升级，包括采集器，关系数据库转储，组态运行客户端。

ØOPC采集器，Modbus采集器的升级

1.打开采集器配置工具；

2.连接主备配置中心地址；

3.停止所有采集器；

4.重新保存采集器配置；

5.启动采集器。

Ø关系数据库转储的升级

1.打开系统管理工具；

2.连接到主备配置中心地址；

3.重新启动关系数据库转储服务。

Ø组态的升级

1.打开系统管理工具并连接到主备地址；

2.选中组态-节点管理，修改可访问的实时数据库地址，修改为主备地址；

3.选中全部分发-全选-分发；

4.重启所有组态运行客户端，验证功能。可通过停止主机服务的方式切换主备，验证双机热备是否生效。

实时数据库v3.6版本升级操作方法

对于已经部署并运行的单机（机器为A）项目，升级为双机热备（机器为A和B）步骤如下:

1.此操作步骤是ihd 3.6及其以上版本的升级操作；

2.打开系统管理工具，连接到A并配置数据节点将A和B作为数据节点主备地址；

3.机器A（主）上所有服务重启；

4.机器B（备）完全卸载并重新安装实时数据库的最新版本（与机器A版本一致），包括配置中心和数据节点；

4.1.机器B（备）安装配置中心，选择“配置中心部署双机冗余服务器”，配置主备配置中心地址，示意图如下：

4.2.机器B上安装数据节点，配置“内存缓存区大小”“硬盘数据文件大小”和“硬盘数据文件个数”，注意这几个参数必须要与机器A上配置的参数完全一致，如果不知道机器A配置的参数可以打开机器A安装目录config/ServerCfg.xml查看；

选择多服务器，分布式节点部署，配置本机IP和配置中心主备地址。

机器B上的配置中心和数据节点都安装完成。

关闭机器A的实时数据库的后台服务。

拷贝机器A的安装目录下config/Config.db和configCenter.db到机器B的安装目录下的config目录覆盖原文件。

重启启动机器A和机器B上实时数据库服务，服务端的主备升级完成。


配置修改--单机版本机IP地址修改

Navigation: 开始使用 > 安装和卸载 >

配置修改--单机版本机IP地址修改

 Return to chapter overview

单机版指系统环境中只有一台实时数据库服务器，配置中心和数据节点都安装在该机器。

如果该机器IP地址需要变更（例如从168.2.8.90变为168.2.6.210）时，请按照下面步骤修改：

1.启动服务端的所有服务。

2.打开“系统管理工具”，点击连接之后，点击修改，ip地址填写服务器的新地址168.2.6.210，点击保存。

3.点击系统管理工具 - 数据节点配置-修改。选中该行，点击修改，将老的IP地址修改为新的IP地址，确认保存。

4.重启ihd的全部进程，包括服务端和客户端，令配置生效。重启之后ihd运行状态显示正常，客户端用新的ip连接无报错，说明IP修改成功。


配置修改--单机版改为单机双网冗余

Navigation: 开始使用 > 安装和卸载 >

配置修改--单机版改为单机双网冗余

 Return to chapter overview

单机版指系统环境中只有一台实时数据库服务器，配置中心和数据节点都安装在该机器。

单机双网冗余是指一台服务器有两块网卡，分属两个网段，该服务器可被两个网段的外部客户端访问的结构，网络结构说明请参考“iHyperDB常见网络结构”。

系统将该机以虚拟冗余方式提供给客户端访问，因而该机配置方式将不再支持真正的双机冗余热备方案。

注意：此方案与双机热备冗余方案不可兼得。

例如：单机iHD服务器，IP1:168.2.6.210，IP2:168.2.8.90。单机安装时填写地址为IP1，现增加IP2，按照下面的步骤修改：

1.实时数据库服务运行之后，点击“系统管理工具>打开服务器连接管理器”，点击“修改”，勾选“备机IP”，填写IP2，备机端口号默认"5673"，点击“保存”。

2.在系统管理工具中，点击“数据节点配置”，选择“修改”，在“备机IP”处填写IP2地址，端口默认填写"5678"，之后点击“确认”保存。

3.打开“数据节点服务管理工具”，点击“系统参数”，点击“其他”，如下图所示：

4.在配置中心备机IP一栏添加你所需要添加IP2地址，点击“保存”。

5.保存之后，关闭客户端配置工具，关闭实时数据库的所有服务，退出服务管理工具并重启。

6.重启后可以看到服务管理工具中，“是否启用冗余”显示为“是”，“冗余状态”显示为“活动”。但此方案并不是真正意义上的主备冗余，仅是提供双网段访问的网络冗余单机方案。


配置修改--单机版改为内外网

Navigation: 开始使用 > 安装和卸载 >

配置修改--单机版改为内外网

 Return to chapter overview

单机版指系统环境中只有一台实时数据库服务器，配置中心和数据节点都安装在该机器。

内外网结构支持双网段访问，该网络结构说明请参考“iHyperDB常见网络结构”。

此配置修改方案同样适用于冗余热备服务器需要支持双网访问的结构。

本例为：1台单机iHD服务器，需要支持双网段访问。IP1:168.2.6.210,IP2:168.2.8.90。请按照下面的步骤来修改。（对于热备冗余系统，备机IP地址填写方式与主机IP填写方式相同，本处不再复述。）

1.iHD服务运行之后，在“系统管理工具”中点击“数据节点配置”，选择“修改”。

2.在“主IP”参数栏，将之前配置填写的IP1地址后面加上’/’,后面加填IP2，点击“确定”，如图所示：

3.关闭“系统管理工具”，打开“数据节点服务管理工具”，点击“系统参数”，点击“其他”， 在“配置中心主IP”参数栏“新值”处，加上‘/’和IP2地址，如下图所示：

4.修改完之后，重启iHD服务生效。重启过后，可以用系统管理工具通过不同的网络来连接服务端，连接成功证明配置生效。


HPUX版本使用说明

Navigation: 开始使用 > 安装和卸载 >

HPUX版本使用说明

 Return to chapter overview

安装：

1.将tar文件上传到HPUX服务器；

2.执行命令：tar xvf ihyperdb_hpux2.4.x.tar 解压缩；

3.解压缩后生成iHyperDB文件夹，执行命令：cd iHyperDB进入该文件夹；

4.运行hdsetup脚本，运行后需重新登陆当前帐户，使环境变量生效。

运行：

1.在上述$iHyperDB目录下运行hdstart脚本启动服务端程序；

2.输入命令：hdproc查看服务端程序是否启动，如果有未启动的需要再运行hdstart直到所有后台进程都启动。

FAQ:

1.部分中文字符不支持？

在登录的HPUX用户配置文件.profile中添加

export LANG=zh_CN.hp15CN

2.链接库路径找不到？

在登录的HPUX用户配置文件.profile最后添加

export LD_LIBRARY_PATH=$iHyperDB/library:$iHyperDB/executable

3.服务端参数配置在安装路径的config/ServerCfg.xml文件中，修改后须运行hdstop脚本停止服务端进程，然后运行hdstart重启生效。参数修改需注意参考windows版本的服务端管理工具提示的约束条件。

ServerCfg.xml常用配置项说明：

iHyperDBSrv->Kernel->SeqFile->Size, 序列缓存文件大小, 单位M，一般50~512。

iHyperDBSrv->Kernel->ArchiveFile->Size, 单个归档文件大小, 单位M，一般1024~4096。

iHyperDBSrv->Kernel->ArchiveFile->Num, 归档文件的最大个数, 范围3~500, 调整需考虑归档文件存放的硬盘分区大小。

iHyperDBSrv->NetMgr->Network->Port, 网络服务监听端口,默认5678, 注意需防火墙允许该端口。

4.服务器时间和采集器时间戳不同会丢弃数据，如果确认设备时间戳正常,可修改服务端参数config/ServerCfg.xml里面以下两个参数：

<TimeStamp Enable="1" MaxTimeDevSec="1800"/>

MaxTimeDevSec：时间差,单位秒；

TimeStamp Enable：是否丢弃数据设置；

v"1"为丢弃；

v"0"为不丢弃；（但是可能产生数据查询的时间与服务端不一致,请配置人员一定要确认最终客户应用需求,并告知客户。）


Windows版本升级方法

Navigation: 开始使用 > 安装和卸载 >

Windows版本升级方法

 Return to chapter overview

通用升级方法：

1.备份配置config文件夹后执行exe安装程序覆盖安装到原目录；

2.检查部分程序配置文件是否修改

HDPubServer: config/HDPubServer.xml

hdSynchrodata: config/CloudSyn.db,hdSynchrodata.xml

hdOpcua: config/opcua.xml, Log.xml

ihd2ihd采集器增加用户登陆配置：客户端config/HDCollector.db另外替换原有数据库中缺少用户名密码字段

升级示例：

u 3.6.1 win32升级到3.9.1

u 3.6.1 x64升级到3.8.0


3.6.1 win32升级到3.9.1

Navigation: 开始使用 > 安装和卸载 > Windows版本升级方法 >

3.6.1 win32升级到3.9.1

 Return to chapter overview

升级流程：

1.配置迁移：安装3.9.1iHyperDB，安装完成后不立即启动，需要替换原有32位iHyperDB配置以及修改一些配置。

§复制原有iHyperDB config下configcenter.db，config.db到新iHyperDB config下，并运行ConfigCenter配置文件修改章节中的sql语句，添加新版本需要的表和字段。

§修改configcenter.db中t_hdserver的ip到新安装环境的ip。

§对照原有iHyperDB的Servercfg.xml修改新Servercfg.xml，主要是序列缓存和历史文件的大小和数量。

2.数据迁移：启动3.9.1iHyperDB，生成新的Data目录，再停止iHyperDB。

§使用工具，把原有iHyperDB中序列缓存中数据转储到新iHyperDB下。

§复制原有iHyperDB Data下Alarm，Archive，BlockCache，Ry目录到新iHyperDB Data下。

u ConfigCenter配置文件修改

1.configcenter.db修改

t_collector表中加入rystatustagid

ALTER TABLE t_collector ADD rystatustagid INTEGER

2.config.db修改

config.db中加入t_resourcegroup，t_groupresourcegroup，t_tagresourcegroup表

CREATE TABLE t_resourcegroup(

fd_id INT NOT NULL,

fd_name VARCHAR(64) NOT NULL,

fd_accesstype INT DEFAULT 0 NOT NULL,

fd_parent_id INT NULL,

level INT DEFAULT 0 NOT NULL,

PRIMARY KEY (fd_id)

);

CREATE INDEX IE_ResourcegroupName ON t_resourcegroup(fd_name);

CREATE TABLE t_groupresourcegroup(

fd_id INT NOT NULL,

fd_groupid INT NOT NULL,

fd_resourcegroupid INT NOT NULL,

PRIMARY KEY (fd_id)

);

CREATE INDEX IE_UsergroupId ON t_groupresourcegroup(fd_groupid);

CREATE INDEX IE_GroupResourcegroupId ON t_groupresourcegroup(fd_resourcegroupid);

CREATE TABLE t_tagresourcegroup(

fd_id INT NOT NULL,

fd_tagid INT NOT NULL,

fd_resourcegroupid INT NOT NULL,

PRIMARY KEY (fd_id)

);

CREATE INDEX IE_ResourceTagId ON t_tagresourcegroup(fd_tagid);

CREATE INDEX IE_ResourcegroupId ON t_tagresourcegroup(fd_resourcegroupid);

u kernel变更

windows环境测试只需要修改Kernel加载序列缓存处理，就可以正常读取32位Data

linux环境除了修改上面，另外需要修改SEQ_FILE_FIRST_REC_POS到26才能可以初始化序列缓存

块缓存和历史数据经过测试直接可以读取


3.6.1 x64升级到3.8.0

Navigation: 开始使用 > 安装和卸载 > Windows版本升级方法 >

3.6.1 x64升级到3.8.0

 Return to chapter overview

以下示例演示为iHyperDB从3.6.1x64升级到3.8.0x64版本的步骤：

1.备份config、Data、executable文件夹。（内含点位、许可证、历史数据等关键信息）

2.在产品官网 https://product.baosight.com/ihddownload/ 下载3.7.5和3.8.0安装包（如果点击无效，则是被浏览器拦截下载链接，可右键选择链接另存为...）

3.关闭ihd所有进程，包括服务、数据节点服务管理工具、客户端、采集器、以及转储等进程，可在详细信息中检索hd开头的进程并关闭

4.解压3.7.5安装包并以管理员身份运行iHyperDB_ServerInstall_x64.exe（截图中其他安装包会在运行该应用程序后生成）

5.以管理员身份运行iHyperDB_DataNode_x64.exe

6.重启服务器，打开数据节点服务管理工具，核对版本信息及系统信息，运行客户端登录查看历史数据是否查询正常

7.检查功能正常后，从第3步开始，将3.7.5继续升级到3.8.0即可

注意：独立客户端/采集器可沿用3.6.1x64版本，也可覆盖安装3.8.0中生成的客户端安装包

安装3.8.0后再继续安装补丁更新


许可证的申请和使用说明

Navigation: 开始使用 >

许可证的申请和使用说明

 Return to chapter overview

u如何申请许可证

u硬件许可证的使用


软件许可证的申请与使用

Navigation: 开始使用 > 许可证的申请和使用说明 >

软件许可证的申请与使用

 Return to chapter overview

在使用iHyperDB前，请先获取iHyperDB正式许可证。

许可证的申请有两种形式：

u宝信内部用户可通过BSMS系统（http://bsms.baogang.info）申请。

v进入“项目管理->产品许可证管理->产品许可证申请”菜单，可进行用于项目的正式软件许可证申请，或者自用的3个月临时授权申请。项目用授权，需等待审批流程。自用临时授权无需等待审批，申请后可立即下载使用。具体方法可参见iCV帮助中的“许可证的申请”章节。

v现场许可证部署注意事项。

²注意文件许可证的名字必须是License.xml

²存放目录是安装目录的config文件夹

v重新启动iHyperDB数据节点服务，验证许可授权是否生效。

u宝信公司外部用户申请，方式如下：

1.用户代表填写《iHyperDB许可证申请表》（申请表可邮件到product@baosight.com索取或者咨询产品供应商）

²确定申请的授权主机个数

²获取数据节点服务器mac地址

2.将填写好的申请表通过传真或邮箱发送至产品供应商，具体联系方式请询问产品提供商。(一般情况，许可证可以在2～5个工作日内完成签发，特殊要求请与当地产品供应商说明。)

3.获得采购中心提供的授权介质。

4.现场部署许可证。

²注意文件许可证的名字必须是License.xml

²存放目录是安装目录的config文件夹

5.重新启动iHyperDB数据节点服务，验证许可授权是否生效。


硬件许可证的使用

Navigation: 开始使用 > 许可证的申请和使用说明 >

硬件许可证的使用

 Return to chapter overview

硬件许可证以硬件狗uKey形式交付给用户。

通常插在数据节点计算机USB口，计算机会自动安装硬狗uKey驱动，重启服务，系统将自动识别硬狗中的授权系信息。

硬件驱动安装界面如下图：

u手动安装硬件狗驱动过程：

v在开始菜单->iHyperDB中选择“硬件狗ukey驱动安装”，点击“硬件狗uKey驱动安装”；

v第一次安装，会弹出一个黑窗口，等待安装完毕，黑窗口消失。第二次安装则不会出现任何窗口；

v安装后可以启动iHD服务端；

v点击“开始菜单->iHyperDB->数据节点服务管理工具”，验证许可证是否生效。通常重启服务后，许可证会自动识别，如下图。

u许可证升级更新过程：

v首先点击开始菜单应用快捷方式中的“硬件狗许可证升级更新”工具，如下图；

v点击“采集许可证信息”获取原许可证信息码，并将原许可证信息码发送给产品供应商；

v待产品供应商获取许可证升级码，然后再运行此升级工具，将升级码拷贝粘贴进“升级许可证”的输入框，如下图；

v点击“升级许可证”按钮自动更新硬件狗许可证信息；

v升级更新许可证信息后重启服务端程序，用许可证查看工具验证新的许可证信息是否生效。

注意：

启动时无狗，中途插上狗后，必须重启系统，许可证方可生效；

启动时有狗，中途被拔掉，在监测周期内重新插上，IHD在监测周期内恢复正式狗；当前监测周期为30分钟；

启动时有狗，中途被拔掉，重新插上的时间超过2小时的试用周期，则必须重启系统，许可证方可重新生效；

使用硬件许可证时，不能使用远程桌面启动服务端程序。


系统启动和关闭

Navigation: 开始使用 >

系统启动和关闭

 Return to chapter overview

u配置中心服务启动

u数据节点服务启动

u客户端启动

u采集端启动

u系统关闭

u配置中心服务启动：

配置中心服务如果和数据节点服务同服务器，则可以用数据节点服务管理工具进行启动和停止，如果是独立计算机部署，可以从windows服务管理中启动服务hd3ConfigCenter，如下图：

u数据节点服务启动

实时数据库数据节点安装成功后，打开“开始菜单-数据节点服务管理工具”，如下图:

启动系统的方式：

v服务方式：在服务端管理工具的“服务管理”界面，先“安装服务”，然后“启动服务”。

注意：

²服务启动后在许可证正确的情况下会一直运行；

²服务在计算机开机后自动运行；

²安装完服务端以后，在开始启动菜单栏中可以点击【查看Windows服务】从windows操作系统的服务管理中查询服务运行状态。

v进程方式：如果不希望安装为windows服务，则可以通过手工启动进程的方式。在服务端管理工具中进入“进程管理”界面，全选所有进程，点击“启动”即可。

详细请参考：数据节点服务管理工具

u客户端启动

实时数据库客户端提供一个系统管理工具，在安装完成后打开“开始菜单-系统管理工具"。如下图，首先需要连接服务端，参考连接管理。

u采集端启动：

参见：

vmodbus采集器

vOPC采集器

v关系数据库采集器

u系统的关闭

v服务端关闭：

²数据节点服务的停止，可以通过 数据节点服务管理工具。

²配置中心服务如果和数据节点服务安装在一个计算机，则可以通过 数据节点服务管理工具来管理。 否则，需通过Windows系统服务管理来停止服务。或者，“开始菜单”->“所有程序”->“iHyperDB”->“强制退出所有进程”，这样将同时退出客户端进程。

v客户端关闭：

²客户端程序，均可在界面上点关闭或退出。


数据节点服务管理工具

Navigation: 开始使用 > 系统启动和关闭 >

数据节点服务管理工具

 Return to chapter overview

“数据节点服务管理工具”运行于数据节点服务器，用来提供对服务、进程、系统参数配置、许可证等等信息的实时展示功能，是一个数据节点服务管理平台。共分为三大模块：服务管理、进程管理、系统参数。

u服务管理

u进程管理

u系统参数

u服务管理

v主界面：

注：服务端运行时不依赖该工具，即管理工具退出并不会关闭服务端程序。

v服务启/停/安装/卸载操作

²启动服务：启动所有已安装的服务。如果服务正在运行，不做重启操作。

²停止服务：停止所有正在运行的服务，弹出窗口提示所有已停止的服务的数量和名称。

²安装服务：安装所有服务，安装成功后，弹出窗口提示安装完毕、重启计算机。

²卸载服务：卸载所有服务，卸载成功后，弹出窗口提示所有已卸载的服务名称。

²刷新：手动刷新，并显示最新参数。

v系统信息展示

²内核与网络服务信息：内核(Kernel)与网络(NetMgr)进程均在运行，显示“内核与网络服务正在运行”；如果其中至少一个停止运行，则显示“内核与网络服务未启动”；数据库安装完成后第一次启动，由于数据文件创建需要时间，因而首次启动时，会显示“内核与网络服务正在启动中”。每5秒刷新，这两个进程为数据库最重要的两个进程，任一不在运行，数据库将停止服务，数据库管理员请关注此项信息。

注意：此处仅为服务管理，若服务工作不正常，请检查内核与网络进程是否已经以其他方式启动。

²系统信息：该处实时显示系统的一系列运行状态，每隔5秒更新。显示的内容有：

·系统CPU利用率（%）：当前操作系统CPU利用率

·内核服务进程CPU利用率（%）：hdKernel的CPU利用率

·网络服务进程CPU利用率（%）：hdNetMgr的CPU利用率

·系统内存利用率（%）：当前操作系统内存利用率

·内核服务进程内存使用量（KB）：hdKernel的内存使用量

·网络服务进程内存使用量（KB）：hdNetMgr的内存使用量

·系统网络流入（KB/s）：当前操作系统的网络数据流入量

·系统网络流出（KB/s）：当前操作系统的网络数据流出量

·网络服务进程网络流入（KB/s）：hdNetMgr的网络数据流入量

·网络服务进程网络流出（KB/s）：hdNetMgr的网络数据流出量

·归档分区空间使用量（GB）：归档文件所在分区己使用的空间大小

·归档分区空间剩余量（GB）：归档文件所在分区剩余的空间大小

·本机时间：当前计算机系统时间

·系统信息更新时间：最后一次获取系统信息（即获取系统点内存快照）的时间

²许可证信息：该处实时显示许可证的信息，系统启动时更新。显示的内容有：

·许可证类别：显示许可证是否有效；

·允许的最大客户端连接数：已连接的客户端数/限定最大的连接数，前者不能超过后者，后者比实际签发的许可证文件中连接数多1，因为管理工具本身需要占用一个连接；注意采集器如果和服务端不在一个计算机则另外需要一个客户端连接；

·允许最大的Tag点数：已添加的Tag数/限定最大的Tag数，前者不能超过后者；

·支持组态：是否允许组态客户端获取数据；

·支持SPC：是否允许web客户端获取SPC报警；

·许可证有效期：许可证到期时间，超过此时间，系统将无法运行；

·版本信息：显示安装的版本信息。

u进程管理

“进程管理”模块用于实时展示所有服务和进程的运行情况、停止和启动操作，每隔5秒钟更新。

注意：数据库安装完成后第一次启动，由于数据文件创建需要时间，因而首次启动时，hdKernel和hdNetMgr会显示“正在启动中”。此步骤会耗时几分钟，待数据文件创建完毕，状态会变更为“正在运行”。具体耗时与安装配置单个数据文件大小有关，若很长时间不变，很有可能是数据库因参数设置有误，而没有正确安装，导致启动失败。

v进程管理所展示的信息包括：

²进程名称：服务名称。

²进程ID：服务对应进程都有对应的PID。

²服务描述：描述服务的作用。

²启动方式：有“服务方式”和“进程方式”两种状态。

²状态：kernel服务有“正在运行”、“已停止””、“正在启动中”三种状态，其它服务只有前两种状态。除了kernel进程有“正在启动中”状态，其它进程只有“正在运行”一种状态。如果既不是进程也不是服务则显示空白。

²显示/隐藏窗口：只正在运行的进程此列才有按钮显示，其他情况均为空白。单击“显示”按钮，弹出Cmd黑窗口；单击“隐藏”按钮，Cmd黑窗口隐藏，但是仍将在后台运行。

v进程操作：

²启动：当安装成服务时，此处为启动服务；当安装成进程时，此处为启动进程；

²停止：当安装成服务时，此处为停止服务；当安装成进程时，此处为停止进程；

v其他说明：

²第一次进入进程管理模块时，所有的进程都显示窗口；

²非第一次进入进程管理模块时，进程的窗口状态按照实际的状态显示。

²启动进程时默认隐藏窗口的形式启动。

²停止服务时，如果有正在运行的服务依赖这个服务，那么弹出提示确认是否停止这些服务。

v以下罗列几种可能的状态以及显示效果：

²既不是进程也不是服务：

²进程：

²服务：

u系统参数

“系统参数”模块用于显示和配置系统的参数。

主要参数说明：

v网络服务端口：当前数据节点服务端口号，范围1025—65535，且不与计算机上其他程序冲突。

v归档文件个数：最小为当前配置归档文件数，最大不超过500个,归档文件个数为3~500整数,且不能小于原值,

v序列缓存刷新频率：不小于300秒

v自动断开无数据交互的连接：iHyperDB断开没有交互请求客户端的超时时间

v超时时间：不小于60秒，不能大于65535秒

v采集系统信息：iHyperDB更新系统信息间隔

v采集间隔：系统信息收集间隔不能小于30s

v丢弃超过服务器时间戳的数据：丢弃比当前服务器时间加上时间偏差更新的数据；例如：如果勾选改选项，配置偏差为3600s，数据时间超过服务器机器时间3600s，则该条数据就会被过滤掉，不会存储到实时数据库中。

v时间偏差（秒）：配置数据时间大于本机时间的秒数。默认值为1800s，不能大于31536000。

v丢弃过旧时间的数据：丢弃比当前服务器时间减去时间偏差更旧的数据

v时间偏差（秒）：配置数据时间减去本机时间的秒数。默认值为1800s，不能大于31536000

v冗余缓存文件大小：缓存主备同步数据文件大小

v冗余缓存文件路径：缓存冗余数据文件保存路径


客户端应用介绍

Navigation: 开始使用 >

客户端应用介绍

 Return to chapter overview

为了方便用户的使用，在安装完毕后，给用户提供一些便捷的客户端应用，可以从开始菜单打开，如下图：

主要包含如下内容：

uModbus采集器配置工具

uODBC数据源配置

uOPC采集器配置工具

uSQL查询工具

u报警查看客户端

u关系库采集器配置工具

u启动转储到数据库进程

u数据节点网络连接监控工具

u组态运行客户端


客户端服务管理工具

Navigation: 开始使用 > 客户端应用介绍 >

客户端服务管理工具

 Return to chapter overview

客户端服务管理工具是一个通用的将客户端程序安装成服务的工具。

u客户端服务管理工具的使用

u客户端服务管理工具界面介绍

u客户端服务管理工具的使用

如下图：

在命令行中输入如图参数即可。说明如下：

vhdClientServiceManager，exe：运行客户端服务管理工具。

vhdRDBExporter：需要安装为服务进行管理的程序。此处也可以是其他的程序，比如hdBuffer等。

v"C:\iHDB\executable"：程序所在磁盘位置。

v转储到关系数据库：在客户端服务管理工具上显示的描述。

u客户端服务管理工具界面介绍

在开始菜单的实时数据库的客户端快捷链接里点击“启动转储到关系数据库进程”这一链接（当点击其他客户端进程的快捷连接时，则管理对应的服务）

弹出该工具，界面如下：

操作说明：

1.安装：将所管理的文件装成服务。

2.卸载：将已安装的服务卸载。

3.启动：如果已安装成服务则启动服务；如果没安装成服务则启动进程。

4.停止：如果已安装成服务则停止服务；如果没安装成服务则停止进程。

5.刷新：重新获取服务的状态。

状态显示（该工具根据服务和进程的状态，会显示3种状态）：

1. 服务未安装

2.服务-已停止：表示已安装成服务，但是未启动。

3.服务-正在运行：进程-正在运行


系统管理

功能明细

Navigation: »No topics above this level«

功能明细

 Return to chapter overview

《功能明细》下面介绍实时数据库详细功能：

u系统管理工具介绍

u连接管理

u数据节点配置

u数据源管理 ：包括基本点，统计点，报警点，计算点，SPC报警点，数字状态集等。

u数据采集 ：包括OPC采集，modbus采集，关系型数据库采集，客户端缓存等。

u数据查询 ：包括系统管理工具查询，通过excel查询，ODBC和SQL查询，报警查看等。

u数据展示 ：包括电子表格，组态展示等。

u数据分析 ：包括统计与计算，报警，SPC报警等。

u数据保存 ：包括存储引擎，数据转储，大数据采集器安装及配置等。

u数据接口 ：包括OPCServer，COM接口，ODBCDriver等。

u数据安全：包括配置和数据备份，配置和数据恢复，数据节点冗余等。

u权限管理 ：包括用户与组管理，信任管理，管理权限，数据源权限管理等。

u升级工具：配置升级，数据升级。


系统管理工具介绍

Navigation: 功能明细 >

系统管理工具介绍

 Return to chapter overview

系统管理界面

此时，默认不显示消息栏

u菜单栏介绍：菜单栏包括文件、视图、工具、帮助四个按钮。

v文件

²连接：管理请参考连接管理 。

²退出：直接单击退出就可以直接关闭系统管理平台页面。

v视图：包括工具条，消息，任务面板，勾选复选框后界面就会显示所属界面。

v工具：包括连接管理、数据节点配置、采集器配置工具、报警查看、数据节点连接监测工具、错误码查询。

²错误码查询工具查询方法如下：

菜单中选中“错误码查询”弹出“错误码查询”对话框,输入需要查询的错误码，点击查询，在错误信息中显示错误码信息。

v帮助：包括帮助及关于。

其中“关于我们”可以查看当前连接的数据库许可证支持的总点数、产品网站、当前版本号等信息；

u工具条：包括服务器连接管理器、数据节点配置、采集器配置工具、数据节点连接监测工具、错误码查询五个按钮。

u任务面板：包括采集、数据源、报警、数据转储、权限、分发配置。

v采集：采集器状态查询。详细配置参见数据采集。

v数据源：Tag变量配置、数字量状态集、实时记录查询、历史记录查询。详细参见数据源配置 。

v报警：报警组管理、SPC报警点。详细参见报警。

v数据转储：关系数据库、转储脚本配置。详细参见数据转储。

v权限：用户与组、管理权限、信任。详细参见权限管理。

v分发配置：节点管理、组态管理、WEB升级包管理。详细参见组态展示。


连接管理

Navigation: 功能明细 >

连接管理

 Return to chapter overview

“服务器连接管理器”是实时数据库系统中的一个基础模块，是连接数据库服务端的客户连接窗口。下面将详细介绍如何操作系统管理工具中的“连接”功能，即：服务器连接管理器。

服务器连接步骤：

1.开始菜单打开“系统管理工具”

2.随即出现系统管理平台的“服务器连接管理器”界面如下：

3.该“服务器连接管理器”界面也可通过点击“系统管理平台”的“连接”图标打开：

4.单击服务器连接管理工具的修改按钮，在服务器列表可以修改需连接的数据库服务器IP地址、备份IP、端口号、连接超时、数据访问超时。设置好以后单击保存按钮。

5.在“服务器连接管理器界面”的“状态”勾选框，点击勾选，弹出用户登录界面，输入用户名及密码（初始用户名/密码为：admin/admin），点击确定按钮，即可登录服务器。


数据节点配置

Navigation: 功能明细 >

数据节点配置

 Return to chapter overview

系统管理工具提供数据节点配置功能(入口参见连接管理),本章节介绍如何为分布式iHyperDB系统配置多个数据节点信息。点击系统管理工具上方的“数据节点配置”图标，打开“数据节点配置”界面，如下图：

本章包含以下介绍：

u添加节点

u修改节点

u删除节点

u添加节点

v在系统管理平台界面-工具条点击“数据节点”图标，如图所示：

v弹出数据节点配置界面，点击“添加”按钮

v弹出数据节点配置界面，填写相关参数：

参数说明：

²节点名称：自定义，如local；

²主IP：主机IP

²主端口号：默认为5678

²备IP：备机IP

²备端口号：默认为5678

²许可证允许最大点数：以实际为准填写

v配置完毕，点击“确定”按钮，完成节点新增操作。

u修改节点

v在系统管理平台界面-工具条点击“数据节点”图标，如图所示：

v弹出数据节点配置界面，点击修改按钮：

v选择数据节点配置记录，点击修改按钮，弹出节点信息配置界面。

v修改相关信息，点击确定按钮，完成修改操作。

u删除节点

v在系统管理平台界面-工具条点击“数据节点”图标，如图所示：

v弹出数据节点配置界面，选择数据节点配置记录，点击删除按钮。

v如要删除，点击确定按钮即可。

需要注意的是：

1.如果配置单机版的数据节点，IP可以配置成127.0.0.1，客户端、服务器、数据节点必须要装在同一台机器上；

2.如果配置的是非单机版的数据节点，客户端与服务器不再同一台机器上，IP必须设置成本机实际IP。


节点监测工具

Navigation: 功能明细 >

节点监测工具

 Return to chapter overview

“节点监测工具”是实时数据库系统中的一个基础模块，可以选择查看“数据节点”及“配置中心”的连接信息等内容，具体如下：

使用方法如下：

1.开始菜单打开“系统管理工具”

2.点击左上角“节点监测工具”图标，如图所示：

3.在弹出窗内点击1处登录按钮，随即在2处弹窗内进行登录操作；

4.成功登录后，可以进行节点选择；

· 若选择数据节点，可以查看节点连接信息，界面包含系统信息，系统参数页面，表格中显示连接客户端MAC地址

· 若选择配置中心，则显示配置中心连接信息，界面没有系统信息，系统参数Tab，表格中去除MAC地址，详细中显示连接客户端端口


Web客户端

Navigation: 功能明细 >

Web客户端

 Return to chapter overview

本章详细介绍了Web客户端的相关功能。

u 客户端预先准备

u Web端相关操作

u 客户端预先准备

1.用户注册与权限关系配置

2.用户组关系配置

3.资源组与用户组，资源组与tag点关系配置

u WEB端操作

u 数据源配置及用户登录

u 访问配置及应用禁用

u tag点的配置

u tag点记录查询及导出

u 监控运维信息查询

u 数据服务请求履历监控

u 数字量状态集管理

u web端ihd权限配置


环境安装部署

Navigation: 功能明细 > Web客户端 >

环境安装部署

 Return to chapter overview

本章详细介绍了iHD的Web客户端组件的安装部署过程

uLinux安装

uWindows安装

u脚本执行

uRPCServer接口配置

u Linux安装

1.解压压缩包；

2.运行install.sh安装

install会自动安装tomcat、java、部署hdWeb文件、建立共享目录以及设置tomcat服务启动等；安装目录是/data/hdWeb/下

u Windows安装

1.解压压缩包；

2.使用管理员权限运行install.bat

install会自动安装tomcat、java、部署iplat文件、建立共享目录以及设置tomcat服务启动等

服务名称：hdweb-tomcat（在任务管理器的服务中可以查看）

安装目录是C:\hdweb\下

u 脚本执行

i.mysql数据库

LINUX安装包的脚本在hdWeb.tar.gz 解压的Packages下的hdWeb-sql.tar.gz的文件中，WINDOWS安装包的脚本在解压所得的Packages下的hdweb-sql.zip的文件中，下面包含了4j-smart以及hdWeb的初始化脚本，先执行4j-smart下的脚本，再执行hdWeb下的脚本，执行时按版本号由小到大执行脚本。

可直接使用dbeaver数据库连接mysql数据库并运行相关脚本。

注：mysql在创建函数时，用到了delimiter重定义结束符，如直接在命令行中执行mysql脚本，则可直接执行，如使用dbeaver等工具(dbeaver中的mysql驱动不支持使用分号作为 delimiter)，则需要把结束符改为$$（即图中1和2分别改为delimiter $$和$$）后再执行脚本。

§配置修改

1.修改数据库配置文件

Linux下访问/data/hdWeb/hdWeb-tomcat/webapps/hdWeb/WEB-INF/classes/

WINDOWS下访问C:\hdweb\hdweb-tomcat\webapps\hdweb\WEB-INF\classes\

打开路径下的application.properties文件,并修改图中几处配置：

a.为组件名称

b.为schema名称（使用sqlite3时均为main，使用mysql时分别为iplat和iplatdb）

c.为数据库连接方式：

i.jdbc：放出第一行，注释后两行，并修改4中的数据库连接参数

ii.jndi：注释第一行，放出后两行，并修改tomcat配置文件server.xml中的数据库配置

d.为数据库驱动名称、地址、用户名、密码（使用sqlite3时地址为其.db文件在本机的绝对路径）

§修改Tomcat配置文件

打开tomcat安装目录下的conf里面的server.xml，并修改图中1和2处的配置。

1.为数据库配置，如连接方式为jndi，需要修改的配置项为driverClassName、username、password、url，如连接方式为jdbc，则无需修改

u数据库为mysql：

则driverClassName为com.mysql.jdbc.Driver，username和password按实际填写，url为jdbc:mysql://127.0.0.1:13306/iplat?useUnicode=true&characterEncoding=utf-8&useSSL=false，其中红色部分按实际填写

u数据库为sqlite：

则driverClassName为org.sqlite.JDBC，username和password按实际填写，url为jdbc:sqlite:/database.db，其中红色部分为数据库文件路径，按实际填写

2.为资源路径配置。

第一行不动，

第二行docBase改为服务器上存放静态资源的全路径，path为web端映射的资源routing。

u RPCServer接口配置：

RPCServer通过ICE提供状态查询的相关接口，BB调用该接口将查询ihd配置状态

1.配置文件如下：

# The server creates one single object adapter with the name

# "HDConfigHandler". The following line sets the endpoints for this

# adapter.

#

IdentityName=HDConfigHandler

ihd.request.timeout=30

ihd.connection.timeout=30

ihd.connection.primary=admin:admin@168.2.8.173:5673

ihd.connection.backup=admin:admin@168.2.8.174:5673

HDConfigHandler.Endpoints=tcp -p 30000:udp -p 30000:ws -p 10002

#

# Warn about connection exceptions

#

Ice.Warn.Connections=1

Ice.ThreadPool.Server.Size=5

Ice.MessageSizeMax=102400

参数说明：

v ihd.request.timeout：请求超时时间，单位为秒。

v ihd.connection.timeout：连接超时时间，单位为秒。

v ihd.connection.primary：主机配置，格式为：用户名:密码@IP:端口

v ihd.connection.backup：备机配置，格式为：用户名:密码@IP:端口；单机时填空即可；

v HDConfigHandler.Endpoints：配置服务对外端口，一般只需修改tcp端口即可。

v Ice.Warn.Connections：设为1时，记录断开连接信息，一般不需更改

v Ice.ThreadPool.Server.Size：服务端同时处理ICE连接数，一般不需更改

v Ice.MessageSizeMax：ICE最大消息大小，单位为KB。


数据源配置及用户登录

Navigation: 功能明细 > Web客户端 >

数据源配置及用户登录

 Return to chapter overview

本章详细介绍了客户端数据源配置及用户登录与注销方法：

u 数据源配置

u 登录账号

u 注销账号

u 数据源配置

1.iHD数据源注册与关系获取

左侧实时数据源目录树中的数据源的权限信息均会在tomcat启动过程中预加载到java内存中，绿色标记即为连接成功，红色标记则为连接失败。

数据库已保存的数据源信息当连接成功时，会在tomcat启动自动获取所属数据源的权限信息；

如页面新增或初始化失败的数据源，当能连接后，刷新树即可自动加载获取有关权限信息

2.新增数据源

当需要新增数据源时，可以在树中右键实时数据源节点，选中“添加数据源”，在弹出框中输入有关信息点击“确定”即可。

3.修改数据源

当需要对已有数据源信息进行修改时，可右键点击目标节点，选择“修改数据源”，对相关信息修改成功后点击保存即可。

4.删除数据源

当需要对已有数据源信息进行修改时，可右键点击目标节点，选择“删除数据源”。

u 登录账号

左键选中可连接的数据源后，点击下方登录按钮，在弹出框中输入账号和密码，点击“确定”即可完成该用户的登录。（切换用户可点击用户头像重新登陆即可）（注：未登录账号将不允许进行其他操作）

u 注销账号

右键点击数据源，即可注销当前登录账户；


访问配置及应用禁用

Navigation: 功能明细 > Web客户端 >

访问配置及应用禁用

 Return to chapter overview

访问配置：访问配置功能主要用于用户生成及查询客户端id和密钥，客户端id和密钥在用户调用webapi服务时需要作为参数传入以校验是否具备对应的操作权限。

u 管理员群组用户

u其他群组用户

u应用禁用

u 管理员群组用户：

当用户以管理员群组的某用户名登录数据源后，右击目录上的数据源节点，弹出下拉菜单，点击访问配置选项，在弹出界面中会展示当前数据源下所有用户的访问配置信息，用户可以单击表格中的查看或编辑图标对表格中具体某个用户的访问配置信息进行查看或配置。

·首先登录数据源

使用管理员账号/密码登录数据源

·配置访问权限

右键点击相应数据源，点击“访问配置”，在访问配置界面点击编辑配置相应权限；

输入相应应用名称，点击“获取访问配置”可以获取到相应客户端id和秘钥；

u 其他群组用户

当用户以其他群组的某用户名登录数据源后，右击目录上的数据源节点，弹出下拉菜单，点击访问配置选项，在弹出界面中会展示当前数据源下登录用户的访问配置信息，如访问配置信息未配置，则允许用户进行配置，否则仅允许用户查看。

·首先登录数据源

使用个人账号/密码登录数据源

·配置访问权限

右键点击相应数据源，点击“访问配置”，在访问配置界面点击编辑配置相应权限，输入相应应用名称，点击“获取访问配置”可以获取到相应客户端id和秘钥；

u 应用禁用

应用禁用功能允许用户对访问配置中用户绑定的应用进行启用或停用（默认启用），停用后，用户使用对应的客户端id和密钥调用webapi服务时会被告知没有操作权限，调用失败。


Tag点的配置

Navigation: 功能明细 > Web客户端 >

Tag点的配置

 Return to chapter overview

本章介绍了Web客户端Tag点的相关配置查询操作，具体如下：

u Tag点基本信息查询

u Tag点属性查询

u Tag点属性修改

u 删除Tag点

u 新增Tag点

u Tag点基本信息查询

查询数据源下tag点基本信息：配置相关查询条件点击查询按钮即可获得所有相关tag点。

u Tag点属性查询

需进行上一步基本信息查询后在页面表格中的操作栏中点击“预览”的按钮，弹窗显示其具体属性信息

u Tag点属性修改

Tag点属性展示后默认不可编辑状态，当需要对属性进行修改时，点击右下角编辑按钮，可修改属性对应输入框将转为可编辑状态，编辑后，点击“保存”即可完成对该点属性的修改。

u Tag点的删除

Tag点基本信息查询成功后，在表格中勾选该tag点，点击表格上方的删除按钮即可删除所选的tag点

u Tag点新增

单击tag点表上方的新增按钮，在弹窗中键入/选择有关tag点配置的相关信息，点击右下方的“确认添加新tag点”按钮


tag点记录查询及导出

Navigation: 功能明细 > Web客户端 >

tag点记录查询及导出

 Return to chapter overview

本章介绍了Web客户端Tag点如何查询记录值并导出相关记录信息，详情如下所示：

u 记录查询

u 导出文件

u 记录查询

点击“记录查询”按钮，进入相关页面，先点击“选点”按钮，把需要使用的点缓存到“tag点表”的缓存区域，再勾选后进行相关查询点记录条件配置，完成后点击查询即可查询到有关记录。

u 导出文件

支持根据查询条件对实时记录与历史记录导出查看，且同时支持PDF和Excel两种形式：

1.实时值：

勾选需要导出的tag点名称再点击“导出”按钮后，选择需要导出的文件形式即可在平台默认下载路径中获得该文件。（注：条数=tag点数）

2.历史值：

根据需要配置查询条件后，点击“导出”按钮，配置导出参数，即可获得该查询条件与导出参数共同作用下ihd中所有数据。


监控运维信息查询

Navigation: 功能明细 > Web客户端 >

监控运维信息查询

 Return to chapter overview

Web客户端支持查看监控运维信息，其中包括客户端连接数、系统信息、系统参数等具体信息。

u 监控运维信息查询功能支持用户选择数据源，点击“监控运维信息”按钮，选择节点

1）查询其已连接客户端及其详细信息、系统信息、系统参数。

2）点击“刷新”按钮，刷新节点下已连接客户端及其详细信息、系统信息、系统参数

3）点击“过去24小时cpu和内存占用趋势”按钮，查看数据源当前节点下过去24小cpu和内存的变化趋势及平均值


数据服务请求履历监控

Navigation: 功能明细 > Web客户端 >

数据服务请求履历监控

 Return to chapter overview

数据服务请求履历监控功能主要用于给用户提供历史请求的详细调用信息及趋势图展示，以帮助用户判断是否需要禁用相应的应用。

u 详细说明：

·系统每60秒会执行一次定时任务，查询过去60秒内所有调用webapi接口的详细信息（包括执行时间，返回包大小，应用名称等），并存入数据库中。

·用户可以对表格内的请求信息进行排序和筛选以得到自己需要的信息。

·点击服务id字段下的任意一条数据，会筛选出当前选择服务id的请求数据，并在弹窗中以文本和趋势图的方式进行展示，帮助用户进行应用禁用决策。


数字量状态集管理

Navigation: 功能明细 > Web客户端 >

数字量状态集管理

 Return to chapter overview

Web客户端支持数字量状态集管理及查看，详情如下：

u 新增数字状态集

u 删除数字状态集

u 修改数字状态集

u 新增数字状态集

右键单击“数字状态集”节点，选择添加按钮；在弹窗中输入添加的数字状态集名称，点击确定即可。

u 删除数字状态集

右键单击需要删除的节点，选择删除按钮；在弹窗中点击确定即可。

u 修改数字状态集

a.新增数字状态：选中需要修改的数字状态集树节点后，在右侧表格中，点击新增按钮，填入所需信息点击保存即可。

b.修改数字状态：选中需要修改的数字状态集树节点后，在右侧表格中，勾选相应的数字状态进入编辑态，修改完成后点击保存即可。

c.删除数字状态：选中需要修改的数字状态集树节点后，在右侧表格中，勾选相应的数字状态点击删除并在窗口中选择确认即可。


权限配置

Navigation: 功能明细 > Web客户端 >

权限配置

 Return to chapter overview

《权限配置》主要分为四个部分；分别介绍了如何配置用户、用户组、资源组、信任几部分的权限。

u 用户配置

u 用户组配置

u 资源组配置

u 管理权限配置

u 信任配置

u 权限配置刷新

u 用户配置：

1、新增用户

支持用户新增用户，需要输入用户名、密码、描述

2、删除用户

支持用户删除用户

3、修改用户

支持用户修改用户属性，包含用户名、描述、绑定及解绑用户组

4、修改密码

支持用户修改密码（需要输入旧密码，如旧密码不匹配，会提示修改密码失败）

5、重置密码

支持用户重置密码（无需输入旧密码）

u 用户组配置：

1、新增用户组

支持用户新增用户组，需要输入用户组名、描述

2、删除用户组

支持用户删除用户组

3、修改用户组

支持用户修改用户组属性，包含用户组名、描述，绑定及解绑用户

u 资源组配置：

1、新增资源组

支持用户新增用户组，需要输入资源组名、描述，选择资源组权限

2、删除资源组

支持用户删除资源组

3、修改资源组

支持用户修改资源组属性，包含资源组名、描述、绑定的权限，绑定及解绑用户组，绑定及解绑tag点

u 管理权限配置：

修改管理权限：支持用户勾选（勾选表格中的管理权限和点击表格行选中管理权限均可）并修改管理权限，其中权限列的含义为：

u 信任配置：

1、新增信任：支持用户新增一个信任，信任名、起始IP、结束IP需要为唯一

2、删除信任：支持用户勾选（勾选表格中的信任和点击表格行选中信任均可）并删除信任

u 权限配置刷新：

用户在ihd管理与配置页面点击权限配置按钮时，会查询并渲染最新的权限信息。每个权限项的tab页下都有刷新按钮，点击能够查询并渲染最新的权限信息。

如下图所示：


数据节点配置

Navigation: 功能明细 > Web客户端 >

数据节点配置

 Return to chapter overview

数据节点配置支持对数据源下的数据节点进行增删改查，配置项包含：节点名、主IP、主端口号、主机名、备IP、备端口号、备机名、许可证允许最大点数、描述

u 查看数据节点

u 新增数据节点

u 修改数据节点

u 删除数据节点

u 查看数据节点

支持用户右击已登录数据源，点击下拉菜单中的数据节点配置选项，并在弹窗中查看当前数据源下的数据节点

u 新增数据节点

支持用户新增数据节点，点击“新增”按钮，配置相应节点信息，点击“保存”即可；

参数说明：

v 节点名：数据节点名称（注意：数据节点名不能重复）

v 主IP：数据节点主节点实际IP地址

v 主端口号:数据节点主机端口号

v 主机名：非必填项，主机名称

v 备IP：非必填项，备机IP地址

v 备端口号：非必填项，备机端口号

v 备机名：非必填项，备机名称

v 许可证允许最大点数：指该节点下最多配置的点数，最多允许500万点

v 描述：非必填项，对此节点的描述说明

u 修改数据节点

支持用户修改数据节点。（注意：数据节点名不允许重复，节点名不允许修改）

u 删除数据节点

支持用户删除数据节点


采集器状态查询

Navigation: 功能明细 > Web客户端 >

采集器状态查询

 Return to chapter overview

使用采集器配置查询可以查看相应采集器状态及相应设备状态。

u 采集器状态查询支持用户选中某个已登录的数据源，并查询其采集器状态

u 点击上方表格中的采集器，可以查询采集器下的设备列表


数据源配置-new

数据源配置

Navigation: 功能明细 >

数据源配置

 Return to chapter overview

《数据源配置》主要介绍如何为实时数据库配置各种类型的点，数据源配置是实时数据库采集实时数据的基础步骤，其主要功能就是配置采集实际设备传入的数据所对应的Tag点及其相应的运算。

可以进行以下类型tag的配置：

u普通点

u统计点

u报警点

u计算点

uSPC报警点

另外，还为digital类型的普通点设置了数字状态集管理功能，用于进行数字量和对应字符串的映射。

进行数据源配置，首先需要打开系统管理工具，并进行连接。点击“数据源-Tag变量配置”，打开数据源配置的界面如下:

本章主要介绍以下功能：

u新增tag点

u修改tag点

u删除tag点

u查询tag点

u新增tag点

1.点击上方的 [image] 按钮，弹出tag属性配置页面，如下图：

vTag名称（必填）：Tag点的名称，为字符串。最多127个英文字符，63个中文字符，不能以空格开头，包含中文（含中文标点符号）、数字、英文字母、支持的部分英文特殊字符有':'，'('，')'，'@'，'%'，'#'，'+'，'='，'['，']'，'_'，'.'，'-'。

vTag类别（必填）：可以选择Tag点的类型 。该选项确定了点的类型，不同类型的点需要配置不同的属性，具体参考各点的配置说明。参见普通点 、统计点 、计算点 、报警点 、SPC报警点 。

vTag类型（必填）：只有Tag类别为普通点时需要选择。

v数字量集：只有选择了Tag类别为普通点，Tag类型为Digital时生效，用以配置digital点的值与字符串的对应关系。数字量集的详细配置可参见数字状态集管理 。

v工程单位：Tag点对应的数值单位。

vTag描述：Tag点的描述信息。

2.按照不同的Tag类别配置了对应的Tab页后，点击“确定”按钮，保存Tag点。

v普通点可以配置“采集”tab页。

v统计点可以配置“统计”tab页。

v计算点可以配置“计算”tab页。

v报警点可以配置“报警”tab页。

vSPC报警点可以配置“SPC报警”tab页。

v所有类型的点都可以配置“存储”TAB页。如下图：

²采样方式：

·归档：勾选归档后，该tag点的值会存入归档历史文件中，可以进行历史记录查询。可参见历史记录 。不勾选，则该数据只可查到实时值。

·压缩：勾选压缩后，该tag点的值会进行线性压缩，被压缩掉的记录将不会存储到历史记录中。

·跨度：该点的范围。最小值加跨度即为最大值，即该数据的工程量程。

·最小值：该点的最小值（最小值可为负值）。

²存储压缩：

位于服务端的压缩策略

·误差：进行线性压缩时可接受的压缩误差。图例：填“0.2”，意味着下一数值与上一值差为±0.2以内的新值将不会存储到历史记录中。填“0”，等同于不开压缩。

·超时：若两个连续值超过该时间间隔，不进行压缩。意味着，超过此项时间范围的新值，无论其是否在压缩误差范围内，都会存一个新值在历史记录中。

²采集过滤：

位于采集端的压缩策略

·误差：采集过滤时可接受的误差。

·超时：若两个连续值超过该时间间隔，不进行过滤。

v所有类型的点都可以配置“权限”TAB页。详见“数据源权限管理”。

v所有类型的点都可以配置“系统”TAB页。如下图：

²OPC发布：勾选该选项后，可以在iHDOpcServer中进行OPC发布。

u修改tag点

v在tag列表中选中1条记录，点击上方的 [image] 按钮，弹出tag属性配置页面，对属性进行修改后，点击确定按钮，保存修改。

如需修改点名，则在弹出Tag属性窗口点击重命名，弹出重命名窗口，输入新点名后确定即可，如下图所示：

u删除tag点

v在tag列表中选中1条或多条记录，点击上方的 [image] 按钮，提示是否从服务器删除tag点，点击确定完成删除操作。

u查询tag点

v点击上方的 [image] 按钮，弹出tag点查询界面，如下图：

²查询时，首先要选择点类型，之后查询到的结果均为该类型的点。

²基本查询可以按照Tag名、Tag类型、采集器名、Tag描述进行查询。可以使用通配符*和?，*代表任意字符串，?代表任意字符。

²高级查询只对普通点有效。

v勾选1条或多条记录后，点击确定按钮，查询结果会显示在tag列表中。


基本Tag点

Navigation: 功能明细 > 数据源配置 >

基本Tag点

 Return to chapter overview

iHyperDB的各种Tag点，都可以配置“基本”TAB页，“存储”TAB页，“权限”TAB页，“系统”TAB页，

其中普通点还可以配置采集TAB页。

注意：配置普通点的采集属性前，需要先进行采集器的配置，可参见数据采集 。

采集TAB页配置界面如下：

采集页面主要包括：确认采集复选框、采集器名、设备名、扫描组、设备地址。

u确认采集：当确认采集复选框不勾选时，下面的所有选项均为不可编辑。

u采集器名：下拉菜单中有当前存在的采集器名，当采集器名为空时，扫描组、设备地址均为不可编辑状态。

u设备地址：长度为不超过63个字节的中英文字符。

在为Tag点选择扫描组时，确保所选扫描组中的Tag点的总数在3000以内，否则新加的Tag点会采不到数据，如果超过3000点，请对Tag点进行分组。


统计点

Navigation: 功能明细 > 数据源配置 >

统计点

 Return to chapter overview

统计Tag点，除了配置“基本”TAB页，“存储”TAB页，“权限”TAB页， “系统”TAB页外，还可以配置“统计”TAB页。

本页面主要介绍部分主要功能的使用，统计各个功能的详细说明见统计算法 。

只有在基本页面的Tag类别中选择了“统计点”，该页面才可编辑。

详细说明如下：

u基本TAB页

v基本信息配置

v统计类型配置

v统计时间配置

u其他TAB页

v采样配置

v记录时间戳配置

v过滤表达式配置

v记录值转换系数配置

u基本

ü监测点：手工输入或者单击“选择Tag点”搜索普通Tag点作为统计点的原始点。默认长度为空，长度限制为128。

注：原始点的创建可晚于统计点

ü最小信任度：最小信任范围0-100，默认0，填整数或者小数。信任度指区间质量为good的点所占的百分比高于或等于制定的百分比，认为该记录可信。如果100%，代表统计区间内的必须100%全为good点，此统计点才为good; 如果0%,代表只要统计区间内有good点,此统计点均为good.

·统计类型

可选的统计类型有：最小值、最大值、求和、计数、最新值、可信度、算数平均值、时间加权平均值、积分、差值、极差、标准差。

算法介绍如下：

§最大值

统计区间内最大值

§最小值

统计区间内最小值

§求和

统计区间内所有数据的和

§计数

统计区间内数据的个数。

计数类型包括:

v值变化：如从0到10.只要数字变化时必须有0和10，不论中间是否有其他数字，即计数1。如只有0或10，则不计数；一般用于离散型的数字计数

v从<=到>=:第一个数字必须小于第二个数字，如从<=3到>=10，代表从<=3的数字变化到>=10的数字即计数1；（如一条曲线必须向上同时穿过3和10，才计数）

v从>=到<=:第一个数字必须大于第二个数字，如从>=10到<=3，代表从>=10的数字变化到<=3的数字即计数1；（如一条曲线必须向下同时穿过10和3，才计数）

v在区间：如下限3，上限10，代表如果数字在[3,10)区间内，只要数字变化1次，即计数1；

v不在区间：如下限3，上限10，代表如果数字在[3,10)区间以外，只要数字变化1次，即计数1；

§最新值

统计区间内最后一个数据

§可信度

统计区间内数据质量为good的比例

§算术平均值

统计区间内数据的算数平均值

§时间加权平均值

统计区间内的数据积分，再除以时间，比算术平均值更均匀

§积分

统计区间内点所谓围成的图形面积，通常用来计算流量。其中采样点如果是原值或线性插值，采用梯形法算积分；如果采用前向插值法，采用矩形法积分；

§差值

统计区间内最后一个值减前一个统计区间内最后一个数值

§极差

统计区间内最大值减最小值

§标准差

统计区间内标准差，反映数据偏移平均值的大小

§计时

反映数据在统计范围内的持续时间

ü>:如>10,则记录统计点的值>10的持续时间，单位为S（秒）。

ü其他同理。

·统计时间

§开始时间：默认为当天时间，范围是iHyperDB时间的规定范围。开始时间配置好后，第一个统计时间区间为开始时间之后的第一个完整的统计区间。

§特别的，如果配置今天开始的月统计，第一个月统计区间为今天开始后的第一个完整的月统计区间,如果月统计开始日为开始时间之前，那么第一个月统计区间是下个月，如果想这个月就开始统计，建议将开始时间配置到上个月。

§时间模式：分为定周期、时间追溯、持续三种模式。

v当统计点配置时间模式为定周期的等间隔、每天、每月统计时，只有当等间隔、每天、每月的统计时间结束才有一个统计值，为了能能够尽快的看到统计结果，可以配置一个大于0的计算周期T。计算周期T的作用是在统计时间区间[A,B)的时间范围内，在时间点A+T, A+2*T, A+3T… A+n*T, B分别计算出一个统计值，表示[A,A+T)、[A,A+2*T)、[A,A+3*T)…[A,A+n*T)、[A,B)这些统计时间区间的统计结果，如果计算周期配置为0则只会在时间点B统计[A,B)这段时间的结果。如图

例如每天统计的时间区间配置为0:00:00到24:00:00统计每天的产量，计算周期为3600秒，那么统计点会在每天的整点会统计出每天0:00:00到当前整点的产量，1:00:00统计出今天[0:00:00, 1:00:00)的产量，2:00:00点统计出今天[0:00:00, 2:00:00)的产…在24:00:00统计出今天[0:00:00, 24:00:00)的产量。如果计算周期配置为0，则只会在24:00:00统计出今天[0:00:00, 24:00:00)的产量。

v当统计点配置时间模式为时间追溯时，计算周期必须大于0。例如配置时间追溯模式的统计间隔为B,开始时间为A，计算周期为T，那么在A+B,A+B+T, A+B +2*T…. A+B +n*T时刻都会有一个统计值，分别表示[A, A+B)、[A+T, A+B +T)、[A+2*T, A+B +2*T)…[A+n*T, A+B +n*T)这些统计区间的统计值。如下图：

例如时间追溯模式的时间配置开始时间是2016-5-5 0:00:00，统计间隔是30分钟，计算周期是60秒，那么统计点会从2016-5-5 0:30:00开始每隔60秒算出一个统计值，0:30统计[0:00, 0:30)区间的值，0:31统计[0:01, 0:31)区间的值，0:32统计[0:02, 0:32)区间的值，以此类推进行统计。

v当统计点配置时间模式为持续统计时，计算周期必须大于0. 例如配置持续统计，开始时间为A，计算周期为T，那么在A+T,A+2*T,A+3*T….A +n*T…时刻各有一个统计值，分别表示[A,A+T)、[A,A+2*T)、[A,A+3*T)…[A,A+n*T)…这些统计区间的统计值。如下图：

例如持续模式的时间配置开始时间是2016-5-10 0:00:00，计算周期是60秒，那么统计点会从2016-5-10 0:00:00开始每隔60秒算出一个统计值，0:01统计[0:00, 0:01)区间的值，0:02统计[0:00, 0:02)区间的值，0:03统计[0:00, 0:03)区间的值，以此类推进行统计。

v是否清零：

当统计点配置时间模式为持续时，可以配置是否清零属性，是否清零属性只针对求和和积分的统计类型有效，表示当统计值超过最大值后将统计值进行清零操作恢复为“最小值”。是否清零属性与统计点的基本属性“最小值”和“跨度”相关，清零操作的最大值为“最小值”+“跨度”，清零后统计值变为“最小值”。例如配置持续统计的开始时间为今天00:00:00，计算周期为60秒，最小值为0，跨度为3600，采样方式为原始值，原始点从00:00:00开始每隔1秒有一个值为1的数据。那么从00:00:00开始每隔60秒有一条统计记录，值分别为60、120、180… 3540、3600、0(这里被清零)、60、120、180… 3540、3600、0(这里被清零)、60、120、180…

§统计方式：可选等间隔、每天时段和每月时段，对应不同的配置界面。

v等间隔：统计固定间隔内的数据。

ü等间隔默认为1天，“天”不大于365，“时”不大于23，“分”不大于59，“秒”不大于59.间隔不能为0

v每天时段：统计每天固定时段内的数据。

ü每天时段默认0:00:00到23:59:59，结束时间须大于开始时间

v每月时段：统计每月固定时段内的数据。

注意，每月时段时，配置了本月统计时间，查询不到实时数据值，开始时间配置到上月统计时间，才有值

§扫描周期：扫描周期默认60秒，填写整数，长度限制为10位。

·采样配置

ü使用Bad记录: 选择是否使用Bad记录参与计算。不勾，表示只统计质量为Good的数据；勾选，表示质量为Bad的数据也参与该统计计算。

例如：平均值计算，样本为 0(No Data) 、1(Good) 、2(Bad)

1. 使用Bad记录，停机记录0不参与计算，“2”跟Good值一样参与计算，结果为(1+2)/2 = 1.5

2. 不使用Bad记录，停机记录0、Bad数据2均不参与计算，结果为1/1=1

ü原始值：原始点的数值是什么值，就采什么值。

ü线性插值：从开始时间起经过偏移量时间后，每周期用线性插值的方法计算出一个点，为采样点。

ü前向插值：从开始时间起经过偏移量时间后，每周期05开始，每60秒用前向插值的方法计算出一个点，为采样点。

ü偏移量：开始插值时间与开始时间之间的偏差。

ü周期：插值的计算周期。

·统计结果时间戳的配置:

对统计结果所属时间的调整，我们可以通过配置记录的时间戳来实现，起始偏移和结束偏移只能选择一个。

ü起始偏移：如偏移量为0，则以统计区域的开始时间为时间戳；如果偏移量为5秒，则以开始时间后5秒为时间戳；如偏移量是-5，则以开始时间前5秒为时间戳

ü结束偏移：如偏移量为0，则以统计区域的结束时间为时间戳；如果偏移量为5秒，则以结束时间后5秒为时间戳；如偏移量是-5，则以结束时间前5秒为时间戳然天的每天晚上8点到第二天早上8点统计时段为例（20:00-8:00）。

示例如下：

统计结果的时间戳为第一天晚上7：00:00

统计结果的时间戳为第一天晚上9：00:00

统计结果的时间戳为第二天早上8：00:00

统计结果的时间戳为第二天早上7：00:00

统计结果的时间戳为第二天早上9：00:00

统计结果的时间戳为第3天早上8：00:00。86400 = 3600*24.

·过滤表达式配置

可以将超过一定范围的值剔除，不纳入统计范围。下方表达式为真，则过滤，否则，不过滤

表达式tag名应该有单引号

如：'tag1'>=100,则将大于100的点剔除，不纳入统计。

ü若选择“是”，则此点不参与运算；

ü若选择“否”，则此点参与运算。

·记录值转换系数配置

将统计结果按照一定的系数放大或缩小

ü放大：统计值=实际统计值*系数

ü缩小：统计值=实际统计值/系数

·统计术语：

原始点：被统计的点，为普通点。

ü最小信任度：当统计区间内的数据质量为good的点的比例达到或超过该百分比时统计结果是可信的，统计结果数据质量为good，否则为bad。最小信任度为0时统计结果数据质量均为good。

ü统计类型：对数据进行何种方统计，如统计最大值，平均值等等。

ü统计开始时间：统计点从原始点的这个时刻的数据开始统计。如配置2000-1-1 00:00:00 表示统计点统计原始点从2000-1-1 00:00:00开始往后的数据。

ü统计方式：统计点安装哪种方式进行统计，包括等间隔统计，每天时段统计和每月时段统计。

ü等间隔统计：统计原始点从统计开始时间开始每个固定统计间隔的数据。如统计开始时间为2000-1-1 00:00:00, 等间隔统计时间间隔为60秒。统计点会统计原始点的在[2000-1-1 00:00:00, 2000-1-1 00:01:00），[2000-1-1 00:01:00, 2000-1-1 00:02:00），[2000-1-1 00:02:00, 2000-1-1 00:03:00）…这些区间段的数据。

ü等间隔统计：统计原始点从统计开始时间开始每个固定统计间隔的数据。如统计开始时间为2000-1-1 00:00:00, 等间隔统计时间间隔为60秒。统计点会统计原始点的在[2000-1-1 00:00:00, 2000-1-1 00:01:00），[2000-1-1 00:01:00, 2000-1-1 00:02:00），[2000-1-1 00:02:00, 2000-1-1 00:03:00）…这些区间段的数据。

ü每天时段统计：统计原始点从统计开始时间开始每天固定的时间间隔的数据。如统计开始时间为00:00:00, 结束时间为08:00:00。统计点会统计原始点的在[2000-1-1 00:00:00, 2000-1-1 08:00:00），[2000-1-2 00:00:00, 2000-1-2 08:00:00），[2000-1-3 00:00:00, 2000-1-3 08:00:00）…这些区间段的数据。

ü每月时段统计：统计原始点从统计开始时间开始每月固定的时间间隔的数据。如统计开始时间为1日00:00:00, 结束时间为2日08:00:00。统计点会统计原始点的在[2000-1-1 00:00:00, 2000-1-2 08:00:00），[2000-2-1 00:00:00, 2000-2-2 08:00:00），[2000-3-1 00:00:00, 2000-3-2 08:00:00）…这些区间段的数据。

ü扫描周期：统计服务启动后统计点会每隔一个扫描周期触发一次统计。

ü起始偏移：统计结果的时间戳为统计时间段[A,B）的开始时间A加上起始偏移。

ü结束偏移：统计结果的时间戳为统计时间段[A,B）的结束时间B加上结束偏移


报警点

Navigation: 功能明细 > 数据源配置 >

报警点

 Return to chapter overview

只有在基本页面中的Tag类别中选择了“报警点”，该页面才可编辑。

报警点除了配置“基本”TAB页，“存储”TAB页，“权限”TAB页，“系统”TAB页外，还要配置“报警”TAB页。如下：

·判断条件和报警事件：

判断条件和报警事件默认为空。判断条件1-4和报警事件1-4可以是长度不超过127个字节的中英文字符。规则说明参见判断条件和报警事件。

·监测点：

关联的tag点，用该tag点的值来判断是否触发报警。

·值死区：

值死区支持float类型，正数，长度不能超过15位。

值死区只针对GT和LT类型的报警，

例如：值死区配置为1，条件为GT（10），则当值大于11时触发报警，报警后值小于9时恢复。

·时间死区：

大于0的整数，长度不超过9位，只有当报警触发或恢复超过死区时间后，报警才会触发或恢复。

·判断条件和报警事件：

§4种判断条件类型的含义:

GT | 数值型
LT | 数值型
EQ | 数值型，字符串型
NE | 数值型，字符串型
IS_IN | 数值型
NOT_IN | 数值型

§4种判断条件的填写示例:

GT(10) | 大于10
LT(10) | 小于10
EQ(10) | 等于10
EQ("hello") | 等于hello
NE(10) | 不等于10
NE("hello") | 不等于hello
NOT_IN(10,20) | 不在某个闭区间内
IS_IN(10,20) | 在某个闭区间内

§报警事件：

报警事件包括三部分：优先级，报警类型，确认状态。

ü优先级：1,2,3,4.数值越大优先级越高。

ü报警类型：low,lolo,high,hihi,change。

ü确认状态：ack,unack。

事件的填写示例：1_lolo_unack，以下划线为分隔：1代表优先级、lolo代表报警类型，unack代表确认状态。

©2015. All Rights Reserved.


计算点

Navigation: 功能明细 > 数据源配置 >

计算点

 Return to chapter overview

iHyperDB表达式计算功能介绍

·表达式计算模块为用户提供了一种新的途径对普通Tag点进行计算。用户可以通过客户端配置一个计算点，其表达式关联一个或者多个普通的Tag点，计算服务获取到用户配置的计算点自动计算出表达式的结果，然后保存成计算点的记录，存储到Kernel中。

·系统管理工具提供对计算机点的配置管理功能，包括计算点的创建、删除和修改。计算点的数据类型为int32或者float64两种。

计算点除了配置“基本”TAB页，“存储”TAB页，“权限”TAB页，“系统”TAB页外，还要配置“计算”TAB页。

在创建计算点时，需配置下列信息：

ü计算模式:

轮询--按一定的周期处理计算；

通知--关联的监测点的snapshot发生改变时触发计算。如下图：

ü周期：

计算周期，根据此周期设置定时器对表达式进行计算，计算模式为通知的时候周期不可配置。周期必须小于被过滤点的采集周期

ü变量表达式：

这项是计算的重点，计算服务根据表达式做计算。变量以'标识，如'Tag1'+'Tag2'，目前支持四则混合运算以及关系运算符、逻辑运算符；

ü计算历史：

用户勾选起始时间，表示对计算点的历史数据进行计算；用户可选择是否配置历史数据结束时间。若配置了结束时间，则计算点添加成功后开始计算历史数据，计算时指定区间内有所有历史数据计算完成后，就不再计算。若未配置结束时间，则计算点添加成功后开始计算，计算至最后一条历史记录后，将该点转为实时计算。注意通知模式不支持计算历史。

·变量表达式

表达式计算服务部署在服务端，计算服务根据计算点配置，在计算点的计算周期到达时候，自动触发计算点的表达式计算，并将对应的计算点记录写入实时数据库。

§基本运算

计算服务支持关系运算符，逻辑运算符和位运算符，配置规则如下：

ü在配置的时候对表达式涉及的普通点类型不做校验，但是在计算的时候，不支持string和blob类型的普通点的计算。

ü运算符的优先级（从高到低）如下：

优先级 | 运算符 | 含义
12 | ！ | 逻辑非运算
11 | ~ | 按位取反运算
10 | / | 除
 | * | 乘
9 | >> | 位运算右移
 | << | 位运算左移
8 | > | 大于
 | >= | 大于等于
 | < | 小于
 | <= | 小于等于
7 | == | 等于
 | <> | 不等于
6 | & | 按位与运算
5 | ^ | 按位异或
4 | | | 按位或
3 | && | 逻辑与
2 | || | 逻辑或
1 | ?: | 条件运算符

ü位运算只能用于整型操作数(int8,int16和int32),如果变量的实时值不是整型则会强制类型转换为整型 int32参与计算。另外，对于“<<”、“>>”操作符，表达式'Tag1'>>2和2<<‘Tag1’的意义和计算结果都不相同，配置的时候请注意。

ü关系运算符的运算结果是布尔型的，满足为1，不满足为0。结果可参与逻辑运算，实际上不参与四则混合运算，如果你配置（'Tag1'>=100）+1实际上可能没有意义，但是仍可以得到1或者2这个结果。

ü条件运算符?:可以嵌套，不过要用（）标明运算顺序，例如：

ü'Tag1'>100?'Tag1'-50:'Tag1'+50

ü'Tag1'>100?('Tag1'<50?'Tag1'+50:'Tag1'-50):'Tag1'

ü正负号要用()标明运算顺序，例如：'int8'*(-1)，如没有（）则计算结果不正确.

üIF条件语句表达式,如IF (‘Tag1’>50) THEN (1) ELSE(0);含义如果Tag>50,则该计算点值为1，否则为0；

其中不能缺少else字段， 关键字段后表达式都要括号。

1、大于>、大于等于>=、小于<、小于等于<= 运算符不支持连续操作，如‘TAG1’> 'TAG2'>3,若需要上述处理，可以用(‘TAG1’>'TAG2'）&&（‘TAG2’> 3）；

2、参与计算的点，必须是普通点；

3、计算点的时间戳取表达式中关联的普通点的最新时间戳，表达式关联的普通点取最新的snapshot；

4、如果表达式中的普通点取值正常，计算失败（比如分母为0），则计算点不保存记录；

5、表达式关联的普通点，如果是停机记录也会运算，计算点的数据质量为BAD；

6、计算点表达式配置：如果表达式以西文单引号'开始，请将整个表达式圆括号()包围起来，这样使用Excel配置表达式时，Excel不会将西文单引号'自动过滤掉。例如将'tag1'+1 配置为（'tag'+1).

7、计算表达式支持计算点本身。

§内置函数

点击计算点配置页面的Func按钮弹出内置函数选择对话框，如下图：

ü极大值过滤

支持极大值过滤:根据指定的“阀值”过滤掉“极大值”，将未过滤的点保存。

极大值过滤的函数名称：FilExtream('pt_tag', cal_tag, timeInterval, fValue)。

函数说明：可以输入四个参数

1）：第一个参数：'pt_tag'是第一个参数，为被过滤的点名（必须带单引号，点的类型不可以为string或blob或digital类型）；

2）、第二个参数：cal_tag，为保存过滤结果的点名（即计算点自身点名, 不带单引号）；

3）、第三个参数：timeInterval，为允许过滤的最大间隔(单位秒)；

4）、第四个参数： fValue，为过滤的阈值。

举例：比如FilExtream('pt_tag', cal_tag, 10,40)，代表从起始时间开始，pt_tag的第二个点与第一个点比较，如果两点连线的斜率大于40，则过滤第二个点，如果小于40，则将第二个点保留；将第二个数与第三个点比较，如果两点连线的斜率大于40，则抛弃第三个点，如果小于40，则将第三个点保留。以此类推。 （ 如果某个点之前10秒无点可比较，则将此点保存并作为第一个点供其后点比较。）

1、斜率计算规则(pt_tag.value - cal_tag.value)/(pt_tag.time - cal_tag.time) > fvalue；

2、假设被过滤的点的实际间隔为60秒，则过滤的最大间隔，即第三个参数，要大于60秒。否则，根据过滤原则，过滤间隔前无可比较值，则存储该点，导致无法过滤极大值；

3、假设被过滤的点的实际间隔为60秒，则配置计算属性时，周期时间要小于60秒；否则，计算点过滤时，会跳过某些点，导致无法完全过滤极大值；（以上2和3点的时间间隔无关联）;

4、过滤的阈值一般为比较小的正数；如果阈值是1，则等于是过滤掉斜率角度大于45度以外的点；如果阈值是2，则等于是过滤掉斜率角度大于45度以外的点；因此，如果是较大的正数，或者是负数，则起不到过滤极大值的作用；

5、极大值过滤表达式不推荐和其他表达式如+、-、*、/等使用，适合单独使用运算；

6、遇到数据质量为bad点，不论该点是否超过极大值，均保存，且不参与后续比较。如第二个点为bad，则cal_tag的第三个点和第一个点进行比较，和bad点无关;

示例:

实时数据库中新建普通点pt_tag，

新建计算点ca_tag，计算表达式配置为filextream(‘pt_tag’,ca_tag,60,1);

vpt_tag导入记录，

1)pt_record-> time: 2014-06-20 10:00:00, value:0,quality:good

2)由于是首条记录，在time之前pt_tag没有记录值，所以ca_tag直接保存该条记录，

3)ca_tag记录:ca_record->2014-06-20 10:00:00, value:0,quality:good

vpt_tag继续导入记录，

1)pt_record->2014-06-20 10:00:10, value:5,quality:good

2)该条记录时间戳和ca_tag上一条good记录时间戳相差10s < 60s,故需计算，(5-0)/(10-0) = 0.5<1,所以该条记录不需要过滤，保存。

3)ca_tag记录：ca_record->2014-06-20 10:00:10, value:5,quality:good

vpt_tag导入记录，

1)pt_record->2014-06-20 10:00:20, value:16,quality:good

2)该条记录时间戳和ca_tag上一条good记录时间戳相差10s < 60s,故需计算，(16-5)/(20-10)=1.1>1,超过阈值1，故此条记录过滤，不保存为计算点记录

vpt_tag导入记录，

1)pt_record->2014-06-20 10:00:30, value:15,quality:good

2)该条记录时间戳和ca_tag上一条good记录时间戳相差10s < 60s,故需计算，(15-5)/(30-10)=0.5<1,超过阈值1，所以该条记录不需要过滤，保存

3)ca_tag记录：ca_record->2014-06-20 10:00:30, value:15,quality:good

vpt_tag导入记录，

1)pt_record->2014-06-20 10:01:40, value:110,quality:good

2)该条记录时间戳和ca_tag上一条good记录时间戳相差70s > 60s,超过最长时间间隔，故不需要经过计算，直接保存

3)ca_tag记录：ca_record->2014-06-20 10:00:30, value:110,quality:good

üTagYear(‘pt_tag’);

函数说明：获取点pt_tag的快照时间的年份。

参数说明：点名

üTagMonth(‘pt_tag’);

函数说明：获取点pt_tag的快照时间的月份(1-12)。

参数说明：点名

üTagDay(‘pt_tag’);

函数说明：获取点pt_tag的快照时间的日(1-31)。

参数说明：点名

üTagHour(‘pt_tag’);

函数说明：获取点pt_tag的快照时间的小时(0-23)。

参数说明：点名

üTagMinute(‘pt_tag’);

函数说明：获取点pt_tag的快照时间的分钟(0-59)。

参数说明：点名

üTagSecond(‘pt_tag’);

函数说明：获取点pt_tag的快照时间的秒(0-59)。

参数说明：点名

üTagWeekday(‘pt_tag’);

函数说明：获取点pt_tag的快照时间的星期(1-7)。

参数说明：点名

üTagYearday(‘pt_tag’);

函数说明：获取点pt_tag的快照时间在今年是第几天(1-366)。

参数说明：点名

üTagDaysec(‘pt_tag’);

函数说明：获取点pt_tag的快照时间是今天的第几秒(0-86399)。

参数说明：点名

üTagUnixsec(‘pt_tag’);

函数说明：从1970年1月1日零点到现在的秒数。

参数说明：点名

üPrevVal(‘pt_tag’);

函数说明：获取前一个点值。

例如：配置if((PrevVal('Tag1')==0) && ('Tag1'==1)) then(1) else(NoOutput())表示计算点监控到源点的值从0变到1时保存值1到，否则不计算。

参数说明：点名

üNoOutput();

函数说明：不将计算结果进行保存。

参数说明：无

例如：配置if('Tag1'>100) then('Tag1') else(NoOutput())

表示过滤掉小于等于100的源值

üBadVal(‘pt_tag’);

函数说明：检查数据质量是否为bad，bad返回true，其它返回false。

参数说明：点名

例如：配置if(BadVal('Tag1')) then(NoOutput()) else('tag1')

过滤掉源点数据质量为bad的点

üPreUnixsec(‘pt_tag’);

函数说明：前一条记录的从1970年1月1日零点到现在的秒数。

参数说明：点名

üPreMs(‘pt_tag’);

函数说明：前一条记录的毫秒值，毫秒值在0-999之间。

参数说明：点名

üPreBadVal(‘pt_tag’);

函数说明：前一条记录的数据质量，数据质量为Good返回0，其它返回1。

参数说明：点名

üNoneRecord('pt_tag');

函数说明：函数说明：检查数据点是否存在记录，不存在记录则函数返回true，存在记录返回false。

参数说明：点名

例如：If （NoneRecord（'tag1’））then(1) else('tag1’)

如果tag1没有记录值输出1，如果有记录值输出tag1.

删除内置函数时，只校验SPC报警点，其余类型不校验。


SPC报警点

Navigation: 功能明细 > 数据源配置 >

SPC报警点

 Return to chapter overview

SPC报警点管理主要介绍SPC报警点的属性以及如何创建、修改、删除SPC报警点。其中，SPC报警点配置有两个入口，分别是

1.数据源→Tag变量配置→添加SPC报警点

2.报警→SPC报警点，管理配置SPC报警点

·在数据源管理中添加“spc报警点”

·查看SPC报警点

·在报警管理中添加“spc报警点”

·在报警管理中修改“spc报警点”

·在报警管理中删除“spc报警点”

·在数据源管理中添加spc报警点

打开系统管理工具→数据源→Tag变量配置，点击新增Tag按钮，新增一个名为spc_alarm_tag的报警点，此时Tag类型缺省为digital

点击SPC报警属性TAB页，配置SPC报警点属性

§Tag源点：

SPC报警点的报警来源，必须选择统计点类型，且该统计点的统计类型限定为算术平均值、时间加权平均值、极差和标准差

§图类型：

根据Tag源点所选统计点统计类型的不同显示不同的图类型，当前图类型包括：

1.统计类型为算术平均值、时间加权平均值，图类型为Xbar图；

2.统计类型为极差，图类型为R图；

3.统计类型为标准差，图类型为S图

§自动确认：

默认勾选自动确认

§关联Tag点信息：

勾选需要创建关联Tag点时，选择相关关联点按钮无效，初始值输入框可编辑，关联点名称自动置为SPC报警点名称+后缀名形式；不勾选自动创建关联Tag点时，选择相关关联点按钮有效，初始值输入框不可编辑，相关关联点名称框置为空

注：1.如果勾选自动创建关联点，该点名称已经存在，则弹出提示询问是否关联该Tag点

2.关联Tag点类型必须为浮点型

§判异准则：

默认采用八大国标，取值范围为[1-99]整数，且M值不能小于N值

§判异连续性：

目前只支持连续判异

判异准则的一些说明:

§其中，当UCL-CL=CL-LCL时,A区B区C区示意如下图所示:

§连续判异

序 | 异常类型 | 判异说明 | 临界说明
1 | 一点落在A区以外 |  | 等于UCL或LCL值的点不作为该异常；
2 | 连续9点在中心线的同一侧 | 标注在异常发生的末点上；参与过判异的点，移位后可以继续参与判异 | 等于CL值的点不参与计算
3 | 连续6点递增或递减 | 同2 | 数值相等不计算在递增或递减范围内
4 | 连续14点中相邻点上下交替 | 同3 | 有连续点数据相等，不计算
5 | 连续3点中有2点落在中心线同一侧的B区以外 | 1、连续3点作为前提条件; 2、异常判别用2点落在中心线同一侧的B区以外规则； 3、标注在落在B区以外的第2点上，(连续进行标注)； | 数据值等于B区与A区分界线上，不计算在B区以外
6 | 连续5点中有4点落在中心线同一侧的C区以外 | 同5 | 同5
7 | 连续15点在C区域中心线上下 | 标注在第15点上，参与过该异常类型计算过的点，可以循环计算。 | 数值全部在中心线上，算异常7；
8 | 连续8点在中心线两侧，但无一在C区中 | 标注在第8点上。 |

§非连续判异

序 | 异常类型 | 判异说明 | 临界说明
1 | 一点落在A区以外 |  | 等于UCL或LCL值的点不作为该异常；
2 | 连续9点在中心线的同一侧 | 标注在异常发生的末点上；参与过该异常类型计算过的点，不再循环计算；（即，第十点也满足该条件时，不计算在内，从第10点往后计算）； | 等于CL值的点不参与计算
3 | 连续6点递增或递减 | 同2 | 数值相等不计算在递增或递减范围内
4 | 连续14点中相邻点上下交替 | 同3 | 有连续点数据相等，不计算
5 | 连续3点中有2点落在中心线同一侧的B区以外 | 1、连续3点作为前提条件; 2、异常判别用2点落在中心线同一侧的B区以外规则； 3、标注在落在B区以外的第2点上，(每两点一组来标注)； | 数据值等于B区与A区分界线上，不计算在B区以外
6 | 连续5点中有4点落在中心线同一侧的C区以外 | 同5 | 同5
7 | 连续15点在C区域中心线上下 | 标注在第15点上，参与过该异常类型计算过的点，不再循环计算。 | 数值全部在中心线上，算异常7；
8 | 连续8点在中心线两侧，但无一在C区中 | 标注在第8点上。 |

·查看SPC报警点

打开系统管理工具→报警→SPC报警，初始界面如下图所示：

界面默认显示已经存在的SPC报警点信息

·在报警管理中创建SPC报警点

界面中右键选择添加SPC报警点，或者点击界面上方添加按钮，弹出添加SPC报警点向导

üSPC报警点名称：

用户自定义，最大长度128个字节

ü描述：

最大长度1024个字节

ü自动确认：

默认勾选

ü图类型：

根据Tag源点所选统计点统计类型的不同显示不同的图类型，当前图类型包括： 1.统计类型为算术平均值、时间加权平均值，图类型为Xbar图；

2.统计类型为极差，图类型为R图；

3.统计类型为标准差，图类型为S图

üTag源点：

SPC报警点的报警来源，必须选择统计点类型，且该统计点的统计类型限定为算术平均值、时间加权平均值、极差和标准差注:若SPC报警点名称已经存在,点击下一步时弹出错误提示

点击下一步，进入点规则配置页面

该界面主要是配置自动生成点规则，通过配置该规则，可自动生成相关控制限合理限的点名称，并在下次配置时继续使用上次配置的规则.

勾选自动生成Tag点，生成可选点，则系统认为需要创建相关控制限合理限名称；选择前缀或者后缀，则相关点扩展名位置相对变化

控制限合理限名称示例：

ü前缀：扩展名+分隔符+spc报警点名

ü后缀：spc报警点名+分隔符+扩展名

其中，

分隔符：限制一个字符，只能为“.”或者“_”；

扩展名：长度限制128个字节。

点击下一步，进入关联Tag点配置界面，配置关联控制限

若勾选自动生成Tag点，生成可选点，配置相关规则，则配置界面如上图所示。按该规则生成需要创建的关联Tag点名称，（注：如果自动生成名称长度大于128个字节，则自动截断），UCL，CL，LCL创建时需要输入初始值。

（注：如果勾选了创建，但是输入的Tag点名称系统中已经存在，则会提示是否需要关联该已经存在的Tag点）

若没有勾选自动生成Tag点，则配置界面如下图所示：

用户可以手动输入Tag点名称，或者选择已有的Tag点，

（注：关联Tag点必须为系统中已经存在的Tag点，且Tag类型必须为浮点型）

UCL Tag：长度限制128个字节，CL,LCL,USL,LSL限制同UCL。

点击下一步，配置判异准则页面，如下图所示：

判异准则默认全部勾选，采用国标形式，判异连续性目前只支持连续判异

其中N值不能大于M值，且M值和N值的取值范围是[1-99]的整数

点击完成，完成创建SPC报警点及相关关联Tag点。

·在报警管理中修改SPC报警点

选中某一条SPC报警点，右键选择修改SPC报警点选项，或者点击上方修改按钮

如下图所示：

其中，SPC报警点名称，图类型，Tag源点不可以被修改

点击下一步，修改关联Tag点配置

关联Tag点只能选择系统中已经存在的Tag点，不能创建关联点，且Tag点类型必须为浮点型，点击下一步，修改判异准则页面

点击完成，完成修改.

·在报警管理中删除SPC报警点

选择一条或者多条spc报警点记录，右键选择删除选项或者点击界面上方删除按钮，可从服务器上删除选中的spc报警点，但是相关关联的Tag点配置不会被删除。


数字状态集管理

Navigation: 功能明细 > 数据源配置 >

数字状态集管理

 Return to chapter overview

数字状态集是用文字来代替重复的数字，使看起来更直观，比如用红、黄、绿分别代表数字1、2、3。

在系统管理工具->数据源中选择“数字状态集”，如下图：

本章节主要介绍如何对数字状态集进行添加，修改，删除。

本节内容包括：

·添加数字状态集

·数字状态编辑

·删除数字状态集

·配置了数字量状态集的tag结果显示

·添加数字状态集

在数字状态集页面点击右键，选择“添加数字状态集”

弹出“输入要添加的数字状态集名”对话框

填写数字状态集名

点击确定，在数字状态集列表中就会显示新添加的数字状态集

·数字状态编辑

单击左侧数字状态集列表中的任意一个状态集，右侧状态列表中显示该状态集的所有状态，其中表中“状态值”和“状态名”列都可以编辑，状态值是[-128,127]的整型数，状态名最多支持31个字节。

§添加：点击数字状态表下方的加号标识，表中将添加一个数字状态。

§删除：点击数字状态表下方的减号标识，表中选中的行将被删除掉。

§修改：双击列中的单元格，可以修改状态值和状态名。

§排序：选择一个数字状态，单击上移下移按钮，就可以将这个状态上移一行或者下移一行。

§保存：点击保存按钮，可以将数字状态表中的状态保存到服务器。需要注意的是，前述步骤中对状态进行的任何修改，如果没有点击保存按钮将不会生效。

·删除数字状态集

在数字状态集页面点击右键，选择“删除数字状态集”

弹出删除确认对话框

点击确定，删除成功，在数字状态集列表中，该数字状态集消失

·配置数字量状态集的tag结果显示

1.添加一个数字量状态集“颜色”并依次添加3种状态“红”“绿”“蓝”，则0表示“红”，1表示“绿”，2表示“蓝”。

2.添加一个digitalset类型的Tag，并将Tag属性项DigitalSet的值置为“颜色”。

3.向服务器存入一条实时记录，值为1。

4.通过“实时记录”查询菜单查询该Tag实时记录，在Excel中会显示“绿”，而不是1。

5.通过“历史存储记录(时间区间模式)和历史存储记录(记录条数模式)”查询该Tag在该时间戳的历史记录，同样会在Excel中显示“绿”

注：本版本数字量状态在Excel中的显示只支持最多255个状态。


典型案例2-统计点采集

Navigation: 功能明细 > 数据源配置 >

典型案例2-统计点采集

 Return to chapter overview

本案例介绍如何配置统计点并进行数据采集

1、新增统计点

进入系统管理平台-数据源-Tag变量配置页面,点击按钮,进入"Tag属性页面",见下图:

在基本页面上的Tag属性选成“统计点”。新增stat2统计点。添加完毕后，点击“统计”tab页，见下图：

配置完毕后，点击确定进行保存。

2、实时查询统计结果

在“实时记录查询”页面中，添加此统计点“stat2”，就可以看到此统计点的最后一条统计结果

3、查询历史统计结果

在“历史记录查询”页面中，查询“stat2”点，可以看到记录里有值


典型案例12-计算点采集 电量计算案例

Navigation: 功能明细 > 数据源配置 >

典型案例12-计算点采集 电量计算案例

 Return to chapter overview

本案例的场景：

原始采集信号：电表计量值（到达该表量程最大值或因现场换新表，该数据会被清零，并重新开始计数。）

计算需求：根据电表计量值，做定时差值运算，将结果累加，但需对原始数据清零重计的例外进行处理。

假设：

 | Tag类别 | Tag名称
电表计量值 | 普通点 | Tag
电量计算值 | 计算点 | Ca

计算表达式：

IF(NoneRecord('Ca'))THEN('Tag')ELSE IF('Tag'>=PrevVal('Tag'))THEN('Ca'+'Tag'-PrevVal('Tag'))ELSE('Ca'+'Tag')

该计算表达式所引用的内置函数，请参阅计算点内置函数说明。


典型案例16-变化率计算点配置案例

Navigation: 功能明细 > 数据源配置 >

典型案例16-变化率计算点配置案例

 Return to chapter overview

综述:变化率支持最高按秒计算点的变化率，计算结果支持存储为INT32和Float64位，变化率点的单位需要在工程单位配置处配置

1.客户端配置

1.1、添加Tag点

在属性基本Tab页填写Tag名称, 选择Tag类别为计算点， 工程单位根据实际填写,见下图:

1.2、点击计算Tab页

选择计算方式为通知，通过搜索或手工输入监测点，变量表达式中输入计算表达式,见下图:

变化率计算的表达式模板为：('tagName'-PrevVal('tagName'))/(TagUnixsec('tagName')-PrevUnixsec('tagName'))

涉及公式含义见计算点章节

2.Excel批量导入

可以先建一个变化率计算点然后导出计算点变量，修改Excel 后再进行导入，需要修改的列包括Tag名、Tag类型、计算模式、计算表达式、计算源点。


数据采集

Navigation: 功能明细 >

数据采集

 Return to chapter overview

数据采集，指从传感器或其他待测设备（模拟/数字被测单元）中自动采集非电量或者电量信号，送到上位机中进行分析、处理。被采集的数据是已被转换为电讯号的各种物理量，如温度、水位、风速、压力等，可以是模拟量，也可以是数字量。

《数据采集》章节主要介绍OPC采集器、和关系数据库采集器这两种采集客户端，并详细介绍了用来配置采集器相关功能模块的采集器配置工具。

采集器所在的服务器，如果修改了计算机系统时间，必须重启采集器才能保证采集成功

本章主要内容包括：

·采集器状态查询

·如何在采集器配置里面删除采集器

·OPC采集器

·modbus采集器

·关系数据库采集器

·iHD2iHD采集器

·采集（客户端缓存）

采集到的数据可以展示，展示方式请参考：

·数据展示

©2015. All Rights Reserved.


采集器状态查询

Navigation: 功能明细 > 数据采集 >

采集器状态查询

 Return to chapter overview

采集器状态查询位于系统管理工具中的“采集器状态查询模块”，用来显示服务器下的所有采集器和设备的状态。

进入系统：

系统管理平台-采集-采集器状态查询

·功能介绍：

1.在系统管理平台中连接好服务器

2.系统将这个服务器下的所有采集器及其状态显示在界面上。内容包括：采集器名、主机名、类型、状态、状态点名和活动点。

ü采集器名：已连接服务器下配置的采集器名

ü主机名：该采集器如果被占用则这列有值，表示占用该采集器的机器名；如果该采集器没有被占用，则显示为空

ü类型：采集器的类型

ü状态：有正在启动、活动、未启动和超时四种状态。其中“超时”状态表示采集器连接不正常、异常退出等非常规状况。

采集器的状态值如下：

采集器状态 | 采集器状态值
超时 | 65530
未启动 | 65531
活动 | 65532
正在启动 | 65533

ü状态点名：标志该采集器状态的Tag点名

ü活动点：用分数表示。分子表示这个采集器下活动Tag点的个数，分母表示与这个采集器关联的Tag点的个数。

4. 系统显示被选中的采集器下面关联的设备的状态。一般默认选择第一行采集器。

5. 设备状态的内容包括：设备名、设备IP、状态、状态点名和活动点信息。

ü设备名：选中采集器下的设备名

ü设备IP：表示该设备所在的iP地址

ü状态：有已连接和未连接两种状态。

ü状态点名：标志该设备状态的Tag点名

ü活动点：用分数表示。分子表示这个设备下活动Tag点的个数，分母表示与这个设备关联的Tag点的个数。

6. 单击服务器右边的刷新按钮，可以获取最新的采集器和设备状态。

使用采集器状态监控时，若采集客户端时间和实时数据库服务端时间不同步，可能会出现误报超时的情况


如何在采集器配置工具里删除采集器

如何在采集器配置里面删除采集器

Navigation: 功能明细 > 数据采集 >

如何在采集器配置里面删除采集器

 Return to chapter overview

1.在采集器配置工具里面删除采集器的时候，需要先确认采集器的状态，确保状态为停止，选为本地采集器的钩也要去除。

2.返回采集器配置界面，点击采集器列表里面的删除图标，提示窗口选择确认。

3.回到本地采集器配置界面，点击左上角刷新按钮，采集器列表该采集器会被自动删除。


采集器备份与恢复

Navigation: 功能明细 > 数据采集 >

采集器备份与恢复

 Return to chapter overview

u 采集器备份

u 采集器备份恢复


采集器备份

Navigation: 功能明细 > 数据采集 > 采集器备份与恢复 >

采集器备份

 Return to chapter overview

v备份触发

当点击采集器配置工具的修改和删除时，会触发采集器配置的自动备份。

v备份地址与归档

自动备份当前选中的采集器配置到config/CollectorBackup目录下，文件名类似2023_02_07_13_49_08_opclocal.xlsx。当文件数量到达50个时会自动删除最旧的一个备份文件。


采集器备份恢复

Navigation: 功能明细 > 数据采集 > 采集器备份与恢复 >

采集器备份恢复

 Return to chapter overview

导入时会验证连接iHD的IP和导入配置文件中IP是否一致。

点击恢复按钮选择恢复文件，备份文件在config/collectorConfigBackup下：


修改删除操作履历

Navigation: 功能明细 > 数据采集 > 采集器备份与恢复 >

修改删除操作履历

 Return to chapter overview

记录用户对采集器的修改删除操作，方便支持人员在出现问题时进行定位。

v文件位置

目录\iHyperDB\config下的iHDRevisionHistory.db文件

v文件说明

time：修改采集器的时间

address：连接iHD的客户端IP地址

userid：登录用户的id

collector：修改或删除的采集器名

operation：目前只有修改和删除两种

errorcode：0或者其他失败错误码

根据IP和用户id可以知道做出修改的客户端IP以及用户，用户名和用户id的对应关系可以在configcenter.db的t_user表中找到。


OPC采集器

Navigation: 功能明细 > 数据采集 >

OPC采集器

 Return to chapter overview

OPC(OLE for Process Control)是以Microsoft公司的OLE/COM技术为基础，采用客户/服务器模型制定的一种工业控制领域的开放式标准，主要解决监控程序与数据源的交互问题。OPC服务器向下对设备数据进行采集，向上与OPC客户应用程序通信完成数据交换。OPC采集端作为实时数据库的数据采集客户端之一，支持工业OPC通信协议，可以从OPC服务器采集数据并发送到DB服务器。

注：由于当前市场OpcServer多为32位的，所以在使用ihd实时数据库过程中请使用32位的。如果用户必须要使用64位的ihd实时数据库，请安装OPC Core Components Redistributable (x64) 3.00.107插件，这样64位的ihd才能采集32位opcserver的数据。

《OPC采集器》主要介绍：

§OPC配置

§采集器相关Tag属性

§OPC采集端支持ICV服务器冗余

§

§远程OPC数据采集环境配置

·OPC数据采集流程

数据采集流程图如下：

底层设备（如PLC）的一个采集点（流量监测点）产生一个数据（如流量），OPC服务器采集采集到该数据，之后OPC采集器（hdOPCInt.exe）将该数据采集并发送到iHyperDB服务器中保存下来。

·OPC数据采集功能

§动态配置：OPC采集器支持动态配置，具备主动同步配置以及被动同步配置功能。其中：

ü主动同步配置：指OPC采集端会根据配置文件中配置的同步周期主动向DB服务器问询配置信息，当本地配置与服务器配置不一致时，更新本地配置（同步配置会在采集器开始运行时将服务器上的采集器配置信息同步到本地采集器）；

ü被动同步配置：指当DB服务器端点信息发生变化时，如新增修改或删除节点，会发送消息到相关的OPC采集端，采集端根据收到的配置变更信息更新本地的节点信息。

§自动重连：自动重连功能包括与DB服务器的自动重连和与OPC服务器自动重连：

ü与DB服务器自动重连：指根据配置文件中的连接监测周期定期监测与DB服务器的连接，当连接中断时，重新建立连接的功能；

ü与OPC服务器自动重连：是指根据 采集器配置工具 中配置的连接监测周期监测与OPC服务器的连接，当连接中断时，重新建立连接的功能。

§日志功能：是指当配置信息发生变化时，或者与DB服务器连接中断，或者与OPC服务器连接中断时记录日志信息的功能。

一台计算机中只能运行一个OPC采集端。

同一个OPC Server下采集的点数建议不要超过20000个，否则可能导致性能下降及OPC Server的不稳定。


OPC采集器配置工具

Navigation: 功能明细 > 数据采集 > OPC采集器 >

OPC采集器配置工具

 Return to chapter overview

采集器可用于向指定服务器添加采集器，配置设备和扫描组信息，在本地采集器配置页面里，事先添加好的采集器，选择并保存本地采集器，最后安装、启动采集服务开始数据的采集。

·采集器配置

采集器配置工具是用来配置采集器相关属性的工具。它可以与iHyperDB的一个或多个服务器连接，分别配置各个服务器下关联的的采集器。同时也可以配置每个采集器所管理的设备的属性，以及属于每个设备的扫描组的属性:

§界面介绍：

在开始菜单-采集端应用快捷链接-采集器配置工具，进入该模块。或者在系统管理工具页面上，点击按钮进入该模块。

ü采集器列表：采集器列表中罗列出属于某一个服务器的所有采集器。列表上方有三个按钮，分别为添加，修改和删除。

ü设备：设备列表中罗列出属于某一个采集器的所有设备。列表上方有三个按钮，分别为添加、修改和删除。

ü信息：这里展示选中的一个设备的所有信息，包括属于这个设备的扫描组信息。

ü扫描组：列表中展示所有属于选中的设备的扫描组。列表上方有四个按钮，依次为添加、修改、删除和查看按钮。

上述展示信息中分为展示状态和编辑状态。展示状态时，设备列表上方添加、修改和删除按钮可用，保存按钮不可用，右侧基本信息和扫描组均不可编辑。编辑状态时，设备列表上方都不可用，右侧基本信息和扫描组均可编辑，保存成功后，恢复展示状态。

§采集器的操作:

连接服务器后,“采集器列表”加载属于该服务器的所有采集器信息，默认选中第一个采集器。这个采集器的名称、类型、描述、机器名信息、设备信息、和扫描组信息全部显示在相对于的区域。

§添加采集器：

单击采集器列表上方的“添加采集器”按钮，弹出如下菜单。填写采集器名和描述信息， 类型和机器名不可以填写。单击确定按钮。成功则在采集器列表中添加这个采集器。

单击选中一个采集器。

§同一个服务器下采集器名不能重复且采集器名长度不超过32个字节的中英文字符。

§采集器名规则最多31个英文字符或15个中文字符，不能以空格开头，可使用中文（含中文标点符号）、数字、英文字母、部分英文标点符号( 仅允许"-"、":"、"."和"_" )。

§描述信息长度不超过128个字节的中英文字符。

§修改采集器：

单击采集器列表上方的“修改采集器”按钮，弹出如下菜单。填写描述信息， 名称类型和机器名不可以填写。单击确定按钮。成功则在采集器列表中更新这个采集器。

如果一个采集器已经被占用，表现为机器名有值，则不可以被修改或删除。

§删除采集器：

单击采集器列表上方的“删除采集器”按钮，弹出确认是否删除菜单，单击确认后删除这个采集器，同时从列表中删除。 单击“取消”则不删除。

如果一个采集器已经被占用，表现为机器名有值，则不可以被修改或删除。

§添加设备:

单击设备列表上方的 “添加”按钮，

设备列表新增一行，可编辑，同时右侧的设备属性也全部置为默认值

可对该设备信息进行编辑。依次键入设备名，描述和右侧的各个属性。双击左侧“设备列表”的编辑模式，可以填写设备名称和描述信息。

设备信息也可以通过浏览的方式获得。单击设备名称旁边的浏览按钮，弹出下列对话框：

采集器类型可以选择本地或者远程。如果选择了远程，需要输入IP地址并单击查找。在设备列表中选中一个设备，单击确定按钮。自动将已选择的设备填充至设备名称一栏。

注意：设备名称是指有效的OPC设备名，是OPC驱动在注册表中的有效名称，如“Matrikon.OPC.Simulation”和“Baosight.CV5OPC”。单击设备列表下方的保存按钮，即可新建一个设备。保存后各个属性不可编辑，进入展示状态。

ü基本信息配置：设备地址是采集器需要采集的设备的ip地址（目前是采集器和OPC Server在同一台计算机上，故配置为127.0.0.1即可，端口视具体设备而定，重试次数默认3次，重连周期默认1000ms）。

ü设备名长度不超过64个中英文字符

ü设备描述信息长度不超过128个字节

ü设备地址必须符合IP地址的要求

ü重连周期合法范围是30分钟之内

ü重试次数合法范围在1-100次

üOPC组容量合法范围是1-10000

§修改设备：

单击设备列表上方的 “修改”按钮：

列表下方“保存”和“取消”按钮可操作。

右侧基本信息变为可编辑。修改后按“保存”按钮即可保存修改结果。保存成功后恢复展示状态。

§删除设备

§新建扫描组

在修改设备或者新建设备的时候，基本信息中的内容可编辑，扫描组做为基本信息的一部分也可进行配置。

单击“添加扫描组”按钮

弹出"添加扫描组"对话框

扫描组的扫描类型有两种：轮询和通知。选通知模式时，周期、相位和使用缓存不可编辑。

选轮询模式时，周期必须大于刷新频率。

完成扫描组的配置后，点击设备列表下方的【保存】按钮即可保存当前配置信息在本地。

ü扫描组名：长度不超过64个中英文字符

ü扫描组描述：长度不超过128个中英文字符

ü刷新频率：合法范围在24小时之内

ü周期：合法范围在24小时之内

ü相位：合法范围在24小时之内，相位是指在轮询模式下，如果同时有两个或两个以上的扫描组，相位的设定时间即为两个扫描组开始轮询采集的间隔时间。如：配置了两个扫描组，设置周期同为5s，第一个扫描组demo的相位为0s，第二个扫描组demo1的相位为1s，那么，第一个扫描组demo采集的时间实际为为0s、5s、10s，第二个扫描组demo1的采集时间实际为1s、6s、11s。

注意：每个扫描组中的Tag点的总数在3000个以内，超过3000点新加的Tag点会采不到数据。

§删除扫描组

从扫描组列表中选中一个扫描组，单击“删除扫描组”按钮，弹出是否删除对话框，点击“是”即可删除该扫描组，点击“否”取消删除。

§查看扫描组

从扫描组列表中选中一个扫描组，单击“查看扫描组”按钮，弹出查看扫描组对话框，其中内容均不可编辑。

§修改扫描组

从扫描组列表中选中一个扫描组，单击“修改扫描组”按钮，修改后按“确定”保存。

注意：如果扫描组配置变动，建议在Tag点采集属性配置的页面刷新重新获取扫描组

·本地采集端配置

采集端配置工具，可用来下载和查看指定服务器上的所有采集器信息，选择并保存本地采集器，配置服务连接属性和缓存属性，同时集成了安装服务和启动服务器的功能。

在开始→iHyperDB→采集端应用快捷链接→采集器器配置工具，单击“本地采集器配置”tab页，进入该模块，界面如下：

注意:

1. 由于客户端系统管理平台配置信息改变后不会通知采集端配置更新。故在配置采集端时建议先点本地的刷新按钮，再进行后续操作，避免不必要的错误。

2. 不要使用具有相同机器名的电脑同时远程配置采集器。

当单击保存按钮后，如果所连接的服务器和配置文件CollectorCfg.xml里的服务器信息不一致。

本地采集器配置支持按名称查询，可以按照名称进行模糊查询。（例：输入ry*表示搜索以ry开头的采集器）

弹出如下对话框,单击确定则修改为当前选择的服务器，单击取消则不作保存。

操作步骤如下：

1.下载采集器

启动后系统自动将全部采集器下载到列表中。如果已经被选为本地采集器的，第一列勾选上，机器名有显示，安装重启服务按钮和服务状态有显示。

2.选择/取消选择本地采集器

勾选/取消勾选“选为本地采集器”的复选框，如果不配置本地服务配置和缓存配置，直接点界面最下方的“保存”按钮。

§如果一个采集器的已经被另外一台机器占用，表现为机器名与本机不一致，如果还是要将这个采集器保存为本地采集器的话，保存按钮按下后会提示,单击确定，则将这个采集器强制修改为本地采集器。单击取消则不作保存。

§如果一个采集器原来不是本地采集器，勾选并单击保存后，弹出如下提示，单击确定，这个采集器被选为本地采集器，配置文件中增加这个采集器的Interface信息。

§如果一个采集器原来是本地采集器，取消勾选并单击保存后，弹出如下提示，单击确定，取消这个采集器为本地采集器，删除配置文件中的Interface属性，停止和卸载与之相关的所有服务和进程。

3.本地服务配置

4.缓存

“启用buffer”复选框勾上则其下内容均可编辑，如果不勾选，则都不可编辑。对于离散型数据，建议不启用buffer。

本地采集器配置也可以根据操作系统用户显示当前用户勾选状态，如下图所示：

·浏览OPCServer和导出

用来浏览OPCServer中的点和导出成实时数据库支持的Excel类型。

1.从“采集器”下拉框选择一个采集器

2.界面左侧的树结构中显示为“采集器”-“设备”-“扫描组”的层级关系，都是用户在OPC采集器配置中配置好的内容

3.选中一个扫描组，单击右键菜单中的“浏览点”，弹出“选择点”对话框;

4.在“选择点”对话框中选择好一些点后，单击确定返回;

5.已选择的点被加到界面右侧的表格中。包括点名和点类型的内容;

6.单击“读值”按钮，可以读取已经选择的点的数据值、数据质量和时间戳等信息;（为保证性能，只支持200个点的读值）

7.单击“导出”按钮，弹出导出配置对话框;

为即将导出的Tag点名添加前缀和后缀，如果不填，则Tag点名取OPC Server里的点名。点击“选择”，选择导出地址，确认导出文件名之后，单击“导出”按钮，则可以选择导出“HD_OPC_TAG_20140627_141922.xls”;

1、前缀和后缀特殊字符应符合Tag点名称规则，具体参考基本Tag点。

2、前缀+后缀+OPCServer点名不超过127个字符

如果不通过按钮选择导出路径，而是手工输入不带路径的文件名（带.xls），则默认路径为安装目录的executable文件夹（C:\iHyperDB\executable）。

8、在excel中将这些点上传至服务器中，具体参考Tag点上传

1.导出文件名可以自动生成，格式为“HD_OPC_TAG_年月日_时分秒”

2.选择的OPC点不会保存，当切换采集器或者重新选择服务器或者关闭系统时，用户已选的点会被清除，请注意及时导出。

Excel中的Tag类型是系统根据所选点的类型自动匹配和填充的。见下表：

9、浏览点

ü双击左边的树结构，可以一层一层展开OPCServer的层级结构

ü双击树上的每个节点，可以浏览该节点下面的点，并显示在中间的表格中，作为待选择的点

ü可以通过名称过滤或者类型过滤。填写需要过滤的点名单击回车，或者直接选择需要的点类型，即可完成过滤。

ü用户单击左右箭头按钮，可以全选或者多选点，并移动到已选择的点列表中

ü单击“确定”，则将已选择的点导出到上层应用

1.单箭头可以移动多个选择的点;

2.不支持的点类型不可以选择;


Tag点采集配置

Navigation: 功能明细 > 数据采集 > OPC采集器 >

Tag点采集配置

 Return to chapter overview

《Tag点采集配置》主要介绍在iHyperDB系统管理平台中的数据源配置中，对一个Tag点的采集页面的配置。

·进入数据源配置

iHyperDB中的数据源，可以完成对Tag点的新建、修改和删除功能，从而对数据库中的点进行统一的配置和管理，如何进入数据源配置步骤如下：

1. 如果没有启动iHyperDB服务，请启动相关服务。

2. 启动“iHyperDB系统管理平台”

3. 单击“连接”按钮，配置所需要的服务器。 具体配置，请参考：连接管理。

4. 在任务面板中选择“数据源”→“Tag变量配置”加载该模块，具体配置，请参考：数据源

·Tag点的采集属性页面

§前提条件：

在数据源配置页面，若系统中，没有Tag点，那么请先新增Tag点，具体可参考：新建Tag点。

若已经有Tag点，点击“修改Tag点”进入Tag点的属性页面，具体可参考：修改Tag点。

§Tag点的采集配置：

Tag点的属性页面中包括“基本”、“采集”、“存储”、“报警”、“权限”、“系统”、“统计”和“计算”页面。其中“采集”页面是对Tag点的采集功能进行的配置。

采集页面主要包括三部分内容：确认采集复选框，接口和设备。其中接口包括接口名和扫描组；设备包括设备点名和数据类型。

§确认采集：当确认采集复选框不勾选时，“接口名”和“扫描组”的所有选项均为不可编辑。

§采集器名：当采集器名为可编辑状态时，下拉菜单中有当前存在的采集器名，当采集器名为空时，扫描组、设别组均为不可编辑状态。

§设备地址：当可编辑状态时，键入设备地址。长度为不超过63个字节的中英文字符。默认为空。 "设备地址"就是将要采集数据的设备的点的地址，例如，opc采集器，此处填写的设备点名就是opc sever上item的名字。 或者通过“查找”按钮找到需要采集的点。如果选择多个，则默认第一个选择的点

注：在Tag属性的“基本”页面，当该Tag点的“Tag类别”是“报警点”时，“采集”页面不可编辑。

断开服务器后，在Tag便利配置菜单查询某个点时，会提示OPC发布失败。


采集器相关Tag属性

Navigation: 功能明细 > 数据采集 > OPC采集器 > Tag点采集页面配置 >

采集器相关Tag属性

 Return to chapter overview

本节介绍iHyperDB中与采集器相关的Tag属性项。

iHyperDB服务器中的点必须通过一些属性与采集端建立关联才能进行数据采集，以下给出相关属性的说明。

配置项 | 名称 | 说明 | 取值范围 | 备注
采集器名 | szCollectorName | 与采集器配置工具中采集器名相对应，指定该Tag点由哪个采集接口进行采集 | 非空字符串 | 如果对应名称的OPC采集端没有运行，则该点无法采集数据
扫描状态 | bScan | 表示该Tag点是否扫描 | 布尔型 |
设备点名 | szInstrumentPoint | 指定该Tag点对应采集器服务器上的地址信息 | 非空字符串 | 如果该值无效，则该点无法采集数据
设备名 | szDeviceName | Tag点所属的扫描设备。设备信息包含采集设备的相关信息，如IP和读取方式等。 | 非空字符串 | 如果该设备无效，则该点无法采集数据
扫描组名 | szScanGroupName | Tag点所属的扫描组。扫描组包含扫描周期、扫描相位、扫描类型等信息。 | 非空字符串 | 如果该扫描组，则该点无法采集数据
TagID | nTagID | Tag的内部编号 | 正整数 |
Tag类型 | nTagType | Tag对应的数据类型，需要与采集器的服务器端实际数据类型一致，当类型不一致时，可以发生读取错误，或数据精度损失。 | 0-7 |


OPC采集端支持ICV服务器冗余

OPC采集端冗余支持

Navigation: 功能明细 > 数据采集 > OPC采集器 >

OPC采集端冗余支持

 Return to chapter overview

OPC采集器支持SCADA冗余，可以支持iCV服务器冗余(iCV服务端版本5.3.5P3以上)，以及特定文件冗余状态设置方案(如下面的iFix方案),

具体参见下面说明：

1、配置采集器，填写必要参数，如图：

注意，在要做采集器的设备中，设备地址要写：127.0.0.1

2、分别在两台要做采集器冗余的机器上，安装ihd采集器，然后，打开采集器配置工具，将采集器应用为本地采集器。如图：

注意：如果使用采集器缓存hdBuffer，那么主备机的采集器都需要使用

3、至此，独立采集器的配置完毕，下面要设置icv或者ifix的SCADA主备状态检测信息。

具体配置文件位置在：iHyperDB\config目录下的CollectorCfg.xml中，如下图，默认采用iFix冗余状态检测机制，不存在iFixStatus.dat则判定为采集器是独立活动状态，否则根据下面具体方式设置冗余活动状态。

·OPC采集器冗余在iCV中的使用

1.按照上面的配置，分别应用采集器到iCV的主备服务器，具体为：在iCV服务器主机配置采集器，服务器ip(127.0.0.1)，应用到本地，启动采集器服务或进程；在iCV服务器备机应用采集器，应用到本地，启动采集器服务器与进程。

2.配置iHyperDB普通点，选择采集iCV的OPC Server数据；

3.查询采集到的数据；

4.切换iCV主备机活动状态，查看数据是否继续采集。

5.采集器端的配置文件供参考：iHyperDB\config\CollectorCfg.xml 文件 ,如 <driver name="OPC" type="opc" path="" rystatus="iCV" desc="冗余状态检测，目前可使用iCV的rmapi，iFix的iFixStatus.dat" /> 【说明】rystatus为iCV，表示支持iCV冗余状态监测，需要iCV的rmapi.dll路径（一般icv的安装路径的executable文件夹）加入操作系统PATH环境变量。

iHyperDB采集到的数据来自新的活动状态节点，由于数据时间戳来自iCV的OPC Server，如果主备机时间不一致，可能导致数据时间不连续。

iCV主备机状态异常，如主备机之间网络中断导致主备机同时活动的情况不考虑。

未配置采集器冗余状态监测类型rystatus，默认采集数据。

· OPC采集器冗余在iFix中的使用

1.按照上面的配置，分别应用采集器到ifix的主备服务器，具体为：在ifix服务器主机配置采集器，服务器ip(127.0.0.1)，应用到本地，启动采集器服务或进程；在ifix服务器备机应用采集器，应用到本地，启动采集器服务器与进程。

2.配置iHyperDB普通点，选择采集ifix的OPC Server数据；

3.查询采集到的数据；

4.切换ifix主备机活动状态，查看数据是否继续采集。

5.采集器端的配置文件供参考：iHyperDB\config\CollectorCfg.xml 文件 ,如 <driver name="OPC" type="opc" path="" rystatus="ifix" desc="冗余状态检测，目前可使用iCV的rmapi，iFix的iFixStatus.dat" /> 【说明】rystatus为iFix，表示支持iFix文件状态监测方案，由其他应用程序将iFix服务器冗余状态写入文件iHyperDB\config\iFixStatus.dat，其中“1”表示当前节点活动，“0”表示非活动；其他SCADA冗余可以参考采用iFix方案。

§iHyperDB采集到的数据来自新的活动状态节点，由于数据时间戳来自ifix的OPC Server，如果主备机时间不一致，可能导致数据时间不连续。

§ifix主备机状态异常，如主备机之间网络中断导致主备机同时活动的情况不考虑。

§未配置采集器冗余状态监测类型rystatus，默认采集数据。

6。关于iFix的冗余状态设置，

以下是iFix中脚本代码示例：

Option Explicit

Private Sub iFIXStatus_DataChange(ByVal DataValue As Variant, ByVal TimeStamp As Date, ByVal Transition As Long, ByVal Reserved As Variant)

Dim con As Object

Dim configpath As Object

Dim WriteValue As Byte

If CInt(DataValue) = 1 Then

WriteValue = 1

Else

WriteValue = 0

End If

Set con = CreateObject("Scripting.FileSystemObject")

Set configpath = con.CreateTextFile("C:\iHyperDB\config\iFixStatus.dat", 1, -1)

configpath.WriteLine (WriteValue)

configpath.Close

End Sub

在调度中需要如此配置

©2015. All Rights Reserved.


远程OPC数据采集环境配置

Navigation: 功能明细 > 数据采集 > OPC采集器 >

远程OPC数据采集环境配置

Return to chapter overview

《远程OPC数据采集环境配置》主要介绍远程连接的环境配置。主要内容包括：

·防火墙设置

·远程OPC数据采集环境配置

·远程OPC数据采集环境配置

·防火墙设置（OPC服务器和客户端上都要进行设置）

关闭window自带的防火墙。

或者 ，

如果担心安全问题，则在配置结束后恢复防火墙并需要在window防火墙管理界面上配置允许客户端程序访问权限。

1.允许OPC Server程序

步骤如下: 控制面板→Windows防火墙 →例外→选择OPC Server程序，并添加。

2.开放OPC通讯135端口。

步骤如下: 控制面板→Windows防火墙→例外→添加端口

DCOM配置（OPC服务器和OPCClient服务器都要进行设置）

1)开始→运行→输入：dcomcnfg，打开组件服务界面。

2)在控制台根目录→组件服务→计算机→我的电脑，右键选择“属性”。

选择默认属性tab页，将“在这台计算机上启用分布式COM”打上勾，将默认身份级别改为“连接”。

3. 打开COM安全属性页。

4. 分别编辑界面上的4个按钮选项。在四个编辑选项中分别添加everyone用户，并勾选上所有权限选项。

5. 打开MSDTC属性页，在这个页面中勾选"使用本地协调器"。

6. 在OPC服务器上，还要回到“组件服务”界面，打开DCOM配置，找到注册的OPC服务器的名称选项，打开它的属性。

7. 在常规属性页，将身份验证级别改成“无”。

8. 在位置属性页，设置成如下： QQ截图20180329164648

9. 在安全属性页，设置如下：

10. 在标示属性页，设置如下

有时做好dcom配置后，需要重新启动电脑才起作用。所以为了安全起见，建议最好重新启动一下电脑，再做下一步。

1.如果交互式用户设置不成功，可以尝试其他用户；

2.交互式用户：OPC Server以交互的用户认证，这个账户是当前登陆此计算机且驻留在OPC Server的计算机上，也就是必须有账户登陆，否则不能启动OPC Server，当前用户注销时，OPC Server就会关闭，即使是计算机的重新启动，也会造成OPC Server的短暂的关闭；

3.启动用户：OPC Server以访问的用户认证，操作系统会为每个访问的用户创建一个实例，这样会有三个问题出现，若OPC Server只允许一个用户访问时，当系统中已经有了一个实例，再有其它用户就无法访问。若是OPC Server允许多个用户访问时，那么带来的问题是随着不同用户的访问，就会打开多个实例，这样就会占用更多的计算机资源。另外一个问题是硬件的抢占，如串口，当一个使用了，其它用户就无法再使用。

4.其它用户：OPC Server以指定的用户账户认证，这种情况需要在OPC Server的计算机上存在着要指定的账户，而且对于OPC Client必须知道此用户，否则无法访问。

5.系统账户：OPC Server以操纵系统账户认证，对于工作组还是域，系统账户都能被识别，也不需要有用户登陆。但OPC Server必须以服务的方式启动。

·本地安全策略配置

OPC服务器和OPCClient服务器都要设置：打开控制面版→管理工具→本地安全策略→本地策略→安全选项，选择本地账户的共享和安全，双击打开属性对话框，将模式改成经典模式，如下图：


OPC配置

OPC配置文件说明

Navigation: 功能明细 > 数据采集 > OPC采集器 >

OPC配置文件说明

 Return to chapter overview

运行采集端的系统中需要配置iHyperDB环境变量，配置文件需要放置在该环境变量指定路径下的Config目录下。如果没有配置该环境变量，则配置文件需要放入可执行文件的父目录下的Config目录下。采集器的统一配置文件名：CollectorCfg.xml，以下对OPC采集器相关的配置进行说明。

·OPC配置项包括：

§接口属性配置项

配置项 | 名称 | 说明 | 取值 | 备注
接口名 | name | OPC采集端的名称，配置时应该保证名称全局唯一，当两台OPC采集端名称相同时，它们向数据库服务器发送数据时，会发生数据时间戳重复的错误 | 非空字符串（最大长度31字节） |
采集器类型 | type | 采集器的类型，依据不同的采集器类型加载不同的配置，字符相对固定 | 非空字符串（相对固定，不可修改） |
启用buffer | buffer | 是否启用buffer，0表示不启用，非零表示启用，若启用buffer | 整数 |
布尔量处理方式 | boolprocess | 对布尔型数据按照0/1处理 | true |
 |  | 保持原始接口数据值 | false（默认） |

§数据库端属性项

配置项 | 名称 | 说明 | 取值范围 | 备注
同步周期 | synccycle | 与DB服务器同步配置的周期。当该周期到来时，OPC采集端向DB服务器请求配置时间戳，当发现本地时间戳与请求的时间戳不同时，更新OPC采集端的配置，并将本地时间戳设置为服务器的时间戳。OPC采集端支持同步及异步两种同步配置方式，当服务器端的点发生变化时，会发送通知给OPC采集端，OPC采集端也会根据配置的周期自动向服务器同步配置。 | 正整数(int32) | 单位为分钟建议此周期设置为30分钟以上
连接检测周期 | connectcycle | 检查与DB服务器端连接的周期。当该周期到来时，OPC采集端向DB服务器请求配置时间戳，如果成功，表明连接正常，如果失败，则测试连接，当连接中断时，进行重连。 | 正整数(int32) | 单位为秒。建议此周期设置为30秒
数据库网络地址 | ip | 数据库服务器端的ip地址 | ip地址串（最大长度15字节） |
数据库网络端口 | port | 数据库服务器端的端口号 | 正整数(uint16) |

·OPC配置工具中相关属性包括：

§OPC服务器端属性项

配置项 | 说明 | 备注
设备名 | OPC服务器的名称 |
设备地址 | OPC服务器所在计算机节点名称，可以为主机名或IP地址 |
读取方式 | 从该OPC服务器读取数据的方式。零为异步，非零为同步 |
读取位置 | 从OPC服务器读取数据的位置。零为直接从设备获取数据，此种方式速度慢，非零从OPC服务器的缓存中读取数据，此种方式读取速度快 |
异步超时 | 采用异步读取方式时，当异步读取请求已经发送后，经过该项设置的时间后，检测数据是否已经获取成功，如果获取失败，需要记录日志。值为零时表示不启用。 目前该项功能暂不支持。 | 单位为毫秒
连接检测周期 | 与OPCServer的连接检测周期。该周期到来时，检查与OPCServer的连接是否正常，如果连接已中断，则重新向该OPCServer进行注册 | 单位为分钟

相关的OPC Server端配置详见OPC采集配置工具使用说明。


OPC采集器写停机记录配置

Navigation: 功能明细 > 数据采集 > OPC采集器 >

OPC采集器写停机记录配置

 Return to chapter overview

本节介绍OPC采集器写停机记录配置方式。

找到CollectorCfg.xml文件，配置如下参数项：

<?xml version="1.0" encoding="utf-8"?>

<collector version="1.3">

<interface

name="modbus1" type="modbus" buffer="0" />

<dbserver connectcycle="10"

synccycle="1" ip="127.0.0.1" port="5673" bakip="" bakport="0"

connecttimeout="5" sendtimeout="5" user="admin" password="YWRtaW4="

timestamp="0" timestampcycle="10" />

<driverpath>

<!-- <driver name="IOMBTCP" type="modbus" path="C:\iCentroView\Drivers\Iombtcp\" /> -->

<driver

name="OPC" type="opc" path="" rystatus="iFix" desc="iFixStatus.dat"

boolprocess="false" typefromOPC="true" startnodatarecord = "true" endnodatarecord = "true"/>

</driverpath>

<interface

name="test" type="opc" buffer="0" systemuser="system" /></collector>

注意：

startnodatarecord是true表示启动会写nodata记录，false表示不会写nodata。

endnodatarecord是true表示停止会写nodata记录，false表示不会写nodata。

没有这两个配置字段时，默认启动和停止都会写nodata记录。


典型案例1-基本tag点采集过程

Navigation: 功能明细 > 数据采集 > OPC采集器 >

典型案例1-基本tag点采集过程

 Return to chapter overview

OPC数据采集流程：底层设备（如PLC）的一个采集点（流量监测点）产生一个数据（如流量），OPC服务器采集采集到该数据，之后OPC采集器（hdOPCInt.exe）将该数据采集并发送到iHyperDB服务器中保存下来。

采集流程图如下：

配置案例：本案例中的OPC服务器为Matrikon.OPC.Simulation，通过配置Tag点的采集属性页面，实现OPC采集器（hdOPCInt.exe）将Matrikon.OPC.Simulation采集到的数据发送到iHyperDB的功能。

准备工作：安装好iHyperDB服务端并启动服务进程。

1.配置服务器：

i.在iHyperDB安装的目录下，找到采集器配置工具，

ii.打开系统管理工具平台，点击左上角的“连接管理”按钮，打开“数据节点服务管理工具”，如图下图，配置需要连接的iHyperDB服务器，如需详细的服务器管理器配置帮助，请查看连接管理。

2、添加采集器

点击采集器列表中的“添加”按钮，添加新的采集器，本例中的采集器名OPC，详细见添加OPC采集器

3、添加设备

添加或选择好采集器后，通过设备列表中的“添加”按钮，添加采集设备信息“Matrikon.OPC.Simulation”，注意，这个名称需要与OPC Server匹配，

设备地址是采集器需要采集的设备的ip地址（目前是采集器和OPC Server在同一台计算机上，故配置为127.0.0.1即可，端口视具体设备而定，重试次数默

认3次，重连周期默认1000ms）。

4、添加扫描组

在基本信息配置中，点击扫描组配置下方的添加按钮，用以完成扫描组配置，本例中，以“Demo”扫描组为例。

5、上传配置到iHyperDB服务器

通过上述4步的配置，点击过“保存”按钮，即可完成将配置信息同步到iHyperDB服务器上

上传到iHyperDB服务器的采集器、扫描组和设备信息将在采集Tag点的配置页面中使用。

6、配置采集Tag点

i.打开系统管理平台，点击选择“数据源->Tag变量配置”进入Tag点配置页面，可参考“新建Tag点”，点击添加Tag：

ii.添加Tag点（默认是指普通点）一般只需填写“基本Tab页”，需要采集的点则需要填写“采集”Tab页信息，如下图所示，

注意，在这里，设备点名，需要跟实际的OPC设备相对应，此处填写的Random.Int1，是跟Matrikon模拟器中的点相对应的。

选取的相关信息均为前面添加的采集器、设备、扫描组信息。为保证在“采集器名”、“设备名”和“扫描组”下拉框中找到已经配置的设备，请确保事先已在OPC设备中或者数据模拟器中设置好的相应的配置已经正确保存。

7、选择本地采集器

进入“本地采集器配置”TAB页，勾选采集器列表中第一列的复选框，将这行的采集器设置为本地采集器。

注意：可以先点击页面右下方的“保存”按钮，保存到本地。保存成功后如下图：

8、实时数据库连接信息

这里配置的是OPC采集器与iHyperDB服务器连接的属性。

用户名和密码默认不填，如果没有配置信任，则必须填写用户名和密码。

时间戳来源默认为来自服务器，同步周期默认10秒。

9、启动缓存配置

如果开启缓存则勾选“启动buffer”前的复选框，如果不使用缓存则取消勾选复选框。配置界面内容如下图，缓存文件路径必须是绝对路径而且不能包含中文

除路径外的其他值可以选默认值，单击保存按钮后保存至配置文件。检测配置文件CollectorCfg.xml，对应项“buffer=1”如下图：

检测配置文件buffer.xml如下图：

10、安装和启动服务

当采集端配置工具全部配置完成并保存成功后，先单击指定采集器的“安装”按钮，安装属于这个采集器的windows服务。安装成功后，服务状态由未安装变为已停止，然后单击启动按钮，启动这个服务。成功启动后，服务状态由已停止变为正在运行。注意有时需要重新启动计算机才能使windows服务生效。

成功启动服务后查看服务可以发现服务列表中已经有这个服务而且是正在运行的状态。

11、配置信任信息

如果不需要采集器配置时保存服务端登陆用户和密码，需要按照如下方法配置信任信息。

为了使得采集器与iHyperDB服务器的通讯和数据交互能正常的进行，通过安全策略检查，需要将采集端所在的计算机配置为iHyperDB的信任，此时，打开“系统管理平台工具->权限”，点击“信任”选项，将看到被添加信任的IP，右单击->选择添加按钮，打开添加信任对话框，填写起始、终止IP，二者可相同。

这里需要注意的是：不同的信任的IP区间是不可以重复的。

被添加信任的IP段（从起始IP到终止IP所包含的所有IP地址）所代表的机器都可以通过OPC采集器向iHyperDB服务器发送数据。

12、查看数据采集结果

这时我们可以在“系统管理工具->数据源->实时记录查询”中，看到刚才配置的Tag点可以采集到数据。


Modbus采集器

Navigation: 功能明细 > 数据采集 >

Modbus采集器

 Return to chapter overview

· Modbus采集器配置

打开采集器配置工具

1. 添加modbus采集器：

点击添加按钮，弹出采集器属性框，再输入采集器名称，在下拉框选择采集器类型为“modbus”，点【击确定】

2. 删除modbus采集器：

同OPC采集器

3. 修改modbus采集器：

同OPC采集器

4. 添加modbus采集器：

首先选择一个modbus采集器，然后点击添加设备按钮，输入设备名称，然后在右侧选择modbus连接类型，有TCP，RTU和Serial三种，TCP和RTU主要配置界面相同，如下图：

其中RTU连接类型，适用于采用TCP连接，但Modbus协议使用RTU协议的场景。如果使用串口连接方式，协议默认使用RTU协议。

采集配置参数如下：

5. 修改modbus设备：

点击【修改】按钮，进行修改

6. 删除设备：

点击【删除】按钮，删除设备

7. 添加modbus扫描组：

在设备配置中点击【添加】按钮，弹出modbus扫描组配置框，如图：

1. 站号必须大于0

8. 删除修改：

同OPC扫描组

Tag点配置

配置Tag点的采集属性：如果选择modbus采集器

界面如下：

设备地址配置是根据数据类型来配（注意：宝信Modbus采集地址中间多一个0）

1.如果数据类型选择digital配置下面地址范围：

000001、100001、300001:15（300001寄存器的最后1位）、400001（400001寄存器的第1位）；

2.如果数据类型选择string或者blob类型，按如下方法配置：

STRING/BLOB:起始地址#长度（字节）

例如：400001#16，表示从400001开始读取16个字节；

3.如果选择其他数据类型，包括int8、uint8、int16、uint16、int32、uint32、float、double配置如下地址范围：

§8位无符号整型、8位有符号整型：

例如：400001:0、400001:8

400001:0代表取400001的第一字节，400001:8代表取400001的第二字节

§16位无符号整型、16位有符号整型：

例如：400001，表示读取一个完整400001寄存器

§32位无符号整型、32为有符号整型、单精度浮点型：

例如：400001，表示读取400001和400002两个寄存器

§双精度浮点型：

例如：400001，表示读取400001和400004四个寄存器

字节序：默认的int8、uint8、string、blob、digitaldouble不用配置字节序。


关系数据库采集器

Navigation: 功能明细 > 数据采集 >

关系数据库采集器

 Return to chapter overview

关系数据库（RDB）采集器是将存储于关系数据库中的历史数据或特殊数据转储到iHyperDB中的工具，便于实现数据的集中与管理，实现数据的无损迁移和系统过渡。

v功能说明

1. 本模块读取配置界面所指定的转储规则以及配置项，依照规则进行从关系数据库到iHyperDB的数据转储；

2. 支持宽表、窄表两种表类型的数据转储；

3. 本模块动态检查转储规则的更新；

4. 和关系数据库、iHyperDB网络断开后，本模块可以自动重新连接；

5. 本模块在启动时会自动判断转储规则中“记录起始时间”参数与iHyperDB中的对应的Tag点最新记录时间，避免重复采集。

·使用限制

1.目前支持DB2、SQLServer、MySQL、Oracle、postgresql。关系数据库客户端环境配置请参阅转储环境配置；

2.支持普通点数据采集；tag点导入关系库采集器后将自动修改点与采集器关联关系，注意如果该点原来关联其他采集器并进行了采集，将会保留原来的历史记录；

3.不支持blob数据类型；

4.关系数据库的“时间”字段支持DateTime和字符串两种类型，字符串时必须是以下格式中的一种：

“年-月-日 时:分:秒.毫秒”， “年/月/日 时:分:秒.毫秒”“年-月-日 时:分:秒”， “年/月/日 时:分:秒”；

5.配置文件中表名只可以以字母开头，不支持数字或者特殊字符开头，如“2narrow”、“*narrow”等，这是因为SQL Server对表名的限制；

6.如果要添加Tag点到一个已经运行的规则下，转储程序不会转储该Tag点在规则已运行时间之前的数据，若必须要转储这些数据，则需新建一个规则后添加该Tag点；

7.关系数据库采集，各数据库支持的字段类型汇总如下

SQLServer：

Name字段支持：

String，包含char、varchar、varchar2；

Time字段支持：

1字符串格式时间

"YY-MM-DD HH:MM:SS"

"YY-MM-DD HH:MM:SS.MMM"

"YY/MM/DD HH:MM:SS "

"YY/MM/DD HH:MM:SS.MMM "

2关系数据库DateTime格式；

Quality、Value字段不做校验。

PostgreSQL：

Name字段支持：

String，包含char、varchar、varchar2；

Time字段支持：

1.字符串格式时间

"YY-MM-DD HH:MM:SS"

"YY-MM-DD HH:MM:SS.MMM"

"YY/MM/DD HH:MM:SS "

"YY/MM/DD HH:MM:SS.MMM "

2.关系数据库TimeStamp格式(timestamp without time zone)；

Quality、Value字段不做校验。

MySQL：

Name字段支持：

String，包含char、varchar、varchar2；

Time字段支持：

1字符串格式时间

"YY-MM-DD HH:MM:SS"

"YY-MM-DD HH:MM:SS.MMM"

"YY/MM/DD HH:MM:SS "

"YY/MM/DD HH:MM:SS.MMM "

2关系数据库DateTime格式；

3关系数据库TimeStamp格式（配置后在实时数据库采集端展示出的结果为“DateTime“）。

Quality、Value字段不做校验。（建议配置Varchar类型，在实时数据库采集端展示为“String“）

Oracle：

Name字段支持：

关系数据库Varchar2；（在实时数据库采集端展示结果为“string”）

Time字段支持：

1关系数据库Varchar2；（在实时数据库采集端展示结果为“string”）;

字符串格式时间

"YY-MM-DD HH:MM:SS"

"YY-MM-DD HH:MM:SS.MMM"

"YY/MM/DD HH:MM:SS "

"YY/MM/DD HH:MM:SS.MMM "

2关系数据库TimeStamp格式

Quality、Value字段不做校验。（配置为Varchar2，在实时数据库采集端展示为“string“）

DB2：

Name字段支持：

String，Varchar；

Time字段支持：

1关系数据库支持String， timestamp，varchar；

字符串格式时间：

"YY-MM-DD HH:MM:SS"

"YY-MM-DD HH:MM:SS.MMM"

"YY/MM/DD HH:MM:SS "

"YY/MM/DD HH:MM:SS.MMM "

2关系数据库TimeStamp格式

Quality、Value字段不做校验。（配置为Varchar，在实时数据库采集端展示为“string“）

若属性都为varchar，无法采集；若quality是int或Interger类型，则采集成功。

注：以上数据库字段匹配后，使用关系数据库版本不同，在实时数据库采集界面最终展示结果也会有不同！

目前仅支持界面，不支持脚本采集关系数据库数据。

·使用方法

一．打开关系数据库采集器配置配置界面

如下所示：

首先，要连接到一个实时数据库，请点击左上角的“链接”，进行连接。

用户选择下拉菜单时，若选择为空，即没有选择服务器，那么，左边表示关系数据库映射区域的4个按钮“添加连接”、“删除连接”、“添加表映射”、“删除表映射”为不可点击状态，如果选择了实时数据库的服务器，本那么“添加连接”按钮会被激活。

二．添加数据库连接

在指定一个实时数据库后，“添加连接”按钮进入可点击状态：

点击“添加连接”，会弹出“添加关系数据库连接”的界面，

界面根据数据库类型显示连接数据所需要的一些参数，支持如界面所示的四种数据库采集。这里暂以Oracle为例进行配置：

填写Oracle数据库所需参数，点击“测试连接”，如果配置正常，会弹出连接成功的提示，如果添加错误，也会有提示，成功和失败，分别如下图：

此时，左侧关系数据库中就会出现添加的数据库连接，点击这个添加好的数据库连接，在右侧会显示连接的具体信息，如下图：

同时，添加连接成功后，“删除连接”和“添加表映射”按钮被激活。

三. 添加表映射

v 获取表数据示例：

1、窄表

连接添加成功后，点击“添加表映射”，弹出表映射配置界面。如下图

界面左上方显示之前建立的数据库连接中存在的Table,点击其中的一个Table会在右侧显示Table中的字段，包括字段名，类型描述和字段长度。

采集方式：目前支持将关系数据库中的数据作为普通点的原始值采集到实时数据库，所以配置和显示将下拉框做灰化处理。

宽窄表：则是关系数据中数据的存储方式，用户按照Table的实际情况做出选择。

字段匹配：对关系数据库中的字段和采集到实时数据库中的信息进行匹配，窄表的界面如上图所示，选择对应的字段，请注意，这里类型不匹配的话，可能导致匹配失败，请返回更改关系数据库的表，当正确对应后，点击”确定“按钮，表映射添加成功，返回主界面，点击表映射节点，界面显示如下：

数据库中的表名需要是英文的，不支持中文。

匹配字段时，如果弹出了类型不匹配，请按照弹出的提示框，更改数据库中字段的类型。

当配置成功后，“关系数据库”下面的列表会显示匹配好的表名，如下图：

配置规则

一个类型为窄表的表映射只能有一个规则，将关系数据库的数据采集到指定的唯一的实时数据库。

默认情况下不启用窄表的规则，此时界面右下角的规则相关信息都不可编辑的。若用户勾选“启用窄表规则”，界面右下角的规则相关信息变成可编辑的状态。

配置规则时间：用户根据需要配置数据记录的开始时间，如果需要设置结束时间，勾选【启用记录结束时间】，记录的结束时间不得小于记录的开始时间。设置规则的执行开始时间和执行周期。

配置规则Tag点

选择导入Tag点的页面，点击“导入Tag点”按钮，弹出Tag点查询界面，然后选择实时数据库系统中的Tag点，具体配置Tag点，请参考：数据源配置。

服务器为用户之前进入数据库采集工具时指定的实时数据库，为保证实时数据库信息的一直，此处的下拉框不可操作。同时只能采集普通点，所以点类型下拉框也做了灰化处理。

在Tag查询配置界面用户选择好了tag点之后，返回之前的规则配置界面，界面左下方的“已导入Tag点”区域显示用户刚才选择的普通点，显示信息包括：Tag名，Tag描述，Tag类型，Tag描述，iHyperDB源如下图所示：

点击左下角的“保存”按钮，弹出保存成功提示，规则配置结束。

2、宽表

对于宽表配置界面如下：

宽表的表映射是先添加Tag点，导入Tag点后，配置宽表的字段匹配，同时，还要选择记录时间的字段，选择完成后，如下图所示：

点击确定，返回宽边配置界面。此时，界面左侧显示宽表的字段匹配信息，右侧显示是否启用规则，因为Tag点已经在上一步导入，所以这里只有规则时间的配置。

勾选“启用宽表规则”，时间配置可以编辑，根据需求配置开始记录的开始时间，记录结束时间，规则执行的开始时间和周期，然后点击“保存”按钮，给出成功提示，宽表配置结束，如下图：

至此，关系数据库采集器的配置完成。

§对于DB2数据库，用户需要确保数据库的用户名和模式名保持一致

§DB2中的table命名最好以字母开头

v 获取视图数据

如下图，若想采集到视图V_LIMS_PI中的数据，操作步骤如下：

1.连接添加成功后，点击“添加表映射”，弹出表映射配置界面。如下图，找到视图项；

2.添加视图映射后，点击左上角客户端服务管理工具，安装并启动关系数据库采集服务；

3.打开系统管理平台并连接，成功后点击数据源，可以查询所采集点的记录信息；

·导入导出配置信息功能

导出

1.单击“导出”按钮

2.在弹出的对话框中，选择导出的文件路径

1.单击“导出”

2.导出成功

3.在Excel中，有5个sheet页，分别展示连接、宽表和窄表以及对应点信息。

1?导入

1.准备要导入的excel文件。填写5个sheet页的内容。

2.单击“导入”按钮

3.在弹出的对话框中，选择需要导入的文件

4.单击“导入”

5.导入成功

注意：导入时，时间格式需要为“2018-01-01 00:00:00”，右键设置单元格格式为“yyyy-mm-dd hh:mm:ss”

· 字段映射功能：

如有命名不统一问题，支持点位映射，可将数据库的点名A映射到数据库的点名B，操作如下：

1.首先用户通过导出功能把tag点列表导出成Excel表，修改tag点映射关系；

2.在导入Excel表格页面新增一列[关系数据库Tag名]，代表关系库表里需要映射的tag点名；导入tag点时自动给这一列赋值为IHD Tag名相同的内容；

3.使用导入功能把Excel表里的映射关系保存到客户端；

注意：关系库数值字段可能会有一些特殊符号(">""<"等)，IHD在采集时遇到这种字段时会跳过，不处理这一条记录


iHD2iHD采集器

Navigation: 功能明细 > 数据采集 >

iHD2iHD采集器

 Return to chapter overview

iHD2iHD采集器通过历史记录接口查询源数据库，可实现多台iHD服务器之间的数据转储，可以用于iHD服务器级联，数据备份等场合。 该服务运行在ihd客户端。

·功能说明

1.本模块可以读取源iHD中的原始数据，将其转储到目的iHD中；

2.支持源tag点全选，包括：源iHD的普通点、统计点和计算点；

3.如果源iHD中选择转储的tag点名在目的iHD中不存在，则iHD2iHD采集器服务会在目的iHD中自动创建同名的tag点；

4.如果源iHD中选择转储的tag点为统计点或者计算点，在目的iHD中对应的新建的tag点类型会统一更改为普通点；

5.iHD2iHD采集器在目的iHD中新建tag点时，可选配在源iHD中的tag名基础上，增加前缀或者后缀方式；

·使用限制

1.iHD2iHD采集器通过历史记录接口查询源服务器。转储性能受服务器性能及数据库池大小影响，建议不超过4000点。超过4000点应用需求，建议增加ihd客户端方式，每个客户端负载4000点。只转储实时数据，建议采用ihd2ihd实时数据转发服务，其性能可达到上万点，2021年10月已实施应用方案现场实测性能达3万点。

2.如果转储的点数较多，目标服务器和源服务器上查询实时记录的时间戳可能存在延迟。如果源服务器上的点配置了压缩属性，并且数据值被压缩了，那么目标服务器上采集数据的时间戳可能长时间没有更新，将压缩超时缩短可提高数据采集频率。

3.iHD服务器若存在备机，在配置iHD2iHD采集器加点时，主备服务器均必须在线，否则将无法配置成功。

·使用方法

1.打开关系数据库采集器配置界面

通过：“windows开始菜单->iHyperDB->iHD2iHD采集器配置工具”打开界面（V3.6.1 P1之前的版本）如下所示：

V3.6.1 P2版本新增点表配置“导入”“导出”功能，可将采集点表导出成Excel文件方便编辑，如下所示：

点击“启动采集服务”，启动服务，如下图。

v令采集器以服务方式运行：点击安装，可以将采集器安装为windows服务，再点击启动，启动IHD后台采集服务。

v令采集器以进程方式运行：若不点击安装，直接点击启动按钮，则以进程方式启动IHD后台采集服务。

2.iHD2iHD采集器配置页面

1)通过：“ihyperDB->客户端应用快捷链接->iHD2iHD采集器配置工具”打开iHD2iHD采集器服务，界面如下所示：

采集器配置列表中会展示出现有配置的IHD采集器，通过增加、删除、修改按钮可以做IHD采集器编辑配置。

2)在“iHD采集器配置”页面中，点击“+”，新建一个IHD采集器,如下图所示；

iHD采集器的参数：

v采集器名称：自定义，不可重复

v源服务器机器主机IP：被采集的iHD服务器；

v源服务器主机端口：iHD的端口号，默认是5673；

v源服务器机器备机IP：被采集的iHD服务器备机；

v源服务器备机端口：iHD的端口号，默认是5673；

v目标服务器主机IP：负责采集的iHD服务器；

v目标服务器主机端口：iHD的端口号，默认是5673；

v目标服务器备机机IP：负责采集的iHD服务器；

v目标服务器备机端口：iHD的端口号，默认是5673；

v轮询周期：执行转储采集数据的周期，单位为秒；

v记录起始时间：确定被采集的历史记录的从何时开始被采集（此时间之前的记录不采集）

注意，原服务器与目标服务端机器的IP不能相同。

3)源IHD中的转储tag，有两种选择方式：

A.可以选择“全部普通点”，“全部统计点”，“全部计算点”；（支持多选）

B.可以选择“详细选择Tag点”，自定义选择转储tag；点击“选择”可选择被采集的点

4)点击“获取已配置Tag点”，获取已之前已经保存配置的tag点

5)添加tag名前缀和后缀, 方便区分不同iHD上的Tag点

注意： 详细选择Tags点时，需先添加Tag名前后缀好，再从左侧点击→，前后缀名才可生效。

6)点击页面最下方“保存选中采集器配置”，将选中的采集器配置保存；再点击“通知采集器刷新配置”，将修改后的配置通知后台服务生效。

注意：

1.如果后台服务没开启的话，通知消息会返回失败。但此时重启后台服务，配置依然会生效；

2.为保证采集正常，建议源iHD和目标iHD互相将对方IP配置到“权限”模块下的信任列表中；

3.为保证采集正常，建议源iHD和目标iHD的IP不能相同；

4.许可证过期后，需要重启服务端和采集器。


ihd2ihd实时数据转发服务

Navigation: 功能明细 > 数据采集 >

ihd2ihd实时数据转发服务

 Return to chapter overview

ihd2ihd实时数据转发服务（hdRTD2ihd）可实现iHD源到目的服务器的实时数据转储，可以用于实时数据全备份场景。该服务运行在iHD源服务器端。

注意事项：除了系统点，源库tag点表必须全部导入目的库，目的库需保证完成点表导入配置，否则ihd2ihd实时数据转发服务将无法正常启动。

实时数据转发服务相关配置：

·tag点配置

1.全量转发

a.首先在excel的实时数据库插件中连接到源iHD，点击将除系统点外的所有tag点下载到本地。

b.在excel的实时数据库插件中连接到目标iHD，将源iHD中tag点上传到目标iHD。

2.非全量转发

源ihd中tag点属性“保留参数3”值为1的所有tag点添加到目标iHD中。

注意：除了系统点，源数据库全部tag点（点名不做修改）需完全导入目的数据库。源库点表⊆目的库点表。

·配置文件说明

vhdRTD2ihdConfig.xml

hdRTD2ihd实时数据转发服务的配置文件hdRTD2ihdConfig.xml（位于ihyperdb\executable_x64 下）。

<?xml version="1.0" encoding="utf-8"?>

<Cfg>

<TargetHD mainip="10.25.14.231" mainport="5673" backupip="" backupport="" />

<hdRTD2ihd sleepms = "1" cachefile = "4095" />

</Cfg>

配置文件中的标签说明：

TargetHD：目的ihd配置；

mainip：主机IP；

mainport：主机端口；

backupip：备机IP；

backupport：备机端口；

hdRTD2ihd：转发服务配置；

sleepms：发送间歇时间，单位为ms,设置范围为[0,10]；

cachefile：缓存文件的大小限制，单位为Mb。

vservercfg.xml

在启用hdRTD2ihd实时数据转发服务之前，务必修改config\servercfg.xml的配置。

<GlobalCfg BuildVersion="3.6.1_Build_20181130_Win64" EnableExportBigData="1" EnablehdRTD2ihd="1" EnableRedundancy="0" />

标签EnablehdRTD2ihd配置值需修改为“1”，表示需要启用实时数据转发服务。

vLog.xml

日志配置文件，在ihyperdb\config目录下，需添加如下配置项：

<appender name="hdRTDihdFile" type="rollingfile" logdir="E:/iHyperDB/Log/" prefix="hdRTDihd" rollingpolicy="sizerolling" layout="basic" />
<appender name="hdRTDihdConsole" type="console" layout="basic" />

<category name="iHyperDB.hdRTDihd">
<output appender="hdRTDihdFile" priority="debug" />
<output appender="hdRTDihdConsole" priority="debug" />
</category>

vServiceMgrTool.xml

需要在ihyperdb\config目录下的ServiceMgrTool.xml文件中添加如下配置项：

<Process RestartEnable="1" SleepTime="0" Platform="3" ShowBlack="1" DisplayName="实时数据转发服务" ModuleName="hdRTD2ihd" />

注意：如果在目的iHD中未找到源iHD全部对应的tag点，程序将无法运行，请注意！

启用实时数据转发服务：

1.在配置好源ihd和目标ihd的Tag点后，启动实时数据转发服务。点击目录下的“数据节点服务管理工具”，如下图：

2.在数据节点服务管理工具的进程管理中可查看实时数据转发服务（hdRTD2ihd）状态，以及启动/停止该服务，如下图：

3.服务启动后，会读取源ihd和目标ihd的Tag点配置。待读取完成后，在目标ihd的实时数据查看页面和历史数据查看页面均可查看到转储的数据。


采集（客户端缓存）

Navigation: 功能明细 > 数据采集 >

采集（客户端缓存）

 Return to chapter overview

“客户端缓存”Buffer是一个独立的exe程序，部署在客户端。在不使用Buffer的情况下，采集端将采集到的底层数据直接发送到服务端。如果网络出现故障或者服务器忙，采集的数据将会丢失，给企业造成损失。若在客户端部署Buffer则可以避免类似的问题。开启Buffer后，采集端并不直接将数据发送到服务端，而是先发送到Buffer，若网络正常或服务器空闲时Buffer会直接将数据发送到服务器，否则，Buffer先将数据缓存到本地缓存文件中，等到网络恢复正常或服务器空闲时将缓存在本地文件中的数据发送到服务端，尽可能的确保数据不会丢失。

启用Buffer：

首先，进行采集（客户端缓存）中的Buffer配置和采集端的配置，在采集端的配置中可以决定是否启用Buffer。

然后，启动Buffer后再启动采集端，就可以正常的使用Buffer的各种功能了。

·“客户端缓存”配置界面

·配置项说明：

配置项 | 名称 | 说明 | 取值 | 备注
缓存文件 | CacheFilePath | Buffer缓存文件的路径，缓存文件名为buffer.buf | 非空字符串（最大长度256字节） | 缓存文件全路径不能超过作系统限制。如果配置为“F:\ihyperDB\CacheFile”,则Buffer缓存文件放在该路径下。如果配置为“CacheFile”，则缓存文件在hdBuffer.exe的同一级目录的CacheFile文件夹中，注意不能配置为“F:\”这种形式的。
缓存文件大小 | CacheFileSize | 缓存文件的最大值 | 最小值为1，最大值为1048576,用户可以根据计算机的空间来自由的配置。 | Buffer只有一个缓存文件，用来存放由于网络原因没有发送到客户端的数据。单位为兆，若缓存文件大小的设置的太小，连接的服务端数量过大（如缓存文件大小设置为1兆，连接的服务端数目为1000个）时，缓存记录数据可能会失败。
发送周期 | SendPeriod | 若网络正常，Buffer按照发送周期定期的将缓存的数据发送至服务端，推荐值1000毫秒 | 最小为1，最大值为2147483647（2^31-1)， | 单位为毫秒
发送超时 | SendTimeOut | Buffer向服务端发送数据的超时时间；如超过时间，则认为不成功，数据丢失 | 最小为最小为1，最大值为2147483647（2^31-1) | 单位为秒
连接超时 | ConnTimeOut | Buffer向服务端建立连接的超时时间；如超过时间，则认为连接不成功，数据丢失 | 最小为1，最大值为2147483647（2^31-1) | <单位为秒

·如果配置文件由配置界面生成，某些配置项可以是中文，如缓存文件路径。

·如果配置文件不是由配置界面生成，配置项不能为中文。

·缓存文件最大值配置成功后最好不要随意更改，除非配置的缓存文件大小大于实际缓存文件大小。如缓存文件实际大小大小为10M，修改缓存文件最大值为100是可以的，修改为1则不行，会导致Buffer无法启动。


采集器主备冗余配置

Navigation: 功能明细 > 数据采集 >

采集器主备冗余配置

 Return to chapter overview

采集器支持主备冗余（ihd3.8.1P1以上），具体配置方法如下：

·配置采集器

填写必要参数，如图：

·安装采集器

分别在两台要做采集器冗余的机器上，安装ihd采集器，然后，打开采集器配置工具，将采集器应用为本地采集器。如图：

·配置冗余选项

点击冗余配置，对相关选项进行配置，保存后重新启动生效，如图：

v冗余配置项说明

启用冗余：必须勾选，否则冗余配置不生效；

启用TCP：冗余通信协议为TCP，否则为UDP，默认不勾选；

本机优先级：本机的冗余优先级；

对等机优先级：另一台冗余机器的优先级；

优先级需正确对应，即一台配置为主机/备机，另一台的需配置为备机/主机，否则可能导致主备同时发送数据或均不发送数据。

通信端口：可配置所需端口，默认为11230；

备用通信端口：与通信端口功能相同，保活消息同时发送，默认为11231；

发送间隔：保活消息发送间隔，默认为200ms；

超时时间：保活消息超时时间，默认超过1秒未收到消息即进行主备切换。

·冗余配置文件示例

<?xml version="1.0" encoding="utf-8"?>

<collector version="1.3">

<dbserver connectcycle="10" synccycle="1" ip="10.25.10.34" port="5673" bakip="" bakport="0" connecttimeout="5" sendtimeout="5" user="admin" password="YWRtaW4=" timestamp="0" timestampcycle="10" />

<driverpath>

<driver name="OPC" type="opc" path="" rystatus="iFix" desc="冗余状态检测，目前可使用iCV的rmapi，iFix的iFixStatus.dat" />

</driverpath>

<interface name="1129" type="opc" buffer="0">

<Redundancy EnableRedundancy="1" EnableTcp="0" LocalHost="10.25.3.57" PeerHost="10.25.10.109" Port="11230" BackupPort="11231" Sequence="1" PeerSequence="2" IntervalMs="200" Threshold="5"/>

</interface>

</collector>


iHD采集器守护进程和状态监控

Navigation: 功能明细 > 数据采集 >

iHD采集器守护进程和状态监控

 Return to chapter overview

u 概述

u 系统基本设计

u 界面

u iHD采集器守护进程

·概述：

iHD采集器守护进程，监控OPC采集器状态，并监测出采集器异常之后，进行重启。

主要需要重启的场景有两种：

1.采集器处于超时状态，由于网络波动，采集器发生了断开，但重连周期和次数达到上限后，采集器不会再进行重连，处于超时状态。需要重启采集器。

2.采集器状态正常，由于一些其他问题数据不更新了，此时网络正常，opcclient查看数据也能看到，此时根据数据最后更新的时间戳进行判断，用户的超时设置对比，判断异常后，重启采集器。

另外优化采集器状态监控界面，添加查看详细信息界面，根据帮助查看不同设备具体哪些采集点是活动。

·系统基本设计：

1.模块部署及数据流向图

·界面

任务面板有采集点状态查询选项，下拉框选择采集器，查看采集点快照

·iHD采集器守护进程用户手册

iHD config目录下增加hdCollectorDaemon.xml配置文件，根据不同需求配置不同采集器监测周期（单位：秒），和tag点超时判断时间（单位：秒）

<?xml version="1.0" encoding="utf-8" ?>

<hdCollectorDaemon version="1.0">

<Collector name="opclocal" monitor_period="10" timeout="300"/>

</hdCollectorDaemon>

LogClient.xml增加hdCollectorDaemon日志配置

<appender name="hdCollectorDaemonFile" type="rollingfile" logdir="C:/iHyperDB/Log/" prefix="hdCollectorDaemon" rollingpolicy="sizerolling" layout="basic" />

<appender name="hdCollectorDaemonConsole" type="console" layout="basic" />

<category name="iHyperDB.hdCollectorDaemon">

<output appender="hdCollectorDaemonFile" priority="info" />

<output appender="hdCollectorDaemonConsole" priority="info" />

</category>

windows系统下，确认配置文件正确后，双击hdCollectorDaemon.exe启动，或配置为服务，开机自动启动。


数据查询

Navigation: 功能明细 >

数据查询

 Return to chapter overview

介绍实时数据库中数据的查询和展示功能。


系统管理工具查询数据

Navigation: 功能明细 > 数据查询 >

系统管理工具查询数据

 Return to chapter overview

使用系统管理工具可以查询普通点、统计点、计算点的记录：

1. 实时数据查询，请参照系统管理 > 数据 >实时记录

2. 历史数据查询，请参照系统管理 > 数据 >历史记录


实时记录

Navigation: 功能明细 > 数据查询 > 系统管理工具查询数据 >

实时记录

 Return to chapter overview

《实时记录查询》主要介绍如何通过系统管理工具，展示和查询配置好的Tag点所对应的实时数据。

·如何实现实时记录的查询

要实现实时记录的查询，需要以下两个步骤：

一、配置数据采集器，详细请参考：数据采集和采集器配置工具。

二、实时记录的配置

操作如下：

1.通过“iHyperDB系统管理平台”-“实时记录”，打开“实时记录”主窗口

2.我们使用“查询Tag点”功能，可以查询已经存在的Tag点。点击“查询Tag点” 弹出Tag查询对话框，填写相应的点类型，点击“查询”按钮，就能查询到服务器中的所有符合条件的Tag点,注意,查询关键字中,可以用"关键字+*实现模糊查询,如下图中的"tag*"，可以查出所有名字中包含tag的点。

我们选择“tag1”，点击确定，在实时记录主窗口就出现了实时记录。

需要显示数据的Tag点需要首先配置“Tag属性”中的“采集页面”(参考基本Tag点以及Tag点采集配置)，配置接口和设备

·从列表中清除记录

从列表中选择一条或者多条记录，单击工具栏中的“删除选中的Tag点记录显示”

弹出删除确认对话框

点击确定，实时记录列表中，该Tag点的记录被删除。

如果选择“删除所有Tag点的记录显示”，那么实时记录列表中所有的记录都将被删除。

·刷新列表中Tag点记录

单击工具栏中的“刷新列表中Tag点的记录”，那么列表中的Tag点记录被刷新，并且“时间戳”也改变

这个列表中的数据不会主动刷新，手动点击刷新，即可看到数据发生了变化。

·设置字符串数据编码功能

可以根据需求配置字符串编码格式；GBK包含全部中文字符， UTF-8则包含所有需要用到的字符。


历史记录

Navigation: 功能明细 > 数据查询 > 系统管理工具查询数据 >

历史记录

 Return to chapter overview

只可查询普通Tag点的历史记录，不能查询报警点的历史记录。

·《历史记录》主要介绍Tag点的历史记录的查询。操作如下：

1.通过“iHyperDB系统管理平台”左侧模块列表，打开“历史记录”主窗口。

历史记录主窗口包括两个框，“查找Tag框”和“查询记录框”。在“查找Tag框”中包含一个工具栏和Tag显示列表。工具栏中有“查询Tag点”、“刷新Tag点”、“清空Tag点列表”。

2.点击“查询Tag点”，从服务器中选择需要查询的Tag点

点击确定，在“查找Tag”中的列表中，会显示选择的Tag点

3.可以根据需求配置字符串编码格式；GBK包含全部中文字符， UTF-8则包含所有需要用到的字符。

4.在查询记录“对话框”中选择需要查询的Tag点

选择“查询模式”、“起始时间”、“记录条数”和“查询类型”

点击“开始查询”，“Tag查询记录”列表中会显示符合条件的历史记录

在“查询记录”列表中点击“Tag名”、“时间戳”、“数据质量”、“数据值”，历史记录将重新排列。

若点击“时间戳”，历史记录就重新排列，时间由大到小变为由小到大。

·从列表中清楚记录

单击工具栏中的“清空所有Tag”按钮

· 刷新

单击工具栏中的“刷新”按钮，可对上面的Tag显示列表中的Tag点信息进行刷新。

查询模式主要包括：

·存储记录(时间间隔)

输入起始时间和终止时间，查询这一段时间内的记录。

·历史存储记录（记录条数）

输入起始时间，记录条数，查询类型中选择向前查询或者向后查询。查询规定的时间段的记录。

·历史插值记录（等间隔）

输入起始时间和终止时间，输入时间间隔，查询这一段时间内的记录。

1.起始时间必须小于等于终止时间

2.记录列表中最多显示从起始时间开始的65535条记录

3.若Tag类型为digital,则查询的记录显示为状态字符串

4.Tag列表中最多显示400行Tag点

5.时间间隔输入要求：后缀s标示秒；后缀m标示分钟；后缀h表示小时。


excel查询数据

Navigation: 功能明细 > 数据查询 >

excel查询数据

 Return to chapter overview

实时数据库的查询，还可以通过Excel插件完成，具体请参考数据展示 > 电子表格 > Excel中实时数据库插件的功能 > 查询记录 > 查询实时记录。


ODBC与SQL查询

Navigation: 功能明细 > 数据查询 >

ODBC与SQL查询

 Return to chapter overview

·ODBC Driver

·SQL查询


ODBC Driver

Navigation: 功能明细 > 数据查询 > ODBC与SQL查询 >

ODBC Driver

 Return to chapter overview

ODBC Driver提供ODBC接口供用户访问实时数据库数据，ODBC接口遵循微软ODBC规范.

安装实时数据库客户端，安装包中包含了iHyperDB ODBC Driver.

1.ODBC数据源配置

通过操作系统控制面板->管理工具->数据源打开数据源管理器。

注意：Windows 64位系统需通过32位数据源管理器管理，一般路径C:\Windows\SysWOW64\odbcad32.exe

1.1 新增系统/用户数据源

选择系统DSN或用户DSN，点击添加按扭，弹出创建新数据源界面

选择iHyperDB ODBC Driver，点击完成。弹出iHyperDB ODBC数据源配置界面。

输入数据源名称、数据源描述、实时数据库的IP地址、端口号、用户名、密码等信息，并指定连接超时和查询超时时间，点击确定按扭，完成数据源新增。

数据源名称：长度最长为31个字符，不能为空；

数据源描述：长度最长为1023个字符；

主机Ip地址：长度最长为16 不能为空；

备机Ip地址：长度最长为16 不能为空；

用户名：长度最长为31 不能为空 这个为实时数据库用户名；

密码：长度最长为63，最短为5，支持字符，数字，以及0-9数字键上对应的特殊字符。

连接超时范围为0-32767

查询超时范围为0-32767

1.2 修改系统/用户数据源

ODBC数据源管理器中选择数据源，点击“配置”按扭，弹出iHyperDB ODBC 数据源配置界面修改系统、用户数据源，修改完成后点击“确定”按钮保存，点击“取消”按钮，取消修改。

1.3 删除系统/用户数据源

ODBC数据源管理器中选择数据源，点击“删除”按扭，删除数据源。

2. HDSQL

HDSQL遵循SQL语法实现，用户可根据HDSQL定义的关系表及SQL语法，编写SQL语句，查询实时数据库数据。

2.1 TABLE

HDSQL支持如下表的Select查询

2.1.1 HDARCH

FTag | CHAR(128) | Tag名称
FTime | CHAR(24) | 记录时间戳
FQuality | Uint16 | 记录质量
FIValue | Int32 | 整形值
FSValue | CHAR(1000) | 字符或BLOB值
FFValue | Float64 | 浮点值

2.1.2 HDINTER

FTag | CHAR(128) | Tag名称
FTime | CHAR(24) | 记录时间戳
FQuality | Uint16 | 记录质量
FIValue | Int32 | 整形值
FSValue | CHAR(1000) | 字符或BLOB值
FFValue | Float64 | 浮点值
FTimeStep | CHAR(24) | 插值间隔
FInterType | CHAR(24) | 插值类型

2.2 HDSQL语法说明

(select_statement) ::= SELECT (select_list) FROM (table_source) WHERE (condition) [LIMIT (Integer) ASC|DESC]

(select_list) ::=(column_alias) [, (column_alias)]| buildin_func(fivalue|ffvalue)[, buildin_func(fivalue|ffvalue) ]| *

(condition) ::= (compare_expr) [and|or (compare_expr)]

(compare_expr)::= [FTime (Comparison) (time string)]|[FTag = (tag name string)]|[FTimeStep= time_interval]|[FInterType= LINE|PREV]

(Compariosn):: =|>|<|>=|<=

(table_source):= HDArch|HDInter

(time_ interval):= Number(time_mode)

(time_mode): D|H|M|S|MS

(time string):= ‘YYY-MM-DD hh:mm:ss.xxx’

(buildin_func):max|min|count|average|sum

关键字SELECT、FROM、WHERE、LIMIT、ASC、DESC大小写不敏感

§Table_source仅支持HDarch(历史归档表)和HDInter（历史插值表），表名、字段名大小写不敏感

§可以select一个表中的多个列或所有列（用*表示），不支持多表select

§Where可使用And和or组合多个比较表达式，And与or大小写不敏感

§比较表达式仅支持FTag、FTimestep、FInterType的‘=’比较操作及Time字段的=、>、<、>=、<=、比较操作

§比较表达式左边为字段名，右边为比较值

§可通过LIMIT限制最大查询条数，Limit为int32类型，若输入超过2147483647的值，会被截断，输入负数会报错

§一个点的数据默认按时间从大到小排序(DESC),可通过ASC指定为从小到大排序

§查询HDInter表时，可以在Where中指定FTimeStep间隔，其中time_interval可表示为：时间间隔长度+时间模式，如10M，表示间隔10分钟。D表示日（1-24855），H表示小时（1-596523），M表示分钟（1-35791394），S表示秒（1-2147483647），MS（1-2147483647）表示毫秒,大小写不敏感

§SQL最大长度255

§若未指定插值类型，默认为LINE

§若未指定插值 间隔，默认为60秒

§ 内置函数，时间区间不支持[timeA, timeA],多个时间区间之间不可以有交集

§select 中若出现内置函数，不允许再select其它字段，如出现select ftag, MAX(FIVALUE)。会报解析失败

示例：

1.Select * from hdarch where ftag='abc' and ftime < '2013-09-18 08:00:00.000’ and ftime > '2013-09-18 09:00:00.000' limit 10 asc

查询归档表，Tag名为abc的点，2013年9月18日 8点到9点的数据，记录数限制最多10条，按时间升序排序。

2.Select * from hdinter where ftag='abc' and ftime < '2013-09-18 08:00:00.000’ and ftime > '2013-09-18 09:00:00.000' and ftimestep = 10s and fintertype = line limit 10 asc

查询插值表，Tag名为abc的点，2013年9月18日 8点到9点的数据，插值间隔为10s，插值类型为线性插值，记录数限制最多10条， 按时间升序排序。

3.Select max(fivalue),min(fivalue), count(fivalue) from hdarch where ftag='abc1' and ftime > '2014-01-01 08:00:00.000' and ftime < '2014-01-02 08:00:00.000';

计算归档表2014-01-01 08:00:00.000至2014-01-02 08:00:00.000间的最大记录值和最小记录值

4.Select max(fivalue),min(fivalue),count(fivalue) from hdinter where ftag='abc1' and ftime > '2014-01-01 08:00:00.000' and ftime < '2014-01-02 08:00:00.000' AND FTIMESTEP = 1s AND FINTERTYPE = line;

计算插值表2014-01-01 08:00:00.000至2014-01-02 08:00:00.000间的最大记录值和最小记录值，插值方式为线性插值，时间间 隔为1秒

3 HDODBC接口

3.1 支持的ODBC接口

·SQLRETURN SQL_API SQLAllocHandle(SQLSMALLINT HandleType,SQLHANDLE InputHandle, SQLHANDLE *OutputHandle);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms712455(v=vs.85).aspx

·SQLRETURN SQL_API SQLFreeHandle(SQLSMALLINT HandleType, SQLHANDLE Handle);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms710123(v=vs.85).aspx

·SQLRETURN SQL_API SQLConnect(SQLHDBC ConnectionHandle,

§SQLCHAR *ServerName, SQLSMALLINT NameLength1,

§SQLCHAR *UserName, SQLSMALLINT NameLength2,

§SQLCHAR *Authentication, SQLSMALLINT NameLength3);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms711810(v=vs.85).aspx

·SQLRETURN SQLDisconnect( SQLHDBC ConnectionHandle);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms713946(v=vs.85).aspx

·SQLRETURN SQL_API SQLSetConnectAttr(SQLHDBC ConnectionHandle,

SQLINTEGER Attribute, SQLPOINTER Value,

SQLINTEGER StringLength);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms713605%28v=vs.85%29.aspx

·SQLRETURN SQL_API SQLExecDirect

(

SQLHSTMT StatementHandle,

__in_ecount_opt(TextLength) SQLCHAR* StatementText,

SQLINTEGER TextLength

);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms713611(v=vs.85).aspx

·SQLRETURN SQL_API SQLFetch(SQLHSTMT StatementHandle);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms712424(v=vs.85).aspx

·SQLRETURN SQL_API SQLBindCol(SQLHSTMT StatementHandle,

SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,

SQLPOINTER TargetValue, SQLLEN BufferLength,

SQLLEN *StrLen_or_Ind);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms711010(v=vs.85).aspx

·SQLRETURN SQL_API SQLDataSources(SQLHENV EnvironmentHandle,

SQLUSMALLINT Direction, SQLCHAR *ServerName,

SQLSMALLINT BufferLength1, SQLSMALLINT *NameLength1,

SQLCHAR *Description, SQLSMALLINT BufferLength2,

SQLSMALLINT *NameLength2);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms711004(v=vs.85).aspx

·SQLRETURN SQLGetInfo(

SQLHDBC ConnectionHandle,

SQLUSMALLINT InfoType,

SQLPOINTER InfoValuePtr,

SQLSMALLINT BufferLength,

SQLSMALLINT * StringLengthPtr);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms711681(v=vs.85).aspx

·SQLRETURN SQLSetEnvAttr(

SQLHENV EnvironmentHandle,

SQLINTEGER Attribute,

SQLPOINTER ValuePtr,

SQLINTEGER StringLength);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms709285(v=vs.85).aspx

·SQLRETURN SQLSetStmtAttr(

SQLHSTMT StatementHandle,

SQLINTEGER Attribute,

SQLPOINTER ValuePtr,

SQLINTEGER StringLength);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms712631(v=vs.85).aspx

·SQLRETURN SQLRowCount(

SQLHSTMT StatementHandle,

SQLLEN * RowCountPtr);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms711835(v=vs.85).aspx

·SQLRETURN SQLNumResultCols(

SQLHSTMT StatementHandle,

SQLSMALLINT * ColumnCountPtr);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms715393(v=vs.85).aspx

·SQLRETURN SQLDriverConnect(

SQLHDBC ConnectionHandle,

SQLHWND WindowHandle,

SQLCHAR * InConnectionString,

SQLSMALLINT StringLength1,

SQLCHAR * OutConnectionString,

SQLSMALLINT BufferLength,

SQLSMALLINT * StringLength2Ptr,

SQLUSMALLINT DriverCompletion);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms715433(v=vs.85).aspx

·SQLRETURN SQLGetDiagRec(

SQLSMALLINT HandleType,

SQLHANDLE Handle,

SQLSMALLINT RecNumber,

SQLCHAR * SQLState,

SQLINTEGER * NativeErrorPtr,

SQLCHAR * MessageText,

SQLSMALLINT BufferLength,

SQLSMALLINT * TextLengthPtr);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms716256(v=vs.85).aspx

·SQLRETURN SQLGetDiagField(

SQLSMALLINT HandleType,

SQLHANDLE Handle,

SQLSMALLINT RecNumber,

SQLSMALLINT DiagIdentifier,

SQLPOINTER DiagInfoPtr,

SQLSMALLINT BufferLength,

SQLSMALLINT * StringLengthPtr);

接口详细说明参见：http://msdn.microsoft.com/en-us/library/ms710181(v=vs.85).aspx

·SQLRETURN SQLGetConnectAttr(

SQLHDBC ConnectionHandle,

SQLINTEGER Attribute,

SQLPOINTER ValuePtr,

SQLINTEGER BufferLength,

SQLINTEGER * StringLengthPtr);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms710297(v=vs.85).aspx

·SQLRETURN SQLExtendedFetch(

SQLHSTMT StatementHandle,

SQLUSMALLINT FetchOrientation,

SQLLEN FetchOffset,

SQLULEN * RowCountPtr,

SQLUSMALLINT * RowStatusArray);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms713591(v=vs.85).aspx

·SQLRETURN SQLColAttribute (

SQLHSTMT StatementHandle,

SQLUSMALLINT ColumnNumber,

SQLUSMALLINT FieldIdentifier,

SQLPOINTER CharacterAttributePtr,

SQLSMALLINT BufferLength,

SQLSMALLINT * StringLengthPtr,

SQLLEN * NumericAttributePtr);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms713558(v=vs.85).aspx

·SQLRETURN SQLFetchScroll(

SQLHSTMT StatementHandle,

SQLSMALLINT FetchOrientation,

SQLLEN FetchOffset);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms714682(v=vs.85).aspx

·SQLRETURN SQLGetData(

SQLHSTMT StatementHandle,

SQLUSMALLINT Col_or_Param_Num,

SQLSMALLINT TargetType,

SQLPOINTER TargetValuePtr,

SQLLEN BufferLength,

SQLLEN * StrLen_or_IndPtr);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms715441(v=vs.85).aspx

·SQLRETURN SQLMoreResults(

SQLHSTMT StatementHandle);

接口详细说明参见http://msdn.microsoft.com/en-us/library/ms714673(v=vs.85).aspx

3.2 Example

3.2.1 C/C++

example

#include "sql.h"

#include <sqlext.h>

int32 main(int argc, char** argv)

{

SQLHANDLE hEnv = SQL_NULL_HENV;

SQLHANDLE hDbc = SQL_NULL_HDBC;

SQLHANDLE hStmt = SQL_NULL_HSTMT;

SQLRETURN nRet = SQL_SUCCESS;

HDBC* pHDDbc = NULL;

int8 nTimeOut = 3;

char szSQL[1024];

char szTagName[128];

char szTimeStr[24];

uint16 nQuality;

int32 nValue;

char szValue[1024];

float64 fValue;

char szTimeStep[24];

char szInterType[24];

int32 nCount = 0;

// 申请HDODBC环境句柄

nRet = SQLAllocHandle(SQL_HANDLE_ENV, NULL, &hEnv);

if(SQL_SUCCESS != nRet)

{

return nRet;

}

// 申请HDODBC连接句柄

nRet = SQLAllocHandle(SQL_HANDLE_DBC, hEnv, &hDbc);

if(SQL_SUCCESS != nRet)

{

SQLFreeHandle(SQL_HANDLE_ENV, hEnv);

return nRet;

}

// 设置HDODBC连接超时

nRet = SQLSetConnectAttr(hDbc, SQL_ATTR_CONNECTION_TIMEOUT, &nTimeOut, sizeof(nTimeOut));

if(SQL_SUCCESS != nRet)

{

SQLFreeHandle(SQL_HANDLE_DBC, hDbc);

SQLFreeHandle(SQL_HANDLE_ENV, hEnv);

return nRet;

}

// 连接数据源abc

nRet = SQLConnect(hDbc, (SQLCHAR*)"abc", strlen("abc") + 1, NULL, 0, NULL , 0);

if(SQL_SUCCESS != nRet)

{

SQLFreeHandle(SQL_HANDLE_DBC, hDbc);

SQLFreeHandle(SQL_HANDLE_ENV, hEnv);

return nRet;

}

// 申请Stmt句柄

nRet = SQLAllocHandle(SQL_HANDLE_STMT, hDbc, &hStmt);

if(SQL_SUCCESS != nRet)

{

SQLFreeHandle(SQL_HANDLE_DBC, hDbc);

SQLFreeHandle(SQL_HANDLE_ENV, hEnv);

return nRet;

}

// 执行SQL

strcpy(szSQL, "select * from HDInter where Ftag=\'TAG\' and FTime >= \'2013-09-12 10:00:00.000\' and FTime <= \'2013-09-18 11:00:00.000\' LIMIT 10 DESC");

nRet = SQLExecDirect(hStmt, (SQLCHAR*)szSQL, strlen(szSQL) + 1);

if(SQL_SUCCESS != nRet)

{

SQLFreeHandle(SQL_HANDLE_STMT, hStmt);

SQLFreeHandle(SQL_HANDLE_DBC, hDbc);

SQLFreeHandle(SQL_HANDLE_ENV, hEnv);

return nRet;

}

// 绑定字段buffer

nRet = SQLBindCol(hStmt, 0, SQL_CHAR, szTagName, 128, 0);

if(SQL_SUCCESS != nRet)

{

SQLFreeHandle(SQL_HANDLE_STMT, hStmt);

SQLFreeHandle(SQL_HANDLE_DBC, hDbc);

SQLFreeHandle(SQL_HANDLE_ENV, hEnv);

return nRet;

}

// 绑定字段buffer

nRet = SQLBindCol(hStmt, 1, SQL_CHAR, szTimeStr, 128, 0);

if(SQL_SUCCESS != nRet)

{

SQLFreeHandle(SQL_HANDLE_STMT, hStmt);

SQLFreeHandle(SQL_HANDLE_DBC, hDbc);

SQLFreeHandle(SQL_HANDLE_ENV, hEnv);

return nRet;

}

// 绑定字段buffer

nRet = SQLBindCol(hStmt, 2, SQL_INTEGER, &nQuality, sizeof(nQuality), 0);

if(SQL_SUCCESS != nRet)

{

SQLFreeHandle(SQL_HANDLE_STMT, hStmt);

SQLFreeHandle(SQL_HANDLE_DBC, hDbc);

SQLFreeHandle(SQL_HANDLE_ENV, hEnv);

return nRet;

}

// 绑定字段buffer

nRet = SQLBindCol(hStmt, 3, SQL_INTEGER, &nValue, sizeof(nValue), 0);

if(SQL_SUCCESS != nRet)

{

SQLFreeHandle(SQL_HANDLE_STMT, hStmt);

SQLFreeHandle(SQL_HANDLE_DBC, hDbc);

SQLFreeHandle(SQL_HANDLE_ENV, hEnv);

return nRet;

}

// 绑定字段buffer

nRet = SQLBindCol(hStmt, 4, SQL_CHAR,szValue, sizeof(szValue), 0);

if(SQL_SUCCESS != nRet)

{

SQLFreeHandle(SQL_HANDLE_STMT, hStmt);

SQLFreeHandle(SQL_HANDLE_DBC, hDbc);

SQLFreeHandle(SQL_HANDLE_ENV, hEnv);

return nRet;

}

// 绑定字段buffer

nRet = SQLBindCol(hStmt, 5, SQL_FLOAT,&fValue, sizeof(fValue), 0);

if(SQL_SUCCESS != nRet)

{

SQLFreeHandle(SQL_HANDLE_STMT, hStmt);

SQLFreeHandle(SQL_HANDLE_DBC, hDbc);

SQLFreeHandle(SQL_HANDLE_ENV, hEnv);

return nRet;

}

// 绑定字段buffer

nRet = SQLBindCol(hStmt, 6, SQL_CHAR,szTimeStep, sizeof(szTimeStep), 0);

if(SQL_SUCCESS != nRet)

{

SQLFreeHandle(SQL_HANDLE_STMT, hStmt);

SQLFreeHandle(SQL_HANDLE_DBC, hDbc);

SQLFreeHandle(SQL_HANDLE_ENV, hEnv);

return nRet;

}

// 绑定字段buffer

nRet = SQLBindCol(hStmt, 7, SQL_CHAR,szInterType, sizeof(szInterType), 0);

if(SQL_SUCCESS != nRet)

{

SQLFreeHandle(SQL_HANDLE_STMT, hStmt);

SQLFreeHandle(SQL_HANDLE_DBC, hDbc);

SQLFreeHandle(SQL_HANDLE_ENV, hEnv);

return nRet;

}

// 逐条取查询结果并printf

while(SQL_SUCCESS == SQLFetch(hStmt))

{

printf("Tag=%s, Time=%s,Quality=%d,FIValue=%d,FSValue=%s,FFValue=%f, FTimeStep=%s,FinterType=%s\n",

szTagName, szTimeStr, nQuality,nValue,szValue,fValue, szTimeStep,szInterType);

}

// 断开连接

SQLDisconnect(hDbc);

// 释放句柄

SQLFreeHandle(SQL_HANDLE_STMT, hStmt);

SQLFreeHandle(SQL_HANDLE_DBC, hDbc);

SQLFreeHandle(SQL_HANDLE_ENV, hEnv);

return 1;

}

3.2.1 C#

example

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Data.Odbc;

namespace baosight.ihyperdb.csharp.example.odbc

{

class Program

{

static void Main(string[] args)

{

try

{

// 连接字符串，支持三种格式

string constr = "dsn=abc;";

//string constr = "dsn=abc;Uid=admin;Pwd=admin";

//string constr = "DRIVER={iHyperDB ODBC Driver};SERVER=127.0.0.1;PORT=5678;UID=admin;PWD=admin";

// 建立连接

OdbcConnection conn = new OdbcConnection(constr);

conn.Open();

// 创建SQL命令

OdbcCommand cmd = conn.CreateCommand();

cmd.CommandText = "select * from hdinter where ftag='hdsys_cpu' and ftime < '2014-04-16 12:00:00.000' and ftime > '2014-04-16 9:00:00.000' and ftimestep = 1S limit 10 DESC;";

// 执行命令

OdbcDataReader reader = cmd.ExecuteReader();

// 读取结果集

Boolean bOk = reader.Read();

while (bOk)

{

// 读取当前结果集字段值

string strName = reader.GetString(0);

string strTime = reader.GetString(1);

Int32 nQuality = reader.GetInt16(2);

Int32 nValue = reader.GetInt32(3);

string strValue = reader.GetString(4);

double fValue = reader.GetDouble(5);

Console.Write("name:" + strName.ToString() + " time:" + strTime.ToString()+"\n");

bOk = reader.Read();

}

reader.Close();

cmd.Dispose();

conn.Close();

}

catch (System.Exception ex)

{

Console.WriteLine(ex.ToString());

}

}

}

}


SQL查询

Navigation: 功能明细 > 数据查询 > ODBC与SQL查询 >

SQL查询

 Return to chapter overview

· 简述

实时数据库提供一个可供用户操作SQL的界面进行历史记录查询，用户通过编写SQL语句，实现快速，便捷的历史记录查看。

从开始菜单->所有程序->iHyperDB->客户端应用快捷链接->SQL查询工具，弹出SQL查询界面，

如图1所示：(工具栏中的链接为ODBC数据源配置工具，SQL查询之前，请先配置ODBC数据源)

·功能介绍

§获取数据源名称

在“数据源名称”下拉框中，选择想要连接的ODBC数据源。

§表结构信息

通过表结果信息树，用户可以查询表中的字段，方便写SQL语句。点击树节点，树下面的显示树节点描述，如果是表名就是表描述，如果 是字段名则是字段描述

§快速生成SQL语句

1.生成默认SQL语句

在表名HDArch上右击弹出右键菜单如图2所示

点击“生成默认SQL语句”按钮，在右侧的SQL语句输入框中写入默认SQL语句:

SELECT * FROM HDArch WHERE FTAG = '' AND FTIME < '2017-12-05 09:30:52.000' limit 1000

时间为当前机器时间。

如果在表HDInter上右击，点击“生成默认SQL语句”按钮，默认的SQL语句为：

SELECT * FROM HDInter WHERE FTAG = '' AND FTIME > '2013-09-24 15:46:21.000'AND FTIMESTEP = 10S AND FINTERTYPE = PREV limit 1000

时间为当前机器时间往前推一小时。

在字段名上右击弹出的图片如图3所示：

Tag名称需要用户自行填入，时间为机器当前时间

2.生成SELECT语句

在表名上右击，然后点击“生成SELECT语句”按钮，生成SQL语句：SELECT * FROM HDArch 或者为 SELECT * FROM HDInter

点击“复制”按钮，表名被复制到黏贴板中，用户在SQL语句输入框中右击，选择“paste”写入SQL语句输入框也可以使用快 捷键Ctrl+V

在字段名上右击，然后点击“生成SELECT语句”按钮，生成SQL语句：SELECT 字段名,* FROM HDInter

如果此时，在别的字段上操作生成SELECT语句，则原来的语句变为：SELECT 新字段名,字段名,* FROM HDInter

用户需要手工删除逗号和*

3. 生成WHERE语句

在字段上名上右击，然后点击“生成Where语句”按钮，弹出配置对话框如图4所示：

通过下拉框选择要配置的字段，不同的字段，界面有所不同，图4是配置Tag字段的界面以及生成的Where语句。

配置时间的字段以及生成的Where语句如图5所示：

默认值：开始时间为当前时间往前推1个小时，结束时间为当前时间。

配置时间间隔字段以及生成的Where语句如图6所示：

时间间隔单位有四种：d天，h小时，m分钟，s秒，默认值为1m(1分钟)。

配置插值方式字段以及生成的Where语句如图7所示：

插值类型有2中一种是PREV， 一种是LINE, 界面默认值为LINE

点击“生成语句“生成where语句

用户自行复制语句到主界面的SQL语句输入框

4. 清空SQL语句

点击“清空”按钮，SQL语句输入框中的SQL语句被清空。

SQL查询

在SQL输入框中，输入正确的SQL语句，用户可以借助左侧树节点的右键菜单，快速的编写SQL语句，点击“执行“按钮，

查询符合条件的历史记录或者插值记录。

1、SQL语句不区分大小写

2、如果用户查询的是统计函数结果，结果一律显示为double类型，有六位小数，例如是127，则显示127.000000

3、设置的查询时间，FTIME的开始时间不能等于结束时间

4、生成SQL语句时，不对正确性进行校验；只在第一步，SQL语句执行时进行校验

显示符合条件的记录

点击完“执行“按钮以后，符合条件的记录显示在界面上，如果记录条数比较多，可以通过翻页查看，用户可以点击”每页显示条数“下拉框设置每页显示的记录条数，点击上一页下一页进行翻看，在输入框中输入想要去的页数，点击跳转，直接显示目标页数的记录。

注意：当数据库中的记录有所改变时，用户需要重新点击执行按钮进行查询

界面只支持最多显示十万条记录，当记录条数大于十万条时，截断后面的不显示，用户可以通过查询条件过滤掉过多的记录。


报警查看

Navigation: 功能明细 > 数据查询 >

报警查看

 Return to chapter overview

《报警查看》提供一个可视化的界面供用户查看服务器上的报警组，报警点以及其下的报警记录。

启动报警查看工具：

·方式一：从客户端的系统管理工具的工具菜单中打开。

·方式二：从开始菜单->iHyperDB->客户端应用快捷链接->报警查看客户端，点击打开。

“报警查看”整个界面由4大块组成，左侧区域是服务器上的报警组展示，右侧显示区域为选中的报警组下的普通报警点和SPC报警点上的实时记录，用户可以通过这一块内容了解到实时产生的报警信息，并通过一些操作可以对这些报警记录的信息状态进行修改。其中普通报警点的实时记录不可以隐藏,其余显示面板均可以隐藏显示。

请参考：

§报警记录查看

§报警记录通知

§报警记录确认

§报警记录历史查询

§报警记录注释

©2015. All Rights Reserved.


报警记录查看

Navigation: 功能明细 > 数据查询 > 报警查看 >

报警记录查看

 Return to chapter overview

本节主要介绍通过"报警查看工具"，使用报警组查看、报警记录查看、报警记录导出。

如何启动“报警查看”，请参考：报警查看 。

·报警组查看

·普通点报警记录查看

·SPC报警记录查看

·报警组查看

主要介绍如何通过“报警查看”页面查看服务器下的报警组。操作如下：

1.首先连接报警信息产生的服务器，点击菜单“文件”，弹出“服务器连接”按钮，如下图所示：

2.点击“服务器连接”按钮，弹出服务器连接的对话框，操作按照服务器连接管理器操作。连接服务器

3.对话框退出以后，如图所示：

通过对树节点的点击操作，可以展开多有的结点。

·普通点报警记录查看

§报警记录查看：

主要介绍如何在报警展示模块查看多个服务器上的报警记录。操作如下：

1.选择“报警查看”页面左侧树结点上报警组所在的服务器，点击要查看的报警组

2.该报警组上所有有报警记录的报警点显示在右侧实时显示区域 ，如图所示：

3.该警点上显示的是最新的那条报警记录，当新的报警记录产生以后，界面会自动更新， 当此条报警恢复以后，报警从界面上删除。

实时显示区域中的报警记录属性可以进行自定义当全选时，如下图所示：

当用户添加了新的报警点，并且新的报警点产生了报警，界面任务栏弹出提示信息,如图：

用户点击信息框中任意位置，界面刷新！

·SPC报警记录查看

选择“报警查看”页面左侧树结点上报警组所在的服务器，点击要查看的报警组

该报警组上所有有SPC报警记录的报警点显示在右侧SPC报警实时显示区域，如图所示：

该SPC报警点上显示的是最新的那条报警记录，当新的报警记录产生以后，界面会自动更新，当此条报警恢复以后，报警从界面上删除。

实时显示区域中的报警记录属性可以进行自定义当全选时，如下图所示：

双击某一条报警记录，可以显示当前该记录触发的判异条件，如下图所示：


报警记录注释

Navigation: 功能明细 > 数据查询 > 报警查看 >

报警记录注释

 Return to chapter overview

《报警记录注释》是指用户可以对实时报警界面和历史报警界面的报警记录添加一些注释

报警界面分为实时报警（上部）和历史报警（右上部），SPC实时报警（下部）和SPC历史报警报警界面分为实时报警（上部）和历史报警（下部）。

·实时报警注释

·历史报警注释

·实时报警注释

用户可以通过2种方式给报警记录添加报警注释：

§在实时显示界面，选中要注释的一行或者多行报警记录，点击工具条上“注释”按钮，弹出注释对话框注释

§在实时显示界面，选中要注释的一行或者多行报警记录，右击弹出右键菜单，点击“注释”按钮，弹出注释对话框注释。

添加注释对话框如下：

用户在编辑框进行编辑，编辑完成以后点击“添加”按钮，完成注释，点击“取消”，取消注释。

·历史报警注释

选中要注释的一行或者多行报警记录，右击弹出右键菜单，点击“注释”按钮，弹出注释对话框注释，如下图：


报警记录通知

Navigation: 功能明细 > 数据查询 > 报警查看 >

报警记录通知

 Return to chapter overview

《报警记录通知》主要介绍新的报警记录产生以后，“报警查看”对话框的的提示功能。

目前报警记录通知方式只支持普通点报警。

·新报警的通知方式：

新的报警记录产生以后，报警展示通过两种方式通知报警：

·第一种：托盘方式：

当托盘提示产生以后，界面上的变化主要分为三大部分：

§实时报警记录展示

当新的报警记录产生以后，如果该报警记录坐在的报警组所在的左侧树结点被选中，则更新右侧实时报警记录显示区域。

更新有两种情况：一是当前报警点显示在实时显示区域中，那么只需要更新这个报警点上的报警记录就可以了；二是当前报警点不在实时区域中显示，则将该报警点添加到实时显示区域中。

§报警组的图标

当一个报警记录产生以后，该报警点所在的报警组前面加上图标，如果一个子组有报警记录，则连带它的父组上面的图标都显示有报警记录产生，当一个组以及它的子组的下面都有没有报警记录，或者报警记录的状态为已恢复，则报警组前不添加图标。如图：

§任务栏托盘

任务栏的图片会根据新到报警记录的优先级闪动对应的图标。比如：来了一个优先级为紧急的图标，任务栏图标上不停闪动优先级紧急对应的图标，图标闪动原则，以优先级高的为准则，当目前闪动的优先级高的图标没有被点击掉之前，新产生的优先级低的报警不提示

·第二种：声音方式：

当用户开启声音提示功能，新的报警记录产生以后，系统根据新的报警记录的优先级发出对应的声音。用户可以自行配置声音响应的次数以及响铃。

§ 报警通知规则：

1.当新到的报警记录产生以后，恢复状态为否时，实时界面显示，当恢复状态为时，不显示，如果界面上已有这条报警记录，则在界面删除。

2.报警组树结点前永远显示改组下报警级别最高的图标，当改组下没有报警记录时，树结点前没有图标。

3.托盘只通知新产生的报警记录，对于确认状态的改变和注释状态的改变，不通知。

·报警记录提示的颜色和声音设置：

§声音设置

首先用户可以设置是否开启声音提示

其次用户可以设置提示的声音

用户还可以设置响铃次数

§颜色设置

用户可以对不同的优先级设置不同的颜色来提示，系统会根据用户设置的颜色来生成对应的提示图标。


报警记录确认

Navigation: 功能明细 > 数据查询 > 报警查看 >

报警记录确认

 Return to chapter overview

报警记录产生以后，用户可以通过在界面上的一些简单操作，对产生的报警记录进行确认，包括个别报警点的确认和一个报警组下所有未确认的报警点的确认：

·个别报警点确认

1. 选中界面上需要确认的报警点，选中时，该行变蓝，右击，弹出“确认”菜单，如下图所示：

2. 点击“确认”按钮，向服务器请求确认此条报警记录，如果服务器更新成功，该条报警记录的状态更新为“已确认”

3. 选中界面上需要确认的报警点，选中时，该行变蓝，点击菜单“工具”，弹出“确认”按钮，如图所示：

4. 点击“确认”按钮，向服务器请求确认此条报警记录，如果服务器更新成功，该条报警记录的状态更新为“已确认”

·一个组下所有未确定报警点确认

1. 右击报警组名，弹出“确认”菜单，如图所示：

2. 点击“确认”按钮，向服务器提交确认信息。

3. 向服务器提交确认信息以后，如果确认的报警组为当前选中的报警组，则在界面右侧显示区域显示所有的报警记录，如果用户切换 到了别的报警组，则显示区域不显示刚才操作的确认结果。


报警记录历史查询

Navigation: 功能明细 > 数据查询 > 报警查看 >

报警记录历史查询

 Return to chapter overview

对于历史报警记录，用户可以通过报警展示中的历史查询来完成，报警展示提供了历史展示的界面。

·报警点历史记录查询

·报警组历史记录查询

·普通报警历史查询设置

·SPC报警历史查询设置

·历史记录导出

·报警点历史记录查询

点下历史查询主要有三种方式：

1.在实时报警界面选中要查询的tag点，点击菜单上的“工具”->“历史记录查询”，弹出历史查询窗口，选择查询条件进行查询.

2.在实时报警界面选中要查询的tag点，点击工具条上的“历史记录查询”按钮，弹出历史查询窗口，选择查询条件进行查询

3.在实时报警界面选中要查询的tag点，右键点击，弹出右键菜单，点击历史记录查询，查询历史记录。

·报警组历史查询

在报警组展示界面，用户可以在报警组的树节点上右键点击，弹出右键菜单，弹出“历史记录查询”菜单，配置查询条件，点击查询。

注意. 当历史报警界面的列属性改变以后，历史报警界面不更新，请重新查询历史记录

·普通点历史查询设置

设置界面如下：

§时间查询： 用户可以设置一个时间段，查询在这个时间段内产生的报警。这里的开始时间为查询的起始时间和终止时间，都是报警的产生时间。

§报警类型：默认勾选HIHI和HIGH类型，用户可自定义，要是查全部类型的报警就全部勾选。

§优先级别：默认勾选紧急类型，用户可自定义，要是查全部优先级的报警就全部勾选。

§确认状态：默认勾选为确认， 用户可自定义，要是查全部确认状态的报警就全部勾选。

§是否恢复：默认勾选为否， 用户可自定义，要是查全部的报警就全部勾选。

点击确定，进行查询，点击重置，恢复到默认查询条件

历史查询规则：

§目前只支持查询条件内的50000条记录

§优先级，报警条件，确认状态，和是否恢复都是要勾选的，否则弹出提示框

§默认查询的结束时间是当前时间，开始时间是当前时间往前推一小时，用户可自行设置。

§开始时间大于1970年1月1日8点，终止时间小于2038年1月19日3点14分06秒

·SPC点历史查询设置

用户可以通过下图中界面对SPC报警记录历史查询进行设置

ü查询时间： 用户可以设置一个时间段，查询在这个时间段内产生的报警。这里的开始时间为查询的起始时间和终止时间，都是报警 的产生时间。

ü确认状态：默认勾选为确认， 用户可自定义，要是查全部确认状态的报警就全部勾选。

ü是否恢复：默认勾选为否， 用户可自定义，要是查全部的报警就全部勾选。

点击确定，进行查询，点击重置，恢复到默认查询条件

历史查询规则：

§目前只支持查询条件内的50000条记录

§确认状态，和是否恢复都是要勾选的，否则弹出提示框

§默认查询的结束时间是当前时间，开始时间是当前时间往前推一小时，用户可自行设置。

§开始时间大于1970年1月1日8点，终止时间小于2038年1月19日3点14分06秒）

·导出历史报警记录

在“报警查看”工具中选择“工具->历史记录导出”，如图

如果有历史报警记录，就可导出为csv文件。


WPS加载iHyperDB ODBC驱动数据

Navigation: 功能明细 > 数据查询 >

WPS加载iHyperDB ODBC驱动数据

 Return to chapter overview

1. 在系统驱动列表里添加iHyperDB ODBC驱动：

(1) 安装iHyperDB客户端；

安装完成后，先在LogClient.xml配置文件里加上ODBC相关配置，不然ODBC安装和调用都会有问题!

填写完ODBC日志配置后，以管理员身份打开cmd命令行，跳转至安装目录的executable文件夹，执行"hdODBCInst.exe -install"命令安装ODBC动态库，

确保windows的32位库文件夹里被安装程序复制了hdODBC.dll，才能进行下一步（win10系统里，32位库文件夹名称是"SysWOW64"，64位库文件夹名称是"System32"）

(2) 打开系统ODBC(32位)驱动列表，准备添加ODBC数据源；

(3) 填写iHyperDB ODBC驱动的详细信息，填写完点击确定。

数据源名称：iHyperDB ODBC驱动在驱动源列表里的注册名称；

数据源描述：对iHyperDB ODBC驱动的描述；

主机IP和端口：IHD数据库的主机IP和端口号；

备机IP和端口：IHD数据库的备机IP和端口号；

用户名：登录IHD数据库的用户名；

密码：登录IHD数据库的密码；

添加成功后，在用户DSN列表里可以看到iHyperDB ODBC的数据源名称。

2. WPS excel查询并导入IHD数据

打开WPS excel的导入数据接口，

按照以下步骤加载IHD数据：

(1) 选择ODBC数据源，点击"其他/高级"；

在弹出的窗口选择ODBC Drivers

在"机器数据源"列表里选择其他之前配置好的iHyperDB ODBC数据源

如果成功连接至数据源，会在窗口信息里看到iHyperDB ODBC的相关配置信息

(2) 选择IHD表和字段

在"表名"这一栏，可以选择IHD数据表，

点击">"或者">>"按钮，可以添加一个或者所有的选定字段。接着点击"下一步"进入SQL语句生成页面。

(3) excel自动生成SQL语句步骤

如图所示，excel会根据上一阶段选中的表和字段，自动生成对应的SQL语句。但是默认生成的SQL不符合IHD查询语法！

需要注意的是，查询IHD数据的SQL语句，必须要有where条件，也就是每次查询都需要手动输入符合IHD规则的SQL语句!

点击按钮"1"并输入SQL语句后，再点击"下一步"，进入查询数据的预览页面。

(4) 数据查询结果预览和导入

在预览页面，点击"完成"，即可将数据导入excel表格。

3. iHyperDB ODBC支持的常用SQL查询语法

(1) 查询实时值

SELECT [字段列1，字段列2，...] FROM HDRealTime WHERE FTAG='点名'

示例如下：

实时值：

// 查询单个tag点的实时值

SELECT * FROM HDRealTime WHERE FTAG = 'hdsys_cpu_0'

SELECT FTAG, FTIME, FQUALITY, FIVALUE, FTAGTYPE FROM HDRealTime WHERE FTAG = 'hdsys_cpu_0'

// 实时值模糊查询

SELECT * FROM HDRealTime WHERE FTAG = 'hd*'

SELECT * FROM HDRealTime WHERE FTAG = '*_cpu_0'

(2) 查询历史值

SELECT [字段列1，字段列2，...] FROM HDArch WHERE FTAG = '点名' AND FTIME < '时间' limit 1000

(查询历史值必须要加limit限制记录条数，并且历史值不能模糊查询)

示例如下：

历史值：

// 查询单个tag点的前1000个历史值

SELECT * FROM HDArch WHERE FTAG = 'hdsys_cpu_0' AND FTIME < '2024-03-21 14:04:42.000' limit 1000

SELECT FTAG, FTIME, FQUALITY, FIVALUE, FTAGTYPE FROM HDArch WHERE FTAG = 'hdsys_cpu_0' AND FTIME < '2024-03-21 14:04:42.000' limit 1000

(3) 查询插值

SELECT [字段列1，字段列2，...] FROM HDInter WHERE FTAG = '点名' AND FTIME > '时间' AND FTIMESTEP = '时间间隔(秒)' AND FINTERTYPE = PREV limit 1000

(查询插值必须要加limit限制记录条数，并且插值不能模糊查询)

示例如下：

插值：

// 查询单个tag点的前1000个插值

SELECT * FROM HDInter WHERE FTAG = 'hdsys_cpu_0' AND FTIME > '2024-03-21 13:05:53.000'AND FTIMESTEP = 10S AND FINTERTYPE = PREV limit 1000

SELECT FTAG, FTIME, FQUALITY, FIVALUE, FTIMESTEP, FINTERTYPE, FTAGTYPE FROM HDInter WHERE FTAG = 'hdsys_cpu_0' AND FTIME > '2024-03-21 13:05:53.000'AND FTIMESTEP = 10S AND FINTERTYPE = PREV limit 1000


数据展示

Navigation: 功能明细 >

数据展示

 Return to chapter overview

数据展示的多种方式介绍。


IMV数据代理

Navigation: 功能明细 > 数据展示 >

IMV数据代理

 Return to chapter overview

1.概述

iMV的数据代理功能主要是通过这个代理服务，读取ihyperDB中的数据和报警，传到iMV(cvs)展示出来。

注意该功能在3.6.0以后版本修改架构，不需要再ihd中配置转发，下面配置仅供老版本参考。

2.操作步骤

配置iMV服务器参数：

打开系统管理平台-IMV-iMV发布与更新，修改IP为iMV的redis服务所在机器的IP，以及数据源(datasource)名字的设置。修改后点击“保存”按钮。然后点击“重启服务”按钮，使得配置生效。

a)选择Tag点配置发布到iMV：

在系统管理工具里面配置新的tag点的时候，系统参数下面有个IMV发布，勾选上就可以了。注意增加iMV发布的点，都需要执行上面的重启服务，使得iMV代理服务读取新的配置。

b)在数据节点服务管理工具中启动hdImvDataProxyService

c)浏览器访问iMV，地址形如http://IP:18080/cvs/console/index.html

登陆帐户密码请咨询iMV系统安装人员，注意租户名字，默认iHD发送给user租户。

d)登陆后，点击变量管理选项，可以看到之前选择iMV发布的Tag点及实时记录了，单击刷新可以查看最新的实时记录

3.历史记录趋势图

a)登陆后，点击画面管理选项

b)在根目录下选择“新建画面”，输入画面名称，如“userhelp”，点击确定，根目录下产生了一个名为userhelp的画面图标。双击这个图标，打开画面。

c)从左侧工具栏的“高级控件”中，拖拽趋势控件到右侧的画布上

d)在控件上右键弹出的菜单中选择“趋势配置”

e)在基本属性中，输入趋势名称，选择趋势时间

在曲线配置中，点击“新增组”，输入组名后，点击“添加”

在界面下方点击“新增曲线”，输入曲线名称并关联ihd 的tag点，点击“添加”

f)按键盘上的F6，启动运行态模式，如下图。可以在界面下方的时间区间，查看趋势。

4.报警记录查看

a)在iHD配好报警点

b)从左侧工具栏的“高级控件”中，拖拽报警控件到右侧的画布上

c)在控件上点击右键，从右键菜单中选择报警配置，本例中使用默认配置。

d)按F6进入运行模式，查看报警如下图

5. 历史记录查询

a). 从左侧工具栏的“高级控件”中，拖拽历史报警控件到右侧的画布上

b). 按F6进入运行模式

c). 输入查询条件，单击查询按钮开始查询

6.远程更新配置功能

当添加新的iMV发布Tag点后，需要重启服务，用于更新配置。

打开系统管理平台-iMV-iMV发布与更新，单击“重启服务”按钮。成功后新添加的tag点就出现在iMV系统中了。有时如果重启服务失败，请再次点击按钮重启服务。

7、iHyperDB中查询IMV发布的点

在查询数据中选择高级查询，选择IMV发布状态，接下来选择Like，后面填上IMV=1;%，如下图，点击添加，即可查询IMV发布的点：

8、iMV画面显示iHyperDB点的描述

在点名后面使用A_DESC域名来读取, 如ihd3.tag1.A_DESC。

注意：1)安装后iMV代理的授权要求使用iHyperDB的，如果iMV使用其他授权系统，可修改iHyperDB数据代理配置，在安装目录config\dataproxy.xml文件：文件中的isauth参数，如果是'0',则不使用iHyperDB授权，如果是‘1’，则使用iHyperDB授权。

2)租户lessee的参数，默认是user，可根据cvs配置自定义修改，对应的密码pass参数如果不是默认的也需要修改。

注意：如果是双机冗余时，主机和备机都要修改。


电子表格

Navigation: 功能明细 > 数据展示 >

电子表格

 Return to chapter overview

实时数据库可以与广泛使用的微软办公软件Excel结合，通过在Excel中安装插件的形式，充分的利用Excel处理数据的优势。Excel插件可以实现对数据库中点的配置、下载、上传、查询、数字状态集管理、错误码查询等诸多功能，十分方便快捷。（注意：Excel和Newlims软件冲突，无法同时使用）本章节内容如下：

·Excel插件的功能

§数据源操作

üTag上传

üTag下载

üTag查询

§查询记录

ü查询实时记录

ü查询历史存储记录（时间区间模式）

ü查询历史存储记录（记录条数模式）

ü查询历史插值记录（等间隔模式）

ü查询历史插值记录（时间点模式）

§服务器连接管理器

§数字状态集管理

§错误码查询

·Excel拖选模式

·时间戳格式

在Excel中iHyperDB的插件外形如下：

注意事项：

1）实时数据库Excel插件与office Excel版本需一致,即32位安装程序对应32位office Excel, 64位安装程序对应64位office Excel;

2）不支持同时启动2个Excel,即打开2个文件。

3) 查询记录功能不支持Blob数据类型的查询


Excel中实时数据库插件的功能

Excel中iHyperDB插件的功能

Navigation: 功能明细 > 数据展示 > 电子表格 >

Excel中iHyperDB插件的功能

 Return to chapter overview

iHyperDB与Excel软件紧密结合，同时融合了Excel对表格类型数据的强大处理能力和iHyperDB对大容量数据处理的优势。Ecxel中的iHyperDB插件主要提供以下功能：

·数据源操作

·查询记录

§查询实时记录

§查询历史存储记录（时间区间模式）

§查询历史存储记录（记录条数模式）

§查询历史插值记录（等间隔模式）

§查询历史插值记录（时间点模式）

·服务器连接管理器

§

·数字状态集管理

·错误码查询


数据源操作

Navigation: 功能明细 > 数据展示 > 电子表格 > Excel中实时数据库插件的功能 >

数据源操作

 Return to chapter overview

《数据源操作》完成和数据源相关联的一系列操作，其中包括从服务器下载点到Excel中展示、在Excel中配好点并上传到服务中、添加修改和删除服务器上的点并按照一定的要求从服务器中查询需要的点。

本章节主要内容包括：

·Tag下载

·Tag上传

·Tag查询

©2015. All Rights Reserved.


Tag下载

Navigation: 功能明细 > 数据展示 > 电子表格 > Excel中实时数据库插件的功能 > 数据源操作 >

Tag下载

 Return to chapter overview

《Tag下载》主要讲述了从服务器下载普通点或者报警点到Excel表格，步骤如下：

1.单击Excel文件中的加载项"iHyperDB”，弹出列表，选择“高级”

2.点击【Tag下载...】，弹出"Tag下载"页面，

3.从“点类别”下拉菜单中选择点列别，包括（普通点，报警点，统计点和计算点），在选择属性中配置需要显示的属性，可以选择“全部属性”，也可以通过点击“自选属性”，选择需要显示的列属性；

4.填写查询条件，可以通过填写精确的tag名进行精确查询，也可以通过*Tag名，或者tag名*进行模糊查询。选择并填写查询条件， 此处我们也可以通过使用高级查询功能，查询符合条件的tag。

点击“高级查询”的【搜索】按钮，弹出Tag查询对话框

点击查询对话框中的【查询】按钮，Tag显示列表中会显示当前所有配置的Tag点，选择hdsys_cpu_0，并点击【确定】。

5.单击【确定】按钮，该窗口关闭，此时Tag下载页面中“高级查询”中显示了我们需要下载的Tag点信息

点击【确定】，弹出对话框

点击【是】，弹出对话框

6.点击【确定】，Tag_test点的信息会被下载显示到Excel表格中。

?第一列中的“选择(x)”表示该Tag行被选中。

?输出到Excel中的Tag点的格式为:第一行:选择(x),Tag属性名；

第二行：x，Tag属性值；

第三行：x，Tag属性值；

......

其中“Tag点下载”页面介绍主要包括三个内容：

·选择点类别

用来选择要下载的点的类型，即下载普通点、统计点、计算点或是报警点

·选择属性

“选择属性”项用于显示和自定义显示的属性项。

§普通点和报警点有不同的属性，且报警点只显示所有的属性，不可以自定义，因此自定义属性只针对普通点。

§在选择报警点时右侧两个按钮“全部属性”和“自选属性”不可用。

单击“全部属性”，已选属性框中显示全部的属性。单击“自选属性”，弹出如上对话框：边的“可选属性”列表，列出待选的Tag属性。右边的“已选属性”列表，列出已选的Tag属性。

§点击按钮可以将属性全体右移或左移

§选中一个属性，点击按钮，可将该属性右移或左移

§在已选属性列表中，单击选中一个属性上下拖拽至任意位置，完成排序功能

§单击确定按钮，将“已选属性”列表中的属性返回

【说明】对于普通点、统计点和计算点，“OPC发布状态”列会始终显示在Excel中，对于报警点，“OPC发布状态”不会显示到Excel列表中。

·查询条件

1. Tag名查询: 输入希望下载的Tag查询条件

§Tag名查询中查询条件不能为空，最大支持31个字节。

§支持模糊查询，“*”表示多字符模糊查询 ，“？”表示单字符模糊查询。

§Tag类型不能手动填，只能从下拉菜单中选择

§点击“重置”可以重置所有的查询条件为“*”，在这种查询条件下会查询到服务器中的所有Tag点

2. 高级查询:选择高级查询tab页，填写高级查询的查询条件

§第一个下拉框包含Tag的所有属性，从中选择一个属性

§第二个下拉框根据已选属性提供可选择的操作方式，符号含义如下表所示：

操作方式 | 含义
= | 等于
<> | 不等于
< | 小于
<= | 小于等于
> | 大于
>= | 大于等于
like | 模糊查询

§模糊查询中，“*”表示多字符模糊查询 ，“？”表示单字符模糊查询

§不同属性可使用的操作方式的规则如下表所示，详细见数据源属性的“查询操作方式”列

属性类型 | 可使用的操作方式 | 属性
字符串类型 | =，<>，like | Tag修改者，Tag创建者等
只有特定值或特定格式 | =，<> | Tag类型，Tag访问权限等
数值类型 | 除like均可 | 压缩超时，压缩误差等

§右上输入框用来输入Tag属性值，最大支持31个字节。输入值后，“添加”按钮变为可操作状态，单击将查询条件导入下方查询条件框。按上述方法可继续添加查询条件，查询条件框中末尾另起一行添加新条件，格式不变。

§查询条件格式为“Tag属性+空格+操作方式+空格+Tag属性值”

§用户在查询条件框中手动添加和修改查询条件，只要格式正确即可

§查询条件框中一行只能有一个查询条件，且上一个查询条件和下一查询条件之间不能有空行

§最多支持100个查询条件

§查询条件间是“与”的关系

§若查询条件框中没有查询条件，则查询服务器中的所有Tag

§点击重置按钮，右上输入框和查询条件框清

§显示方式：点击“查询”按钮，查询所有符合条件的Tag，查询结果显示在列表中，列表原有的信息将被清空。如下图：

Ø列表每页最多显示20条Tag

ØTag显示列表中，默认的列名为：选择、Tag名、Tag类型和Tag描述，点击列头可以排序

Ø鼠标放在列表中，右键单击弹出菜单，弹出菜单中单击添加列，弹出选择Tag属性对话框，选择需要添加的属性列。单击“恢复原始列”则恢复到默认的列。 点击列表中的行，可以选中和取消选中所在行的Tag

Ø单击“全选本页”则可选中和取消选中当前页的所有Tag；单击“全选所有页”则可选中和取消选中所有页中的Tag

Ø可按“上一页”和“下一页”翻页 ，当前是第1页时，“上一页”不可按，当前页是尾页时，“下一页”不可按

Ø“下一页”后面的小方框里显示当前的页号，方框后面显示总的页数

Ø在方框中填写需要查看的页码，单击“跳转”按钮则跳转至该页

3. Excel选择

点击按钮，进入Excel拖选模式，从Excel选择要下载的Tag名，其地址显示在框中。

§所选的Tag名只能是一行或一列,不能为多行或多列

§在一行或一列中，若某个单元格内容为空，则跳过后继续处理下面的单元格

§若地址有多个不连续的单元组成，则只处理地址中的第一个单元

§支持手动输入Excel地址，格式相同即可

§Excel选择框不能为空

©2015. All Rights Reserved.


Tag上传

Navigation: 功能明细 > 数据展示 > 电子表格 > Excel中实时数据库插件的功能 > 数据源操作 >

Tag上传

 Return to chapter overview

Tag上传是指用户把点的各种属性在Excel中配好后，上传到实时数据库服务器。

《Tag上传》主要内容包括：

·创建模式

创建模式指在Excel中配置的需要上传的Tag点在服务器中不存在，需要在服务器中创建这些点。

使用如下：

1.首先在Excel中配好需要上传的5个点，

2.在Excel插入想中点击“iHyperDB”->【tag上传...】，弹出如下对话框，从“服务器名”的下拉菜单中选择服务器（默认为上次连接的服务器），在点类型下拉菜单中选择普通点或者是报警点，选择创建模式模式，单击确定，把Excel中配好的点上传到服务器中，

3.单击确定，把Excel中配好的点上传到服务器中，进度条显示进度，上传成功后显示上传的点个数。

4.点击确定，Tag点上传的“创建模式”完成，这时服务器中就会存在刚才上传的upload_1到upload_5的所有Tag点。

Excel中的数据将被上传至服务器，应确保其格式正确：

Tag属性名在第一行，且第二列必须是属性“Tag名”

Tag属性值从第二行开始写，每行的第一个单元格需要设置为x才会被上传，"Tag名"属性值不能为空

如果是新增Tag，“Tag类型”属性必须要有，且属性值[int8,int16,int32,float32,float64,digital,string,blob]不能为空。

注意：

1）在“创建模式”中，若上传的Tag点在服务器已经存在，则报错

2）关于计算点的excel上传：通过excel上传计算点的时候，如果某一行数据上传失败且只有该行的第一列被红色标记出来（即不能定位到具体哪一列出错），那么请检查计算点的计算表达式的配置是否正确。

3）不能直接用老版本的Excel导出文件上传到v3服务器，因为excel列格式不同了，请重新下载v3最新格式编辑后再上传。

·修改模式

修改模式指在Excel中配置的需要上传的Tag点在服务器中已经存在，在服务器中修改这些点。使用如下：

1. 首先在Excel中创建需要修改的点，本例中修改在“创建模式”中上传的"upload_1"Tag点

将该点的“设备点名”进行修改，如下图

2. 单击Excel中iHyperDB插件中的Tag上传

弹出对话框

在模式中选择“修改”

3. 单击确定，将Excel中修改的点上传到服务器中，进度条显示进度，上传成功后显示操作成功Tag点个数。

在“修改模式”中，如果需要修改或者删除的Tag点在服务器中并不存在，则报错。

如在上例中若修改的是“upload_6”，

点击上传时候会弹出对话框

·创建或修改模式

创建或修改模式是指对于在Excel中配置的Tag点，判断其在服务器中是否存在，如果不存在，则在服务器中创建此点，如果存在，则在服务器中修改该点。使用如下：

1. 在Excel表格中修改“upload_1”Tag点的“设备点名”，以及新建一个需要上传的“upload_6”Tag点

2. 在Excel中点击iHyperDB插件中的Tag上传

弹出对话框

在模式中选择“创建或修改”

3. 点击确定，弹出操作成功提示框

·删除模式

删除模式是指在Excel中配置的需要删除的点在服务器中刚已经存在，将这些点从服务器中删除。

1. 在Excel表格中配置需要删除的Tag点“upload_1“以及”upload_2”

2.点击Excel中iHyperDB插件，选择“Tag上传”

弹出“Tag上传...”对话框，选择“删除模式”

3. 点击确定，弹出操作成功对话框

4. 点击确定，操作成功。在服务器中就删掉了“tag001”这个Tag点。

在“删除模式”中，如果需要修改或者删除的Tag点在服务器中并不存在，则报错，弹出对话框

在Excel中配好的点需要保存才可进行“上传”操作。

·数据节点

若配置数据节点较多时，tag点上传可以选择相应数据节点进行上传操作；


查询记录

Navigation: 功能明细 > 数据展示 > 电子表格 > Excel中实时数据库插件的功能 >

查询记录

 Return to chapter overview

查询记录模块下的选项用于从指定的服务器中，按照用户配置的要求，查询实时记录、历史存储记录和历史插值记录，并将这些查到的记录下载并显示到Excel表格中。

主要有以下五部分内容：

·查询实时记录

·查询历史存储记录（时间区间模式）

·查询历史存储记录（记录条数模式）

·查询历史插值记录（等间隔模式）

·查询历史插值记录（时间点模式）


查询实时记录

Show "查询实时记录"的使用

Navigation: 功能明细 > 数据展示 > 电子表格 > Excel中实时数据库插件的功能 > 查询记录 >

Show "查询实时记录"的使用

 Return to chapter overview

查询实时记录是指查询一个或多个Tag点实时的记录，同时将数据质量和时间戳等信息显示到Excel中。本主要内容包括：

§"查询实时记录"的使用

§"查询实时记录"页面介绍

·"查询实时记录"的使用

§从iHyperDB菜单中选择“实时记录...”

弹出“实时记录”对话框，选择Tag名，输出单元格，勾选是否显示数据质量以及输出格式对话框，

单击确定，在Excel中会显示出点Tag1的实时记录

·"查询实时记录"页面介绍

“查询实时记录”页面介绍，主要包括：

§Tag名：指定需要查询实时记录的Tag

有三种方法：

1. 手动输入：在Tag名下方输入栏中输入一个Tag名，查询该Tag的实时记录。

ü不支持多个Tag的查询，不能包含“;”。

ü不允许以空格开头。

ü该项必填，不能为空白。

2. 从Excel中选择：点击输入栏右侧按钮，进入Excel拖选模式，选中Tag后确定返回，显示选中的单元格位置

ü所选的Tag名只能是一行或一列,不能为多行或多列，否则查询时报错

ü在一行或一列中，若某个单元格内容为空，则跳过后继续处理下面的单元格

ü若地址不连续，则只处理最靠近左上角的一个Tag行（或列）

üTag名引用的地址必须在当前sheet下，不能跨sheet引用

ü最多能选择65535个Tag名。

3. 用Tag查询功能选择Tag：点击最右边的按钮弹出Tag查询对话框，查询到需要的一个Tag后选中并按确定返回，显示Tag名称。

ü用此方法只能查询一个Tag的实时记录。

ü若在查询中选择多个Tag，只会查询第一个。

ü该项必填，不能为空白。

§输出单元格

输出单元格：点击输出单元格右方的按钮，进入Excel拖选模式，选中单元格后返回

ü不论选中区域多大，都以区域的左上角第一个单元格为准，然后向右向下输出信息

ü输出单元格引用地址必须在当前sheet下，不能跨sheet引用

ü支持手动输入，格式相同

ü输出单元格不能为空白

§输出格式

指定数据质量：在“显示数据质量”前方的复选框内画勾表示显示数据质量，反之不显示。

时间戳显示方式：选择“不显示时间戳”、“时间戳在上”或者“时间戳在左”。

输出：单击确定键，开始把实时记录值下载并显示到Excel中，同时查询实时记录窗口关闭

ü如果选择了“时间戳在左”也选择了“显示数据质量”，那么一行中依次显示为“时间戳”、“数据质量”“实时记录值”。

ü如果选择了“时间戳在上”也选择了“显示数据质量”，那么一列中依次为“时间戳”、“数据质量”、“实时记录值”。

ü如果没选显示数据质量，那么数据质量就不显示，只显示三种信息

ü按ctrl + alt + F9键，Excel可以刷新Tag点实时记录的显示

ü若不能查询到Tag对应的记录，则在Excel对应的记录单元格中显示提示信息“#VALUE!”

ü如果是手工输入或者用Tag查询方式进行查询，只显示一个Tag的记录。


查询历史存储记录（时间区间模式）

Navigation: 功能明细 > 数据展示 > 电子表格 > Excel中实时数据库插件的功能 > 查询记录 >

查询历史存储记录（时间区间模式）

 Return to chapter overview

查询历史存储记录(时间区间模式):查询一个Tag在起始时间和终止时间区间之内的历史存储记录，同时把数据质量和时间戳等信息显示到Excel中。使用步骤如下：

从Excel中的iHyperDB插件菜单中选择“查询历史存储记录（时间区间模式）..."，

弹出"历史存储记录(时间区间模式)"对话框。

填写Tag名，填写起始和终止时间，指定输出单元格，选择数据质量是否显示和时间戳的输出格式，查询时间支持yyyy/mm/dd和yyyy-mm-dd格式

单击确定按钮即可把查询到的记录下载到Excel中。

时间戳格式：时间格式有默认值，根据当前时间自动生成。例如：起始时间2011-08-04 13：18：03 终止时间2011-08-04 14：18：03，相差一个小时

，除默认值外，有两种方法输入时间：

§手动输入时间，格式和上例一致，例如起始时间2011-08-04 08:40:00 终止时间2011-08-04 14:18:3 ，或者起始时间2013/01/01 11:12:12，终止时间2013/12/31 23:00:00

§从Excel中选择，点击Tag名旁边的表格按钮，进入Excel托选模式，选中单元格后确定放回，选择右侧表格按钮时，选中的单元格的内容需要是符合格式的时间，如下图，选择的$D$4单元格是图中左边第一列的单元格，按照这个格式，也可以成功查询到数据：


查询历史存储记录（记录条数模式）

Navigation: 功能明细 > 数据展示 > 电子表格 > Excel中实时数据库插件的功能 > 查询记录 >

查询历史存储记录（记录条数模式）

 Return to chapter overview

《查询历史存储记录（记录条数模式）》主要介绍了如何查询一个Tag从某一时刻起指定条数的历史存储记录，同时把数据质量和时间错误等信息显示到Excel中。记录条数模式的历史存储记录使用如下：

在Excel中选择iHyperDB插件中的“查询历史存储记录（记录条数）...”

弹出“历史存储记录（记录条数模式）”页面

填入Tag名，输入起始时间，记录条数，指定输出位置和查询类型，选择数据质量和时间戳格式，

单击确定，查询到的Tag点会下载到Excel中显示。

查询类型包括向前查询和向后查询：

§向前查询：表示向起始时间之前查询 。上例中，我们选择了向前查询，即在起始时间2011-08-09 09：39：11起向前查询5条记录。

§向后查询：表示从起始时间起向接近当前时间的方向查询。如下图

©2015. All Rights Reserved.


查询历史插值记录（等间隔模式）

Navigation: 功能明细 > 数据展示 > 电子表格 > Excel中实时数据库插件的功能 > 查询记录 >

查询历史插值记录（等间隔模式）

Return to chapter overview

《查询历史插值记录（等间隔模式）》主要介绍查询一个Tag点在一段区间之内指定时间间隔上的历史!MISSING PHRASE '插值记录'!，同时将数据质量和时间戳等信息显示到Excel中。

1. 从iHyperDB菜单中选择“查询历史插值记录（等间隔）..."，

弹出如下对话框：

填写Tag名，服务器名，起始和终止时间，时间间隔，输出单元格等信息

点击确定，在Excel中显示的历史记录。

输入时间间隔：

两种方法：

ü手动输入，不能以空格开头。

ü从Excel选择，点击Tag名旁边的表格按钮，进入Excel拖选模式，选中时间间隔后按确定返回，显示选中的单元格位置。

说明：

ü时间间隔格式为1d， 1h， 1m，1s，分别表示1天，1小时，1分钟，1秒

ü支持多个时间格式叠加，如1h30m,表示1小时30分钟

ü若时间间隔以负号开头，则表示计算时间间隔时从中止时间开始

ü若时间间隔为正，则表示计算时间间隔时从起始时间开始

ü若统计点进行插值查询，则起始时间为统计点属性页上设置的时间+采样偏移量，而间隔时间是属性页上的采样周期

输出：单击确定键，开始下载历史插值记录值并显示到excel中，同时查询实时记录窗口关闭

ü如果选择了时间戳在左和显示数据质量，显示模式如下图。

ü如果选择了时间戳在上和显示数据质量，显示模式如下图。

v不支持对string，blob，digital三种类型数据的插值查询。

v如果在某些时间点没有插值记录，或者插值查询没有成功，在相应的单元格中会显示#VALUE! 。

v等间隔模式查询的记录条数最多为65535条。

v等间隔模式只能精确到秒。如果想要查询精确到毫秒的插值记录，参见 查询历史插值记录（时间点模式）。


查询历史插值记录（时间点模式）

Navigation: 功能明细 > 数据展示 > 电子表格 > Excel中实时数据库插件的功能 > 查询记录 >

查询历史插值记录（时间点模式）

 Return to chapter overview

《查询历史插值记录（等间隔模式）》主要介绍了在Excel中查询一个Tag在指定的一个或多个时间点上的历史!MISSING PHRASE '插值记录'!，同时把数据质量和时间戳等信息显示到Excel中。使用如下：

在Excel中选择iHyperDB插件中的“查询历史插值记录（时间点）...”，

弹出“历史插值记录（时间点模式）”对话框

填写Tag名“pt_tag”，选择时间戳，输出单元格，勾选是否显示数据质量，选择输格式中时间戳的位置

点击确定，将插值记录以时间点的格式显示到Excel表格中。

·时间戳格式：有两种方法输入时间

§手动输入时间。

§从Excel中选择。点击Tag名旁边的表格按钮，进入Excel拖选模式，选中时间后按确定返回，显示选中的单元格位置（以空格开头）。

·输出结果：单击确定键，插值记录值显示到excel中，同时查询历史插值记录窗口关闭。如果待查询的记录个数过大需要等待若干秒，一次最多可以查询65535条记录。

§显示模式有两种：时间戳在上、时间戳在左。

§不支持对string，blob，digital三种类型数据的插值查询。

§如果在某些时间点没有插值记录，或者插值查询没有成功，在相应的单元格中会显示#Value!


图形用户界面查询

Navigation: 功能明细 > 数据展示 > 电子表格 > Excel中实时数据库插件的功能 >

图形用户界面查询

 Return to chapter overview

《图形界面查询》主要介绍了如何使用顶部功能区图形界面进行“单值查询”、“多值查询”、“计算查询”等。具体使用如下：

u插件安装

u连接服务器

u单值查询

u多值查询

u计算查询

u其他

u 连接服务器：点击“加载项”-“实时数据库”-“服务器连接”，在服务器连接管理器窗口中填写连接信息并确定；

u 单值查询：

·当前数据：查询当前数据是指查询一个或多个Tag点的实时记录，同时将点值和时间戳等信息显示到Excel中；涉及函数-hd_CurrVal

1.点击“当前数据”，弹出侧边任务栏；

2.选择要查询的相应tag点；

3.配置输出单元格并确定；

·归档数据：可以根据时间查询归档数据，同时将查询出的归档数据和时间戳等信息显示到Excel中；涉及函数-hd_ArcVal、hd_ExpVal

1.点击“归档数据”，打开侧边任务栏；

2.选择要查询tag点，查询模式可以选择按点名或按表达式查询；表达式过滤目前仅支持"><="，tag点名需以单引号区分，如'hdsys_cpu_0'>1

3.配置所要查询的时间信息，可以在工具栏“归档数据”下拉框快速筛选“昨天凌晨”、“今天凌晨”、“当前值”，也可以在任务栏“时间戳”处输入想要查询的归档数据时间戳

4.选择“取值模式”

前值：返回与指定时间戳完全匹配或在其之前的值；

只取前值：返回在指定时间戳之前的值；

插值：返回指定时间的插值；

后值：返回与指定时间戳完全匹配或在其之后的值；

只取后值：返回在指定时间戳之后的值；

准确时间：返回一个与时间戳完全匹配的值，或返回错误码（如果该时间戳上不存在任何值）

5.选择输出单元格，时间戳信息后，点击“确定”，即可将查询出的值信息展示在表格中

u 多值查询：

·历史数据查询：可以查询历史数据，同时将查询出的历史数据和时间戳等信息显示到Excel中；涉及函数-hd_CompValNum、hd_NCompFilDat、hd_CompValRange、hd_CompFilDat

1.点击“历史数据查询”，打开侧边任务栏；

2.选择要查询的Tag点；

3.选择查询模式，可以选择按数据或按时间进行历史数据查询；

a.若选择“按数量”查询，则需配置开始时间及查询数量；

b.若选择“按时间”查询，则需配置开始时间及结束时间；可以选择工具栏“历史数据查询”下拉框进行快速筛选时间段，也可以在侧边任务栏自定义配置开始时间及结束时间；

4.配置过滤表达式（可选）、输出单元格，数据质量、排序方式，点击“确定”，即可将查询出的值信息展示在表格中，如下图：

·插值查询：根据时间间隔进行插值查询，同时将查询出的插值数据和时间戳等信息显示到Excel中；涉及函数-hd_SampDat、hd_SampFilDat

1.点击“插值查询”，打开侧边任务栏；

2.选择要查询tag点；

3.配置插值时间；可以在工具栏“插值查询”下拉框进行快速筛选时间，也可以在侧边任务栏自定义配置开始时间、结束时间、时间间隔；时间间隔表达式格式为：1d2h3m4s，d表示天，h表示小时，m表示分钟，s表示秒。

4.选择输出单元格、排列方式，即可将查询出的值信息展示在表格中，如下图：

·时间点查询：根据时间点进行点值查询，同时将查询出的数据和时间戳等信息显示到Excel中；涉及函数-hd_PITimeDat、hd_TimeExpDat

1.点击“时间点查询”，打开侧边任务栏；

2.选择要查询的Tag点；

3.配置时间戳、查询方式；

4.选择输出单元格，点击“确定”，即可将查询出的值信息展示在表格中，如下图：

u 计算查询：

·数据计算：可以查询计算值，同时将查询出的数据和时间戳等信息显示到Excel中；

涉及函数-hd_AdvCalcVal、hd_AdvCalcFilVal、hd_AdvCalcDat、hd_AdvCalcFilDat、hd_AdvCalcExpVal、hd_AdvCalcExpFilVal、hd_AdvCalcExpDat、hd_AdvCalcExpFilDat

1.点击“数据计算”，打开侧边任务栏；

配置项名词解释：

查询目标；查询的点值对象

开始时间：计算开始时间

结束时间：计算结束时间

时间间隔：开始和结束时间之间，每一段统计时间的长度，如1d2h3m4s，d表示天，h表示小时，m表示分钟，s表示秒。

过滤表达式：可以将超过一定范围的值剔除，不纳入统计范围，表达式tag名需用单引号；如：'tag1'>=100,则将大于100的点剔除，不纳入统计。

转换系数：返回值的系数，如果是1说明不需要考虑系数；放大：统计值=实际统计值*系数；缩小：统计值=实际统计值/系数

统计类型：可选的统计类型有：最小值、最大值、求和、计数、算数平均值、标准差。

u 最大值：统计区间内最大值

u 最小值：统计区间内最小值

u 求和：统计区间内所有数据的和

u 计数：反映数据在统计范围内的持续时间：

❖如>10,则记录统计点的值>10的持续时间，单位为S（秒）。

u 平均值：统计区间内数据的平均值，具体依据统计基准选项：

u 标准差：统计区间内标准差，反映数据偏移平均值的大小

u 计时：反映数据在统计范围内的持续时间；例如>10,则记录统计点的值>10的持续时间，单位为S（秒）。

统计基准：统计基准分为算术平均值、时间加权平均值；

u 算术平均值：统计区间内数据的算数平均值；

u 时间加权平均值：统计区间内的数据积分，再除以时间，比算术平均值更均匀；

采样模式：采样取值模式有原始值、线性插值；

采样频率：统计数据的采集频率；

插值采样周期：插值的计算周期，如1d2h3m4s，d表示天，h表示小时，m表示分钟，s表示秒；

信任度：最小信任范围0-100，默认0，可以填写整数或小数。信任度指区间质量为good的点所占的百分比高于或等于制定的百分比，认为该记录可信。如果100%，代表统计区间内的必须100%全为good点，此统计点才为good; 如果0%,代表只要统计区间内有good点,此统计点均为good.

2.选择要查询tag点，查询目标可以选择按点名或按表达式查询；表达式过滤目前仅支持"><="，tag点名需以单引号区分，如'hdsys_cpu_0'>1

3.配置查询时间，统计类型、输出单元格等；

4.点击“确定”后，可以在所选表格中查看统计结果；

u 其他：

点击“关于”，弹出软件相关信息；


服务器连接管理器

Navigation: 功能明细 > 数据展示 > 电子表格 > Excel中实时数据库插件的功能 >

服务器连接管理器

 Return to chapter overview

服务器连接管理器用来管理所有的已连接和未连接的服务器，通过管理器可以添加，删除，修改服务器、查看连接信息、进行连接设置和测试连接状态等。《服务器连接管理器》主要介绍如何使用服务连接管理器来对服务器进行配置。

在Excel中的iHyperDB插件下拉菜单中选择【服务器连接...】

进入“服务器连接管理器”对话框，如下图：


报警分组配置

Navigation: 功能明细 > 数据展示 > 电子表格 > Excel中实时数据库插件的功能 >

报警分组配置

 Return to chapter overview

·概述

本模块完成在Excel中导出和导入报警点分组的功能。用户可以从指定服务器上下载并查看报警点及其分组情况，也可以批量导入报警点。

·报警分组下载

在Excel中，“加载项”-“ 实时数据库”-“报警分组下载”，弹出报警分组下载对话框。

服务器名下拉框中显示所有已经连接的服务器信息，从中选择一个服务器“127.0.0.1:5678”。

报警分组是用树结构表示的，第一次进入时，如果有已经连接的服务器，则显示这个服务器下的分组信息。系统默认所有的报警点都放在“未分组”这个组下面。

单击选择根节点“\”或者“未分组”，再单击“确定”按钮，则开始下载。

如图，系统中有3个报警点被下载到excel中，他们都默认位于默认组下。

注意：

如果下载之前勾选了“只下载当前分组”，那么单击选中一个报警分组，则只会下载这个分组下面的报警点。

·报警分组上传

上传之前先要在Excel中配置好数据，然后选中“加载项”-“ 实时数据库”-“报警分组上传”，弹出报警分组上传对话框进行上传。

注意：在上传时，只以“报警点ID”为唯一的选点条件，报警点名称和监测点不作为上传点的要求。

用户可以修改分组路径，将所在行的报警点移动到新的分组路径下。如果新的分组路径不存在，则系统先创建分组再将报警点移动到这个组下。

如图操作，修改分组路径，用来新建abc三个分组，并将三个点分别移动到对应的组下。

弹出上传对话框，单击确定开始上传。

上传完毕如下图：

注意：不能在“未分组”下新建报警组。

这时再从服务器127.0.0.1:5678上下载所有的报警点，如下图：

可见报警组已经被新建，而且点也被移动。

单击选中报警组“a”，然后勾选只下载当前分组，然后下载。

可见只下载了选中的a组。


数字状态集管理

Navigation: 功能明细 > 数据展示 > 电子表格 > Excel中实时数据库插件的功能 >

数字状态集管理

 Return to chapter overview

·概述

本模块完成在Excel中配置数字状态集的功能。

·报警分组下载

在Excel中，“加载项”-“ 实时数据库”-“数字状态集管理”，弹出报警分组下载对话框。


错误码查询

Navigation: 功能明细 > 数据展示 > 电子表格 > Excel中实时数据库插件的功能 >

错误码查询

 Return to chapter overview

《错误码查询》主要介绍在iHyperDB插件中对错误码的查询。操作步骤如下：

iHyperDB菜单中选择“错误码查询...”

弹出“错误码查询”对话框

输入需要查询的错误码，点击查询，在错误信息中显示错误码信息

点击取消，关闭对话框。

输入规定：

只能输入数字和空格，出现其他符号会报错。错误码前后可以有空格，如“ 110002 ”是支持的。但错误码中间不能有空格，如“11 002”是不支持的。 输入框最多能输入9位数字。 错误码范围：110002-123102 和表示操作成功的0。如果不在此范围内，则提示错误信息。 输入框不能为空，否则提示错误信息。


Excel说明

Navigation: 功能明细 > 数据展示 > 电子表格 > Excel中实时数据库插件的功能 >

Excel说明

 Return to chapter overview

说明Excel表格中各个属性项与实时数据库中各Tag点实际属性值的对应关系:

序号 | Excel属性项 | 属性项与Tag点实际属性值的对应关系
1. | 选择 | x 代表选中
2. | 归档状态 | 0代表不归档，1代表归档
3. | 统计类型 | 0表示最大值；1 表示最小值； 2表示求和；3表示最新值； 4表示可信度； 5表示算术平均值； 6表示时间加权平均值；7表示积分；8表示值变化； 9表示区间变化,从<=到>=；10表示区间变化,从>=到<=；11表示差值统计； 12表示值在区间；13表示值不在区间；14表示极差；15表示标准差； 16表示大于某个值的时间；17表示大于等于某个值的时间； 18表示等于某个值的时间；19表示不等于某个值的时间；20表示小于某个值的时间；21表示小于等于某个值的时间；22表示在某个值区间的时间； 23表示不在某个值区间的时间；23表示统计类型值的最大值, 做校验用
4. | 统计模式 | 统计方式与时间模式：0表示定周期-等间隔，1表示定周期-每天时段，2表示定周期-每月时段，3表示时间追溯-等间隔、4表示持续
5 | 弃坏点模式 | 暂时无
6 | 计数参数1 | 从<=到>=中，<=的值；或者从>=到<=中，>=的值
7 | 计数参数2 | 从<=到>=中，>=的值；或者从>=到<=中，<=的值
8 | 采样方式 | 0表示原始值，1表示线性插值，2表示前向插值
9 | 转换类型 | 0表示统计值放大，1代表统计值缩小
10 | 转换参数 | 放大缩小的比例
11 | 弃过滤失败记录 | 弃过滤失败采样点，0表示是，1表示否，
12 | OPC发布记录 | 0代表不发布，1代表发布


Excel自定义函数

Navigation: 功能明细 > 数据展示 > 电子表格 >

Excel自定义函数

 Return to chapter overview

实时数据库的Excel插件中，包含两个加载宏，一个是xla菜单项，一个是ExcelXLL.xll，实时数据库安装程序默认会安装并注册这两个加载宏。

Excel自定义函数目前有三种使用方式：菜单界面、图形用户界面以及Excel函数框输入直接使用。

Excel函数框输入支持所有自定义函数，菜单界面和图形用户界面分别支持部分自定义函数。

菜单界面主要支持以下自定义函数：

§ hd_SnapShot ：获取实时记录

§ hd_CompValRange ：时间区间模式获取历史原始记录

§ hd_CompValNum ： 记录条数模式获取历史原始记录

§ hd_IntValSpaced ： 等间隔模式获取历史插值记录

§ hd_IntValTimed ： 时间点模式获取历史插值记录

§ hd_GetVal ： 获取某个tag点在某个时间点的记录，使用前向插值算法

§ hd_Static：获取多种类型历史记录统计数据

§ hd_StaticCount：获取统计计数

§ hd_StaticTime：获取统计计时

选中一个函数，点击“确定”，即可进入函数参数输入窗口，输入对应的参数即可获取到对应的实时数据库数据。

示例如下:

·Excel自定义函数可以通过Excel插件菜单界面输入参数后生成，使用中的注意点

(1) Excel对于自定义函数的常用快捷键有：

a. ctrl+alt+F9，重新计算当前sheet中的所有函数

b. ctrl+shift+enter，在标题栏中输入函数后，可按此组合键完成函数的计算

c. ctrl+a， 选中函数输出结果中的某单元格后，按此键可以全选中数组公式中包含的所有的单元格

(2) 函数参数支持Excel单元格引用录入，不过，请注意，需要在引用地址前添加一个空格，以示区分

(3) 只支持普通点,统计点和计算点的数据记录获取

(4) 函数输出结果，若为!Value，代表输出值未正常获取，若为!Name，是因为xll插件未加载成功

(5) 函数参数中mode输出格式参数的说明：

ü hd_CompValNum

1 向前查询，不显示数据质量，时间戳在左

2 向前查询，不显示数据质量，时间戳在上

3 向前查询，显示数据质量，时间戳在左

4 向前查询，显示数据质量，时间戳在上

5 向后查询，不显示数据质量，时间戳在左

6 向后查询，不显示数据质量，时间戳在上

7 向后查询，显示数据质量，时间戳在左

8 向后查询，显示数据质量，时间戳在上

ü hd_CompValRange

2 不显示数据质量， 时间戳在左

3 不显示数据质量，时间戳在上

5 显示数据质量，时间戳在左

6 显示数据质量，时间戳在上

ühd_GetAverValInterRange

1 不显示数据质量， 时间戳在左

2 不显示数据质量，时间戳在上

3 显示数据质量，时间戳在左

4 显示数据质量，时间戳在上

5不显示数据质量，不显示时间戳

ühd_IntValTimed

1 不显示数据质量， 时间戳在左

2 不显示数据质量，时间戳在上

3 显示数据质量，时间戳在左

4 显示数据质量，时间戳在上

ühd_SnapShot

1 不显示数据质量，不显示时间戳

2 不显示数据质量，时间戳在左

3 不显示数据质量，时间戳在上

4 显示数据质量，不显示时间戳

5 显示数据质量，时间戳在左

6 显示数据质量，时间戳在上

ühd_Static

ühd_StaticCount

ühd_StaticTime

0 不显示时间戳

1 时间戳在左

2 时间戳在上

(6) 输出结果为多个单元格的建议使用界面输入后生成函数。

(7) 统计函数参数中的统计类型可参考菜单"历史记录统计"配置,不建议手工修改。参数等参考Excel说明和E xcel客户端统计。 StaticType,StaticCountType,StaticTimeType指统计类型；SampleType 指的是采样方式；Sample指的是统计模式；

ValueBefore、ValueBehind为计数类型的区间左右值；

ValueTime1、ValueTime2为计时类型的区间左右值。

·函数功能及示例

注:相对时间戳格式Pi和iHD不一致,目前性能方程式TimeEQ等6个函数支持Pi的相对时间戳格式hd_SampDat,hd_TimeFilter,hd_TimeFilterVal两种格式都兼容,其余函数仅支持iHD的时间戳格式；iHD的时间戳格式可参考时间戳格式

函数名

函数功能

备注

示例

hd_CurrVal()

返回当前值

返回值分三种情况：

1.所有记录时间戳比当前时间更早，返回最近时间戳

2.当前时间在所有记录时间戳之中，返回插值时间记录

3.所有记录时间戳比当前时间更晚，返回没有数据

语法：

hd_CurrVal(TagName, OutCode, RootPath)

TagName：hd点名

OutCode：返回值排列模式

RootPath：为保留用户习惯,和PI接口一致,hd接口可不填

示例：

hd_CurrVal("test",1,"holden")

返回查询holden服务器上let439点当前值。

OutCode:此参数通过一个输出代码确定函数返回的附加数据以及输出单元格的方向。

当 OutCode 参数设为 0 时，函数按列方向返回值，且无附加数据。要计算 OutCode 参数，

请使用以下公式：

1st | 显示时间戳
2nd | 按行显示而不是按列显示
3rd | 显示质量是good记录百分比
4th | 隐藏条数
5th | 显示扩展状态
6th | 显示标注
7th | 显示开始时间
8th | 显示结束时间
9th | 显示最大/最小时间

按列方向输出值

=hd_CurrVal(''test",0,"")

按列方向输出时间戳和值

=hd_CurrVal(''test",1,"")

按行方向输出

=hd_CurrVal(''test",3,"")

hd_ArcVal()

返回需要查询时间戳的历史值

语法：

hd_ArcVal(TagName, TimeStamp, OutCode, RootPath, Mode)

TagName：hd点名

TimeStamp：查询时间戳

OutCode：返回值排列模式

RootPath：为保留用户习惯,和PI接口一致,hd接口可不填

Mode：取值模式

previous: 返回与指定时间戳完全匹配或在其之前的值

previous only: 返回在指定时间戳之前的值

interpolated: 返回指定时间的插值

next: 返回与指定时间戳完全匹配或在其之后的值

next only: 返回在指定时间戳之后的值

exact time: 返回一个与时间戳完全匹配的值，或返回 错误码（如果该时间戳上不存在任何值

示例：

hd_ArcVal("cdep158","11-dec-92 19:20",0, "","interpolated")

返回casaba服务器上cdep158点在92年12月11日19点20分历史插值。

bit 1

bit 2

按列方向输出值

=hd_ArcVal(''test",''2024/1/25 12:00:00'',"0","","previous")

hd_ExpVal()

返回性能方程式对时间戳历史值计算之后的值

语法：

hd_ExpVal(Expression, TimeStamp, OutCode, RootPath)

Expression：性能方程式表达式

TimeStamp：查询时间戳

OutCode：返回值排列模式

RootPath：为保留用户习惯,和PI接口一致,hd接口可不填

示例：

hd_ExpVal("sqr('sinusoid')","y",0,"")

返回thevax服务器上昨天0点sinusoid点的平方根

目前只支持两个tag之间的简单计算

hd_ExpVal("'tag_int16_3' + 'tag_int16_4'", "2024-02-22 13:15:00.27", 1)

hd_TagAtt()

返回点的属性

语法：

hd_TagAtt(TagName, Property, RootPath)

TagName：hd点名

Property：点的属性

RootPath：为保留用户习惯,和PI接口一致,hd接口可不填

示例：

hd_TagAtt(d1,"uom","")

从默认服务器查询d1单元格hd_点的单位属性

支持hd的通用属性

{"tagid", },

{"descriptor", },

{"tagname", },

{"changedate", },

{"compdev", },

{"compmaxtime", },

{"comptype", },

{"creationdate", },

{"creator", },

{"recaccess", },

{"recnormalgroup", },

{"recownergroup", },

{"digitalset", },

{"engunits", },

{"excmaxtime", },

{"tagtype", },

{"tagaccess", },

{"tagnormalgroup", },

{"tagownergroup", },

{"scan", },

{"span", },

{"minvalue", },

{"tagclass", },

{"tagavaliable", },

{"imvstring", },

{"extstring1", },

{"extstring2"},

=hd_TagAtt("test","tagid","")

hd_CompDat()

返回某个时间段的历史记录

语法：

hd_CompDat(TagName, STime, ETime, OutCode, RootPath, Mode)

TagName：hd点名

STime：开始时间点

ETime：结束时间点

OutCode：返回值排列模式

RootPath：为保留用户习惯,和PI接口一致,hd接口可不填

Mode：边界值处理模式（inside，outside，interpolated，auto）

示例：

hd_CompDat("sinusoid","1:00:00","3:00:00",1,"","inside")

返回sinusoid点从今天1点到3点之间inside模式的历史记录

返回多个时间点的值，目前只支持使用单元格选中多个时间

=hd_CompDat(" $C$23"," $E$25:$E$37","", "interpolated")

hd_NCompDat()

返回从某个时间点开始一定条数的历史记录

语法：

hd_NCompDat(TagName, STime, NumVals, OutCode, RootPath, Mode)

TagName：hd点名

STime：开始时间点

NumVals：返回多少条记录

OutCode：返回值排列模式

RootPath：为保留用户习惯,和PI接口一致,hd接口可不填

Mode：边界值处理模式（inside，outside，interpolated，auto）

示例：

hd_NCompDat("sinusoid","1:00:00",10,1,"","inside")

返回sinusoid点从今天1点开始inside的10条历史记录

hd_SampDat()

返回一段时间平分的插值

语法：

hd_SampDat(TagName, STime, ETime, Interval, OutCode, RootPath)

TagName：hd点名

STime：开始时间点

ETime：结束时间点

Interval：插值间隔

OutCode：返回值排列模式

RootPath：为保留用户习惯,和PI接口一致,hd接口可不填

示例：

hd_SampDat("sinusoid","y","t","3h",1,"")

返回sinusoid点昨天0点到今天0点每三小时的插值

hd_TimeDat()

返回指定时间点的原始或插值记录

语法：

hd_TimeDat(TagName, TimeStamps, RootPath, Mode)

TagName：hd点名

TimeStamps：时间点

RootPath：为保留用户习惯,和PI接口一致,hd接口可不填

Mode：取值方法（interpolated，exact time）

示例：

hd_TimeDat("sinusoid",b1:b12,"","interpolated")

返回sinusoid点b1到b12单元格时间点的插值

hd_AdvCalcVal()

返回单个值，通过计算一段时间的历史值得出

语法：

hd_AdvCalcVal(TagName, STime, ETime, Mode, CalcBasis, MinPctGood, CFactor, OutCode, RootPath)

TagName：hd点名

STime：开始时间点

ETime：结束时间点

Mode：计算方式（total, minimum, maximum, stdev, range, count, average (time-weighted), average (event-weighted)）

CalcBasis：计算基准（time-weighted，event-weighted）

MinPctGood：最小好的数据的百分比

CFactor：返回值的系数，如果是1说明不需要考虑系数。

OutCode：返回值排列模式

RootPath：为保留用户习惯,和PI接口一致,hd接口可不填

示例：

hd_AdvCalcVal("sinusoid","y","t","total","time-weighted",50,1,4,"")

返回sinusoid点从昨天0点到今天0点值的总和，如果查询时间段内好的值大于50%会有返回值，需要乘系数，方法同时返回好的值的百分比在返回值左侧。

当 OutCode 参数设为 0 时，函数按列方向返回值，且无附加数据。要计算 OutCode 参数，

请使用以下公式：

OutCode支持：

2nd 按行或者按列显示

3rd 显示质量是good记录百分比

示例：

=hd_AdvCalcVal("hdsys_cpu_0","2024-02-19 9:02:00","2024-02-20 9:02:00","average", "event-weighted", 80, 1, 3)

hd_AdvCalcDat()

返回一段时间经过计算的等分值

语法：

hd_AdvCalcDat(TagName, STime, ETime, Interval, Mode, CalcBasis, MinPctGood, CFactor, OutCode, RootPath)

TagName：hd点名

STime：开始时间点

ETime：结束时间点

Interval：间隔

Mode：计算方式（total, minimum, maximum, stdev, range, count, average (time-weighted), average (event-weighted)）

CalcBasis：计算基准（time-weighted，event-weighted）

MinPctGood：最小好的数据的百分比

CFactor：返回值的系数，如果是1说明不需要考虑系数。

OutCode：返回值排列模式

RootPath：为保留用户习惯,和PI接口一致,hd接口可不填

示例：

hd_AdvCalcDat("sinusoid","y","t","3h","total","time-weighted",50, 1,4,"")

返回sinusoid点昨天到今天每三个小时值的总和，如果查询时间段内好的值大于50%会有返回值，需要乘系数，方法同时返回好的值的百分比在返回值左侧。

当 OutCode 参数设为 0 时，函数按列方向返回值，且无附加数据。要计算 OutCode 参数，

请使用以下公式：

OutCode支持：

2nd 按行或者按列显示

3rd 显示质量是good记录百分比

目前只支持在选中范围的单元格中显示，不支持自动填充到没有选中单元格

示例：

=hd_AdvCalcDat("hdsys_cpu_0","2024-03-19 9:02:00","2024-03-19 16:02:00", "30m", "average", "event-weighted", 80, 1, 3)

hd_TimeFilterVal()

返回一段时间内的符合性能表达式条件的时间总和

语法：

hd_TimeFilterVal(Expression, STime, ETime, TimeUnit, OutCode, RootPath)

Expression：性能表达式

STime：开始时间点

ETime：结束时间点

TimeUnit：计算的时间单位（seconds， minutes，hours，days）

OutCode：返回值排列模式

RootPath：为保留用户习惯,和PI接口一致,hd接口可不填

示例：

hd_TimeFilterVal($A$1,"y","t","seconds",0,"thevax")

返回符合A1单元格表达式的从昨天到今天的秒数

表达式格式:

'tag'>1,

'tag'==0,

'tag'<>2,

'tag'<=3

=hd_TimeFilterVal("'test'>=10","*-8h","*","seconds",1,"")

hd_TimeFilter()

返回一段时间内平分后的符合性能表达式条件的时间总和

语法：

hd_TimeFilter(Expression, STime, ETime, Interval, TimeUnit, OutCode, RootPath)

Expression：性能表达式

STime：开始时间点

ETime：结束时间点

Interval：等分间隔

TimeUnit：计算的时间单位（seconds， minutes，hours，days）

OutCode：返回值排列模式

RootPath：为保留用户习惯,和PI接口一致,hd接口可不填

示例：

hd_TimeFilter($A$1,"y","t","1h","seconds",65,"thevax")

返回符合A1单元格表达式的从昨天到今天每一个小时等分时间段的秒数，在计算出的秒数左边会显示每个时间段开始的时间

表达式格式:

'tag'>1,

'tag'==0,

'tag'<>2,

'tag'<=3

bit 1,

bit 2,

bit 3,

bit 7,

bit 8

=hd_TimeFilter("'test'>1","12-jan-24 12:00:00","12-jan-24 12:30:00","-10m","minutes",197,"")

hd_Tag2Id()

返回hd_标记点名

语法：

hd_Tag2Id(pointid, hd_Server)

pointid：hd标记点ID

hd_Server：目标hd_ Server

示例：

hd_Tag2Id("test","")

返回服务器点名是test的id

Private Sub 获取tagId_Click()

Worksheets("Sheet1").Cells(54, 3).Formula = "=hd_Tag2Id(""" & Worksheets("Sheet1").Cells(54, 2).Value & """, """")"

End Sub

hd_ID2Tag()

返回hd_标记点名

语法：

hd_ID2Tag(pointid, hd_Server)

pointid：hd标记点ID

hd_Server：目标hd_ Server

示例：

hd_ID2Tag("123","thevax")

返回thevax服务器id是123的点名

hd_AttributeMaskToTag ()

返回一个或多个符合属性的标记点名

语法：

hd_AttributeMaskToTag(tagname, descriptor, pointsource, pointtype, pointclass, engunits, outcode, hd_Server)

tagname：标记点名

descriptor：标记点描述

pointsource：标记点来源

pointtype：标记点类型掩码

pointclass：标记点类掩码

engunits：工程单位掩码

outcode：返回值排列模式

hd_Server：目标hd_ Server

示例：

hd_AttributeMaskToTag("sin*","*","*","*","*","*",0,"thevax")

返回thevax服务器sin开头点名

当 OutCode 参数设为 0 时，函数按列方向返回值，且无附加数据。要计算 OutCode 参数，

请使用以下公式：

OutCode支持：

2nd 按行或者按列显示

3rd 显示质量是good记录百分比

目前只支持在选中范围的单元格中显示，不支持自动填充到没有选中单元格

示例

=hd_AttributeMaskToTag("tag_int16_*",,,"int16","HD3M_TAG_CLASS_BASIC",,0)

hd_PutVal()

向iHD存入一个标记点数据

语法：

hd_PutVal(tagname, value, timestamp,"")

tagname：点名

value：值

timestamp：时间戳

RootPath：为保留用户习惯,和PI接口一致,hd接口可不填

示例：

=hd_PutVal("Da_00002.ai_ylf","0.1","2024-09-03 7:01:03","")

hd_GetVal()

返回标记点时间戳时的值

语法：

hd_GetVal(tagname, timestamp)

tagname：点名

timestamp：时间戳

示例

=hd_GetVal("hdsys_mem_0","2024/9/4 10:00:00")

TimeEq（）

统计tag点在一段时间内等于某个值的秒数

语法：

TimeEq(TagName, StartTime, EndTime,szValue)

TagName：hd点名

StartTime:起始时间

EndTime:结束时间

Value：字符串类型值

可直接在单元格中使用,也可在vba脚本中使用

Private Sub CommandButton1_Click()

Worksheets("Sheet1").Cells(46, 3).Formula = "=TimeEq(""test"", ""-3mo"",""1"")"

End Sub

TimeGE（）

统计tag点在一段时间内大于等于某个值的秒数

语法：

TimeGE(TagName, StartTime, EndTime,szValue)

TagName：hd点名

StartTime:起始时间

EndTime:结束时间

Value：字符串类型值

可直接在单元格中使用,也可在vba脚本中使用

TimeLE（）

统计tag点在一段时间内小于等于某个值的秒数

语法：

TimeLE(TagName, StartTime, EndTime,szValue)

TagName：hd点名

StartTime:起始时间

EndTime:结束时间

Value：字符串类型值

可直接在单元格中使用,也可在vba脚本中使用

TimeNE()

统计tag点在一段时间内不等于某个值的秒数

语法：

TimeNE(TagName, StartTime, EndTime,szValue)

TagName：hd点名

StartTime:起始时间

EndTime:结束时间

Value：字符串类型值

可直接在单元格中使用,也可在vba脚本中使用

TimeGT()

统计tag点在一段时间内大于某个值的秒数

语法：

TimeGT(TagName, StartTime, EndTime,szValue)

TagName：hd点名

StartTime:起始时间

EndTime:结束时间

Value：字符串类型值

可直接在单元格中使用,也可在vba脚本中使用

TimeLT()

统计tag点在一段时间内小于于某个值的秒数

语法：

TimeLT(TagName, StartTime, EndTime,szValue)

TagName：hd点名

StartTime:起始时间

EndTime:结束时间

Value：字符串类型值

可直接在单元格中使用,也可在vba脚本中使用

hd_AdvCalcFilVal

通过计算单个Tag一段时间的历史值并过滤后返回单个值

语法：

szTagName 点名

szStartTime 开始时间

szEndTime 结束时间

szFilterExpression 过滤表达式

szMode 统计计算模式

szCalcBasis 计算基准

szSampleMode 采样模式

szSampleFrequency 采样频率

nMinPctGood 信任度

CFactor 系数

nOutcode 返回格式

统计计算模式：total, minimum, maximum, stdev, range, count, average (time-weighted), average (event-weighted)

目前count统计计算有问题不能使用,有时过滤表达式计算结果有问题

计算基准：

time-weighted 基于时间

event-weighted 基于条数

示例：

=hd_AdvCalcFilVal("hdsys_cpu_0","2024-04-30 9:02:00","2024-04-30 9:12:00","'hdsys_mem_0' > 48","average","time-weighted","compressed","",80,1,1)

统计计算2024-04-30 9:02:00到2024-04-30 9:12:00之间hdsys_cpu_0平均值，同时需要过滤hdsys_mem_0需要满足大于48才参与计算。

hd_AdvCalcExpVal

通过计算表达式一段时间的历史值返回单个值

语法：

szExpression 表达式

szStartTime 开始时间

szEndTime 结束时间

szMode 统计计算模式

szCalcBasis 计算基准

szSampleMode 采样模式

szSampleFrequency 采样频率

nMinPctGood 信任度

CFactor 系数

nOutcode 返回格式

表达式目前只支持加减乘除操作

统计计算模式：

total, minimum, maximum, stdev, range, count, average (time-weighted), average (event-weighted)

目前count统计计算有问题不能使用

计算基准：

time-weighted 基于时间

event-weighted 基于条数

示例：

=hd_AdvCalcExpVal("'hdsys_cpu_0' + 'hdsys_mem_0'","2024-04-30 9:02:00","2024-04-30 9:12:00", "average","time-weighted","compressed","",80,1,1)

统计计算2024-04-30 9:02:00到2024-04-30 9:12:00之间hdsys_cpu_0与hdsys_mem_0之和的平均值。

hd_AdvCalcExpFilVal

通过计算表达式一段时间的历史值并过滤后返回单个值

语法：

szExpression 表达式

szStartTime 开始时间

szEndTime 结束时间

szFilterExpression 过滤表达式

szMode 统计计算模式

szCalcBasis 计算基准

szSampleMode 采样模式

szSampleFrequency 采样频率

nMinPctGood 信任度

CFactor 系数

nOutcode 返回格式

表达式目前只支持加减乘除操作

统计计算模式：

total, minimum, maximum, stdev, range, count, average (time-weighted), average (event-weighted)

目前count统计计算有问题不能使用,有时过滤表达式计算结果有问题

计算基准：

time-weighted 基于时间

event-weighted 基于条数

示例：

=hd_AdvCalcExpFilVal("'hdsys_cpu_0' + 'hdsys_mem_0'","2024-04-30 9:02:00","2024-04-30 9:12:00","'hdsys_mem_0' > 49","maximum","time-weighted","compressed","30s",80,1,1)

统计计算2024-04-30 9:02:00到2024-04-30 9:12:00之间hdsys_cpu_0与hdsys_mem_0之和的平均值，同时hdsys_mem_0需要满足大于48的条件。

hd_AdvCalcFilDat

通过计算单个Tag多段时间的历史值并过滤后返回多个值

语法：

szTagName 点名

szStartTime 开始时间

szEndTime 结束时间

szInterval 计算间隔

szFilterExpression 过滤表达式

szMode 统计计算模式

szCalcBasis 计算基准

szSampleMode 采样模式

szSampleFrequency 采样频率

nMinPctGood 信任度

CFactor 系数

nOutcode 返回格式

统计计算模式：

total, minimum, maximum, stdev, range, count, average (time-weighted), average (event-weighted)

目前count统计计算有问题不能使用,有时过滤表达式计算结果有问题

计算基准：

time-weighted 基于时间

event-weighted 基于条数

示例：

=hd_AdvCalcFilDat("hdsys_mem_0","2024-04-30 9:02:00","2024-04-30 11:32:00", "1m","'hdsys_mem_0' > 49","average","event-weighted","compressed","30s",80,1,3)

统计计算2024-04-30 9:02:00到2024-04-30 11:32:00之间以1分钟进行分割，对每个时间段hdsys_cpu_0平均值进行计算，同时hdsys_mem_0需要大于49。

hd_AdvCalcExpDat

通过计算表达式多段时间的历史值返回多个个值

语法：

szExpression 表达式

szStartTime 开始时间

szEndTime 结束时间

szInterval 计算间隔

szMode 统计计算模式

szCalcBasis 计算基准

szSampleMode 采样模式

szSampleFrequency 采样频率

nMinPctGood 信任度

CFactor 系数

nOutcode 返回格式

表达式目前只支持加减乘除操作

统计计算模式：

total, minimum, maximum, stdev, range, count, average (time-weighted), average (event-weighted)

目前count统计计算有问题不能使用

计算基准：

time-weighted 基于时间

event-weighted 基于条数

示例：

=hd_AdvCalcExpDat("'hdsys_cpu_0' + 'hdsys_mem_0'","2024-04-30 9:02:00","2024-04-30 9:12:00", "average","time-weighted","compressed","",80,1,1)

统计计算2024-04-30 9:02:00到2024-04-30 09:12:00之间'hdsys_cpu_0' + 'hdsys_mem_0'的原始值平均值。

hd_AdvCalcExpFilDat

通过计算表达式多段时间的历史值并过滤后返回多个值

语法：

szExpression 表达式

szStartTime 开始时间

szEndTime 结束时间

szInterval 计算间隔

szFilterExpression 过滤表达式

szMode 统计计算模式

szCalcBasis 计算基准

szSampleMode 采样模式

szSampleFrequency 采样频率

nMinPctGood 信任度

CFactor 系数

nOutcode 返回格式

表达式目前只支持加减乘除操作

统计计算模式：

total, minimum, maximum, stdev, range, count, average (time-weighted), average (event-weighted)

目前count统计计算有问题不能使用,有时过滤表达式计算结果有问题

计算基准：

time-weighted 基于时间

event-weighted 基于条数

示例：

=hd_AdvCalcExpFilDat("'hdsys_cpu_0' + 'hdsys_mem_0'","2024-04-30 9:02:00","2024-04-30 10:02:00", "1m","'hdsys_mem_0' > 49","average","time-weighted","interpolated","30s",80,1,3)

统计计算2024-04-30 9:02:00到2024-04-30 10:02:00之间以1分钟进行分割，对每个时间段'hdsys_cpu_0' + 'hdsys_mem_0'插值的平均值进行计算，同时hdsys_mem_0需要满足大于49。

hd_ExpDat

计算表达式一段时间插值的计算结果

语法：

szStr 表达式

szStartTime 开始时间

szEndTime 结束时间

szIntVal 时间间隔

nOutMode 返回格式

示例：

=hd_ExpDat("'hdsys_netin_0'>3","2024-05-06 00:00:00.000","2024-05-07 00:00:00.000","1h",1)

从昨天0点到今天0点每间隔一个小时，当hdsys_netin_0的值大于2时，返回值，否则返回"not match"

hd_TimeExpDat

计算在一个时间点表达式的计算结果

语法：

szStr 表达式

szTimestamp 时间点

示例：

=hd_TimeExpDat("'hdsys_netin_0'>2","2024-05-06 15:08:45.950")

在"2024-05-06 15:08:45.950"时间点，当hdsys_netin_0的值大于2时，返回值，否则返回"not match"

hd_CompFilDat

返回某个时间段符合过滤条件的历史记录

语法：

szTagName 点名

szStartTime 开始时间

szEndTime 结束时间

szFilterExpression 过滤表达式

nFilterCode 是否标记过滤的值

nOutCode 返回值排列模式

szRootPath 数据所在服务器名

szMode 边界值处理模式

边界值处理模式详情:

auto / interpolated：获取开始时间和结束时间点的两个插值；

inside：获取开始时间到结束时间内的所有历史值(左开右闭)；

outside：获取开始时间到结束时间内的所有历史值，并分别获取边界值左边和右边时间最近的一个历史值。

过滤表达式：

比如'test1>10'，意思是先从开始时间到结束时间获取到test1点数值大于10的所有时间区间，再返回这些时间区间内szTagName点的所有历史值。

示例：

=hd_CompFilDat("hdsys_cpu_0","2024-05-06 15:00:00","2024-05-06 15:30:00","",1,3,"","inside")

在"2024-05-06 15:00:00"到"2024-05-06 15:30:00"时间段内，hdsys_cpu_0所有的历史值

hd_NCompFilDat

返回从某个时间点开始一定条数的历史记录

语法：

szTagName 点名

szStartTime 开始时间

nNumVals 查询条数

szFilterExpression 过滤表达式

nFilterCode 是否标记过滤的值

nOutCode 返回值排列模式

szRootPath 数据所在服务器名

szMode 边界值处理模式

边界值处理模式详情:

inside：获取开始时间往后的n条历史值(闭区间)；

outside：获取开始时间之前的一条历史值，再获取开始时间往后的n-1条历史值(闭区间)。

过滤表达式：

比如'test1>10'，意思是先从开始时间到结束时间获取到test1点数值大于10的所有时间区间，再返回这些时间区间内szTagName点的n条历史值。

示例：

=hd_NCompFilDat("hdsys_cpu_0","2024-05-08 13:00:00",10,"",1,1,"","inside")

从"2024-05-08 13:00:00"开始往后，hdsys_cpu_0的10条历史值

hd_SampFilDat

返回经过过滤的一段时间的插值

语法：

szTagName 点名

szStartTime 开始时间

szEndTime 查询条数

szInterVal 插值间隔

szFilterExpression 过滤表达式

nFilterCode 是否标记过滤的值

nOutCode 返回值排列模式

szRootPath 数据所在服务器名

示例：

=hd_SampFilDat("sinusoid","y","t","3h","",1,1,"")

sinusoid点昨天0点到今天0点每三小时的插值


Excel客户端统计

Navigation: 功能明细 > 数据展示 > 电子表格 >

Excel客户端统计

 Return to chapter overview

历史记录统计

通过本模块，可以按照用户指定的统计方式，对Tag点值进行统计计算。并且，可以通过刷新操作，获取实时的统计结果。

一、操作步骤

1.Excel菜单中点击 历史记录统计 选项：

2.弹出的客户端统计界面如下：

3.选择输出单元格，时间戳输出格式，监测点，最小信任度，统计类型，统计时间，采集方式，采样周期，记录时间戳，过滤表达式，记录值转换系数等。

4.点击确定，记录值输出到excel指定的单元格中：

1.输出格式：包含三种时间戳在上，时间戳在左，和无时间戳；

2.统计类型的选择，统计时间的配置等和统计点的配置相同。

二、 普通和高级模式

1.普通模式：配置好所有的统计条件之后，系统将统计条件转换为Excel自定义函数的参数，可以按ctrl+alt+F9刷新统计结果。

2.高级模式：不支持Excel自定义函数，不可刷新结果。


Excel拖选模式

Navigation: 功能明细 > 数据展示 > 电子表格 >

Excel拖选模式

 Return to chapter overview

“Excel拖选模式”是Excel中特有的一种操作方法，主要功能是通过在Excel中拖拽选择某些单元格，从而把单元格内容快速导入到所需要的应用中。这种操作方法充分利用了Excel中的数据，可以减少繁重的手动输入。

通常由某功能窗口中的“表格图标按钮”启动该功能，并自动关闭当前功能窗口，激活Excel表格，打开一个专门的输入小窗口。

从Excel中拖拽选中一些单元格后，它们的位置信息会显示在输入小窗口中，单击确定后返回原功能窗口，并把位置信息导出到功能窗口对应的位置中去。

v如果在当前sheet中选择，位置信息显示如“=$B$1:$D$1”，表示从B1单元格到D1单元格

v不支持跨sheet选择。

“Excel拖选模式”功能在以下页面使用：

·查询历史存储记录（时间区间模式）

·查询历史存储记录（记录条数模式）

·查询历史插值记录（时间点模式）

·查询历史插值记录（等间隔模式）


Excel拖动填充

Navigation: 功能明细 > 数据展示 > 电子表格 >

Excel拖动填充

 Return to chapter overview

“Excel拖拽填充”是Excel中特有的一种操作方法，主要功能是通过在Excel中拖拽选择某些单元格，帮助我们快速填充数据、序列或公式，这种操作方法充分利用了Excel中的数据，可以减少繁重的手动输入。

v如果单元格中是公式，拖动填充柄会自动调整公式中的单元格引用（相对引用）。

v如果希望公式中的某些引用不变，可以使用 $ 符号锁定行或列（绝对引用）。

使用步骤如下：

1.连接服务器：

2.配置查询条件；例如查询 点hdsys_cpu_0，在7点-11点每小时第三分钟的值

点击“时间点查询”- 选择tag点、时间戳、输出单元格等查询信息后，点击“确定”按钮；

3.拖拽填充；

· 相对引用填充：

点击查询结果，可以看到公式和参与计算的单元格信息，点击F6拖动到F10，即可快速查询到所需时间点的值；

· 绝对引用填充：

如下图1：公式中第一个参数是F5，若直接拖拽，则下方单元格第一个参数依次会变成F5-F6-F7-F8-F9，计算后由于tag名不合法则提示“不合法的Tag名”，如图二所示；

故需修改公式，固定公式中第一个参数项，即在行列之前加$符号，按回车进行计算后，拖动单元格即可发现，F5列被固定，可查询出正确结果；


时间戳格式

Navigation: 功能明细 > 数据展示 > 电子表格 >

时间戳格式

 Return to chapter overview

时间戳格式：

§绝对时间格式2010-04-13 10:59:36.123 (年-月-日 时：分：秒.毫秒)或2010-04-13 10:59:36 (年-月-日 时:分:秒)

§相对时间格式： 只支持d，h，m，s

§最小时间：1970-01-01 08:00:01.000

§最大时间：2038-01-19 11:14:06.000

§关键字now表示当前时间， now-1d表示当前时间的前一天，等等, 精确到秒

§时间换算以秒为单位， 时间数值不超过int32上限

§参考时间缩写:参考时间缩写代表一个相对于当前时间的时间。

输入 | 含义
* | 当前时间（现在）
3-1 或 3/1 | 当年的 3 月 1 日 00:00:00（午夜）
2011 | 2011 年当月当天的 00:00:00（午夜）
25 | 当月的第 25 日 00:00:00（午夜）
t | 当日（今天）的 00:00:00（午夜）
y | 前一日（昨天）的 00:00:00（午夜）
tue | 最近一个星期二的 00:00:00（午夜）

§带时间偏移量的参考时间缩写:当参考时间缩写带有一个时间偏移量时，将会从该参考时间缩写中增加或减去指定时间。

输入 | 含义
*-1h | 一小时以前
t+8h | 今天 08:00:00（上午 8:00）
y-8h | 前天 16:00:00（下午 4:00）
mon+14.5h | 上周一 14:30:00（下午 2:30）
sat-1m | 上周五 23:59:00（晚上 11:59）

§时间偏移量:时间偏移量需要单独输入，可指定一个相对于暗示的参考时间的时间。暗示的引用时间可能为当前时钟时间或其他时间，具体取决于表达式的输入位置。

输入 | 含义
-1d | 当前时间的前一天
+6h | 当前时间的六个小时后

查询实时记录是指查询一个或多个Tag点实时的记录，同时将数据质量和时间戳等信息显示到Excel中。

主要内容包括：

· “查询实时记录”的使用

1. 从iHyperDB菜单中选择“实时记录...”

选择已经连接的服务器，Tag名，输出单元格，勾选是否显示数据质量以及输出格式对话框，

单击确定，在Excel中会显示出点Tag1的实时记录

·"查询实时记录"页面介绍

“查询实时记录”页面介绍，主要包括：

§服务器名：用于选择需要操作的服务器

点击服务器名下拉框，显示所有被添加的服务器

ü横线处表示无服务器，横线上方是已连接的服务器，横线下方是未连接的服务器

ü默认为前一次连接的服务器

ü如果列表中没有选择服务器，开始下载时会提示必须选择一个服务器

ü如果选择的服务器未连接，开始下载时自动连接服务器。连接成功执行后续操作，连接不成功报错。

§Tag名:指定需要查询实时记录的Tag

有三种方法：

1. 手动输入：在Tag名下方输入栏中输入一个Tag名，查询该Tag的实时记录。

ü不支持多个Tag的查询，不能包含“;”。

ü不允许以空格开头。

ü该项必填，不能为空白。

2. 从Excel中选择：点击输入栏右侧按钮，进入Excel拖选模式，选中Tag后确定返回，显示选中的单元格位置

ü所选的Tag名只能是一行或一列,不能为多行或多列，否则查询时报错

ü在一行或一列中，若某个单元格内容为空，则跳过后继续处理下面的单元格

ü若地址不连续，则只处理最靠近左上角的一个Tag行（或列）

üTag名引用的地址必须在当前sheet下，不能跨sheet引用

ü最多能选择65535个Tag名。

3. 用Tag查询功能选择Tag：点击最右边的按钮（"放大镜"）弹出 Tag查询 对话框，查询到需要的一个Tag后选中并按确定返回，显示Tag名称。

ü用此方法只能查询一个Tag的实时记录。

ü若在查询中选择多个Tag，只会查询第一个。

ü该项必填，不能为空白。

§输出单元格

输出单元格：点击输出单元格右方的按钮，进入Excel拖选模式，选中单元格后返回

1.不论选中区域多大，都以区域的左上角第一个单元格为准，然后向右向下输出信息

2.输出单元格引用地址必须在当前sheet下，不能跨sheet引用

3.支持手动输入，格式相同

4.输出单元格不能为空白

§输出格式

指定数据质量：在“显示数据质量”前方的复选框内画勾表示显示数据质量，反之不显示。

时间戳显示方式：选择“不显示时间戳”、“时间戳在上”或者“时间戳在左”。

输出：单击确定键，开始把实时记录值下载并显示到Excel中，同时查询实时记录窗口关闭

ü如果选择了“时间戳在左”也选择了“显示数据质量”，那么一行中依次显示为“时间戳”、“数据质量”“实时记录值”。

ü如果选择了“时间戳在上”也选择了“显示数据质量”，那么一列中依次为“时间戳”、“数据质量”、“实时记录值”。

ü如果没选显示数据质量，那么数据质量就不显示，只显示三种信息

ü按ctrl + alt + F9键，Excel可以刷新Tag点实时记录的显示

ü若不能查询到Tag对应的记录，则在Excel对应的记录单元格中显示提示信息“#VALUE!”

ü如果是手工输入或者用Tag查询方式进行查询，只显示一个Tag的记录。


Excel数据上传

Navigation: 功能明细 > 数据展示 > 电子表格 >

Excel数据上传

 Return to chapter overview

数据上传的格式如下图所示：

格式说明：

列A | 列B | 列C | 列D
Tag名 文本型 | 时间戳 文本型，格式见上图 | 数据质量 数值型 192=good 其他数值=bad | 数据值 数值型

选择高级菜单中的“数据上传”开始上传数据。

注意：

v上传数据请按照格式说明填写；

v上传的同批数据必须是同一个TAG的数据；

上传出错的行，会在尾部用红色标出错误原因。


wps表格的应用

Navigation: 功能明细 > 数据展示 > 电子表格 >

wps表格的应用

 Return to chapter overview

WPS表格加载项插件是基于office而衍化而来的,

支持版本：WPS Office 2016 简体中文专业增强版 （最新版 ）版本号：10.8.0.6501

由于wps的版本是32位的，所以ihd暂时只支持32位的客户端使用wps导入数据的功能。

*第一次安装wps后需要配置加载项.

如安装了Excel插件的机器,第一次启动wps会自动加载excel加载项，界面会弹出以下错误，如图所示：

提示框直接选择结束,配置wps的插件后再启动才能正常使用.

（1）加载项的配置，打开wps的开发工具>加载项，

（2）需要勾选iHyperDB_Wps 和 hdExcel Xll Add-In,点击确定后，重启下wps，配置生效。

如果没有显示2个插件，需浏览添加executable目录下面的iHyperDB_wps.xla和ExcelXLL.xll.

重新打开即可。 加载完成之后，点表的导入导出参照office excel的表格导入导出。兼容Excel插件函数功能。

注意：如果安装了wps后，可以连接上服务器，但是点击tag点下载等选项无法使用功能，可重新安装wps后重启机器再使用。


Excel权限批量操作

Navigation: 功能明细 > 数据展示 > 电子表格 >

Excel权限批量操作

 Return to chapter overview

Excel权限配置是指用户将点与资源组进行关联后（具体参照资源组权限管理），在使用Excel插件时，可以根据资源组对tag点进行上传下载操作，也可以批量上传资源组信息；

u 资源组关联Tag下载

u tag关联资源组上传

u 批量上传资源组

操作步骤如下：

·首先点击展开“高级”菜单，选择“资源组关联Tag下载”或“tag关联资源组上传”选项。

·若选“资源组关联Tag点下载”，则将相应资源组关联tag点导出至excel，原有“扩展字符串1”字段更改为“记录资源组”，原有“扩展字符串2”字段更改为“tag配置资源组”

示例如下：

Select(x) | Tag名 | 归档状态 | Tag修改日期 | Tag修改者 | 压缩误差 | 压缩超时 | 压缩类型 | Tag创建日期 | Tag创建者 | 记录访问权限 | 记录权限组 | 记录所有者 | 描述 | 数字量集 | 工程单位 | 过滤超时 | 过滤误差 | TagID | Tag类型 | Tag访问权限 | Tag权限组 | Tag所有者 | 扫描状态 | 记录取值范围 | 最小取值 | 是否可用 | 保留参数1 | 保留参数2 | 保留参数3 | 保留参数4 | 保留参数5 | OPC发布状态 | IMV发布状态 | 记录资源组 | tag配置资源组 | 设备点名 | 设备点类型 | 采集器名 | 设备名 | 扫描组名 | 字节序
x | tag1 | 1 | 2023-12-11 10:32:6 | admin | 0 | 0 | 0 | 2023-11-23 14:29:36 | admin | 0 | admin | test1 |  |  |  | 300 | 0 | 13 | float64 | 21 | admin | test1 | 1 | 100 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | IMV=0;IMVSCAN=1000;IMVTASKID=1;IMVEXTPARA=; | recordaccessr(r)|recordaccessrw(r,w)|recordaccess() | tagconfigaccessr(r)|tagconfigaccessw(w) |  | 0 |  |  |  | 0
x | tag2 | 1 | 2023-11-23 14:29:43 | admin | 0 | 0 | 0 | 2023-11-23 14:29:43 | admin | 53 | admin | admin |  |  |  | 300 | 0 | 14 | float64 | 53 | admin | admin | 1 | 100 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | IMV=0;IMVSCAN=1000;IMVTASKID=1;IMVEXTPARA=; | recordaccessr(r)|recordaccessrw(r,w)|recordaccess() | tagconfigaccessr(r)|tagconfigaccessw(w) |  | 0 |  |  |  | 0

·若选“tag关联资源组上传”，则将相应资源组关联tag点上传至excel；上传Excel表结构，示例如下：

选择(x) | Tag名 | 记录资源组 | tag配置资源组
x | tag1 | recordaccessr;recordaccessrw;recordaccess | tagconfigaccessr;tagconfigaccessw
x | tag2 | recordaccessr;recordaccessrw | tagconfigaccessr

·如需批量上传资源组，则添加资源组批量上传Excel表结构，示例如下：

（注意：上传模式为增量导入，即不会修改或删除已经导入的资源组，如需要修改需手动添加或删除重建）

选择(x) | 资源组名 | 描述 | 权限类型 | 用户组
x | tag1 |  | 1 | admin;user1;user2
x | tag2 |  | 5 | admin;user3

配置完成后选择“资源组上传”，在弹出窗内可选择上传模式“上传/删除”，点击“确定”，即可查看上传进度及操作结果弹窗；

·权限类型和数字对应关系：


点名在线修改

Navigation: 功能明细 > 数据展示 > 电子表格 >

点名在线修改

 Return to chapter overview

iHD提供KingAPI接口对iHD中除系统点外的tag点点名进行修改，用户可通过Excel插件批量修改点名以及查看点名修改履历，修改点名涉及的相应服务可能需要手动重启等操作同步配置。

1.修改点名操作：

·实时数据库“高级”菜单中添加“修改点名上传”和“点名修改履历下载”选项。

·用户按下表示例，组织需要修改点名的tag点信息后，点击“修改点名上传”，即可实现批量修改点名功能。

注意：用户需要确保旧点名与新点名正确后再进行点名更新操作,如果新tag点名中存在重复点名，需要用户将重复点名修复后才能修改点名。

选择(x) | 旧Tag名 | 新Tag名
x | tag1 | tagnew1
x | tag2 | tagnew2

·用户点击“点名修改履历下载”选项，即可下载tag点名修改历史信息，示例如下：

选择(x) | 旧Tag名 | 新Tag名 | 用户名 | 修改时间
x | tag1 | tagnew1 | user1 | 2024-2-4 10:1:59
x | tag2 | tagnew2 | user1 | 2024-2-4 10:2:6

2.iHD服务处理：
如果修改点名的tag点涉及到iHD如下服务，需要进行相应处理，同步修改后点名配置信息。

修改点名后需要手动修改配置的服务：

修改点名后需要重启的服务：

在线修改点名后，iHD客户端程序以及第三方应用服务需要重启。

如：系统管理工具、HDOPCServer、SQL查询工具、Excel表格客户端等等。


Excel/WPS插件安装

Navigation: 功能明细 > 数据展示 > 电子表格 >

Excel/WPS插件安装

 Return to chapter overview

普通用户版本与管理员版本区别为：管理员版本Excel加载项具有高级功能（包括数据上传与下载等）及用户与组配置功能，普通用户版本则仅有数据查询功能；

用户可按实际需求选择安装；

u 插件安装：

运行iHD客户端安装程序iHyperDB_Client_Addin.exe，按提示选择路径进行安装即可。

安装完成后，插件均为普通用户版本，仅有数据查询功能，连接服务器后查询即可；

u 版本切换：

若想使用管理员版本，首先需切换到安装目录 :\iHD\executable_x86

将文件 iHyperDB.xla，iHyperDB_wps.xla 改成其他名字如 iHyperDB_通用.xla，iHyperDB_wps_通用.xla

将文件 iHyperDB.admin.xla 、iHyperDB_wps.admin.xla 分别改名为 iHyperDB.xla，iHyperDB_wps.xla


组态展示

Navigation: 功能明细 > 数据展示 >

组态展示

 Return to chapter overview

组态展示介绍基于icv的CS架构组态功能。

组态展示包括分发配置、组态画面运行两个部分。

分发配置可以实现对组态页面的编辑及分发。如节点管理、函数库管理、图库管理、分发等功能。分发配置模块位于“开始菜单->iHyperDB->系统管理工具->分发配置”。

组态画面运行能够监视各种实时数值、实时报警、还可以确认报警和进行远程控制，实现页面间的切换等。组态运行从“开始菜单->iHyperDB->客户端应用快捷链接->组态运行客户端”进入。

注意:

1、在安装客户端时候，选择安装“组态”功能才能正常使用组态模块；

2、ihd的组态不能和icv组态安装同一个机器。

3、组态趋势图不能展示string数据，请不要选择string类型点。

4、如果需要在组态系统中查看Tag点数据，Tag点的名称不能含英文标点符号（-和:和.）。


安装部署

Navigation: 功能明细 > 数据展示 > 组态展示 >

安装部署

 Return to chapter overview

iHyperDB实时数据库组态系统可以通过组态客户端展示实时数据和历史记录。

组态系统的服务端包含在配置中心，统一存储配置文件和处理客户端分发请求。

CS客户端/HMI可以展示运行组态画面，需要安装iHyperDB客户端程序，还需要在客户端安装过程中选择“组态运行客户端/HMI”模块。

userhelp.chm

iHyperDB_Client.exe

在安装中勾选“客户端”节点类型,还需要在客户端安装过程中选择“组态运行客户端/HMI”模块。

userhelp.chm为帮助文档，具体组态和图库帮助手册参见安装目录的executable\zt文件夹中chm帮助文件。


权限管理

Navigation: 功能明细 > 数据展示 > 组态展示 >

权限管理

 Return to chapter overview

·权限管理

系统管理平台->权限管理->统一权限管理模块提供了设置配置分发权限：

双击一行“配置分发权限”，或右击该行，弹出菜单中选择“属性”选项，弹出“配置分发权限设置”对话框

按照下述规则配置各项信息，然后点击“确定”按钮，即可完成配置。

规则：

ü所属组、操作组、其它组，三者权限依次递减，即前一个大于等于后一个权限；

ü用户只能指定一个所属组，也只能指定一个操作组，其余的组均称为其他组；

üAdmin用户可以对权限值任意配置，其它“iHyperDB-User写”权限的用户只能按照A要求配置；

“配置分发”权限有两种：“无”和“读/写”。


节点管理

Navigation: 功能明细 > 数据展示 > 组态展示 >

节点管理

 Return to chapter overview

1、节点管理

系统管理平台->组态->节点管理 模块提供如下几个功能：

1.1、配置hmi节点

a)hmi节点为运行态组态系统所在的节点

b)Web节点为这样一个特别的hmi节点：其对外提供webserver服务。全局最多只存在一个web节点

1.2、配置节点上运行的组态画面

a)对于普通的hmi节点，通过绑定组态画面，设置初始启动画面，并执行分发动作，服务端将推送对应的配置及组态文件至该节点

b)对于web节点，需要在B/S系统的“组态集成配置模板”中设置节点初始启动画面；其它的同普通hmi节点

配置实时数据库物理位置，本系统中所有的节点均能够与这些实时数据库进行数据交互。

本节内容如下：

·设置实时数据库

§设置实时数据库

在分发配置模块，我们配置实时数据库的IP、端口号等信息，这些信息将仅被用于组态系统访问实时数据库。

“设置实时数据库”详述了如何对可访问的实时数据库基本属性进行配置。内容如下：

ü添加实时数据库

节点管理->节点基本信息Tap页，点击“添加”按钮，弹出“添加可访问的实时数据库”对话框：

依次输入服务器名、描述、主机信息、备机信息（须勾选“是否有备机”），点击确定，完成添加。

如果要能在组态界面中选点，一定要先把分发配置->节点管理中的可访问的实时数据库配置上，然后部署到该节点上，才可以在编辑态选实时数据库的点

§修改实时数据库

选中要修改的数据库，右击，弹出修改按钮，单击“修改”，进入修改界面，输入新的实时数据库信息，单击确定完成修改：

§删除实时数据库

选中要删除的实时数据库，单击删除按钮，弹出删除确认框：

单击确定，完成删除。

注：输入项信息限制规则：

1、服务器名：非空，不得包含英文句号，最大长度63字节；全局惟一；

2、描述：可为空，最大长度63字节；

3、IP地址：最大长度15字节，不可为127.0.0.1；

4、端口号：不得为空，范围：[0,65535]；

·设置节点

§设置节点

“设置节点”详述了如何对节点的基本属性进行配置。节点基本信息界面，内容如下：

§添加节点

单击节点列表框内的添加按钮，弹出节点信息输入框：

依次输入节点名称、IP、类型、描述，点击确定，完成添加。

ü修改节点

选中要修改的节点，右键菜单选择“修改”，弹出修改节点界面：

除了节点类型不可修改，其它三项信息均可修改。

§删除节点

选中要删除的节点，单击节点列表框内的删除按钮，弹出删除提示：

单击确定，完成删除。

§分发节点：请参阅“分发/全部分发”章节。

注：

1、节点名称：非空，最大长度63字节；

2、节点名称全局惟一；

3、IP地址：最大长度15字节；

节点描述：可为空，最大长度63字节；

·设置节点的组态画面

§设置节点的组态画面

进入节点管理的Tap页：节点画面列表，可设置节点的组态画面。“设置节点的组态画面”详述了如何独占地配置节点与组态画面绑定。绑定画面操作为互斥操作，需要签出节点。本部分内容如下：

§签出节点

节点树上选中节点，单击签出按钮，签出节点：

§签入节点

节点树选中已签出的节点，单击“签入”按钮，保存该节点的画面绑定信息至服务端。

§取消签出节点

节点树选中已签出的节点，单击“取消签出”按钮，取消该节点的签出。

§增减组态画面

签出节点，单击节点画面列表框内的“增减画面”按钮，进入绑定画面配置界面：

对话框左面为当前可选的全部组态画面名称，右面为已选中的组态画面名称。选中左面的画面，单击”>>”按钮，将该画面置为已选；选中右面的画面，单击”<<”按钮，将该画面置为未选。

单击“确定”按钮，完成选择画面。

对于hmi节点来说，还可选择画面作为初始启动画面：

注：

只有签入节点，才将绑定画面信息保存至服务端

©2015. All Rights Reserved.


组态画面管理

Navigation: 功能明细 > 数据展示 > 组态展示 >

组态画面管理

 Return to chapter overview

组态管理->“组态画面”Tap页，进行组态画面管理。组态画面是指现场中使用的构成现场监控画面的图形。

本节内容如下：

·导入画面

单击界面上的“导入画面”按钮，弹出打开文件对话框。如下图所示：

选中需要导入的组态画面（可多选），点击打开按钮，系统管理平台将选中的画面导入至服务端，组态画面主界面上显示这些导入的画面。如下图所示：

点击列名，可对所有文件、文件夹按字母排序。只允许导入扩展名为“bsp”的文件；

·签出

勾选一个或多个未签出的组态画面，单击“签出”按钮，签出这些组态画面。被签出的组态画面信息中显示状态、操作者、操作者信息。

·签入

勾选一个或多个已签出的组态画面，单击“签入”按钮，将这些组态画面文件变更保存至服务端。签入后，表格中对应的状态、操作者、操作者信息为空。

·取消签出

勾选一个或多个已签出的组态画面，单击“取消签出”按钮，取消客户端对这些组态画面的变更。取消签出后，表格中对应的状态、操作者、操作者信息为空。

·修改画面描述

表格中选中已签出的画面，右键选择“修改”，弹出修改描述界面。输入新的描述，单击确定完成修改。

·新建画面

选择“新建画面”，弹出新增的画面

·编辑画面

选中已签出的组态画面，单击“编辑画面”按钮，打开该组态画面进行编辑。

如果当前画面正在编辑时，发生了分发画面的操作，会导致这个画面的属性变成了只读，此时，请先从组态画面管理中，取消签出，然后再次签出，这样，画面属性就是可读状态了，在组态编辑态中，这个画面就可以继续保存了。

·在组态画面上显示实时数据库tag数据值

1.在组态配置客端运行组态画面编辑

2.在组态画面插入Text文本动画显示实时数据库的快照数据

勾选“动画”，双击输入框可选择tag变量. （注：第一次配置时可能出现iCV变量选择界面，这时需要点击界面右上角的“切换数据源”按钮，可进入实时数据库变量选择界面如下）

再“确定”，“保存”。

完成画面编辑后，将保存的画面在组态配置客户端签入，然后部署到iHD-HMI客户端，在客户端就可以运行组态画面了。

注意

1)iHD的tag变量只能查看，不能控制或写值。由于iCV界面限制，在组态中展示的tag变量名称有限制，如不能包含"+"、"."、"-"等符号以及min、max等关键字,具体参考iCV用户手册。

2)如果需要使用组态查看iCV数据，需要配置HMI关联对应的SCADA，具体参见iCV配置说明。

3)部署HMI需要有hdccagent启动，查看客户端进程是否存在该进程。

4)如果需要权限控制，iHD-HMI客户端需要在服务端的信任列表添加客户端IP，对应的映射用户需要有读数据权限。

5)先配置实时数据库节点并部署分发到客户端，iWebview的趋势图才能够选点。

·添加文件夹

我们通过文件夹的方式来对组态画面进行分组浏览。单击“添加文件夹”按钮，输入文件夹名称，单击确定，服务端在指定目录下创建该文件夹，组态画面管理主界面上显示已添加的文件夹。

添加的文件夹在表格中浏览，双击文件夹所在行进入该文件夹。

·返回上级目录

浏览文件夹内组态画面时，可点击“返回上级目录”按钮，返回上级目录。

·删除

选中一个或多个文件夹/未签出画面，单击“删除”按钮，从服务端删除这些文件。

分发：请参阅“分发/全部分发”章节。

注：

1、画面名称：非空，最大长度255字节；

2、画面描述：可为空，最大长度63字节；

3、文件夹名称：非空，最大长度255字节；


组态函数库管理

Navigation: 功能明细 > 数据展示 > 组态展示 >

组态函数库管理

 Return to chapter overview

组态函数库脚本管理

组态管理->“组态函数库脚本”Tap页，进行组态函数库脚本管理。多个组态画面可通过调用函数库中的相同函数来实现相同的功能。关于组态脚本的进一步信息，请参阅【编辑组态脚本】。

本节内容如下：

·导入

单击界面上的“导入”按钮，弹出打开文件对话框，如下图所示：

选中需要导入的脚本（可多选），单击“打开”按钮，系统管理平台将选中的脚本文件导入到服务端，在函数库脚本列表中显示这些脚本。

只允许导入扩展名为.vs的脚本文件。点击列名，可对脚本进行排序。

· 签出

勾选一个或多个未签出的脚本，单击“签出”按钮，签出这些脚本。被签出的脚本信息中显示状态、操作者、操作者信息。

·签入

勾选一个或多个已签出的脚本，单击“签入”按钮，将这些脚本文件变更保存至服务端。签入后，表格中对应的状态、操作者、操作者信息为空。

·取消签出

勾选一个或多个已签出的脚本，单击“取消签出”按钮，取消客户端对这些脚本的变更。取消签出后，表格中对应的状态、操作者、操作者信息为空。

·修改描述

表格中选中已签出的脚本，右键菜单中选择修改，弹出修改描述界面。输入新的描述，单击确定完成修改。

·新建

单击“新建”按钮，客户端运行NotePad.exe，进行新建文本文件。

·编辑

选中已签出的脚本文件，单击“编辑”按钮，打开该脚本文件进行编辑。

·删除

选中一个或多个未签出的脚本，单击“删除”按钮，弹出删除确认框；确定后将这些脚本从服务端删除。

·分发：请参阅“分发/全部分发”章节。

注：

1、脚本名称：非空，最大长度255字节；

2、脚本描述：可为空，最大长度63字节；

·全局脚本的使用案例：

1.自己编辑写一个脚本，用记事本编写即可，后缀名改为“.vs”例如：test.vs，如图：

2.在组态函数库中导入脚本test.vs，并签入。

3.在组态中应用该脚本，新建一个页面，画一个按钮，并在组态脚本中，对这个按钮写一个click事件，click事件中，我们将调用这个全局脚本中的function hello，脚本如下：

sub BSButton1_onClick()

'下面的hello方法就是在test.vs中定义的方法

hello

end sub

4.点击按钮，画面上会出现msgbox，显示“hello world”。


图库管理

Navigation: 功能明细 > 数据展示 > 组态展示 >

图库管理

 Return to chapter overview

图库管理

图库是用于组态系统中的一种特殊对象。关于图库的详细信息，请参阅【使用图库】。进入组态管理->“图库管理”Tap页，进行图库管理。

本节内容如下：

·导入

单击界面上的“导入”按钮，弹出打开文件对话框，如下图所示：

选中需要导入的图库（可多选），单击“打开”按钮，系统管理平台将选中的图库文件导入到服务端，在图库列表中显示这些图库文件。

只允许导入扩展名为.clb的图库文件。点击列名，可对图库进行排序。

·签出

勾选一个或多个未签出的图库，单击“签出”按钮，签出这些图库。被签出的图库信息中显示状态、操作者、操作者信息。

·签入

勾选一个或多个已签出的图库，单击“签入”按钮，将这些图库文件变更保存至服务端。签入后，表格中对应的状态、操作者、操作者信息为空。

·取消签出

勾选一个或多个已签出的图库，单击“取消签出”按钮，取消客户端对这些图库的变更。取消签出后，表格中对应的状态、操作者、操作者信息为空。

·修改描述

表格中选中已签出的图库，右键菜单中选择修改，弹出修改描述界面。输入新的描述，单击确定完成修改。

·新建

单击“新建”按钮，客户端运行图库设计器，进行新建图库文件。

·编辑

选中已签出的图库文件，单击“编辑”按钮，打开该图库文件进行编辑。

·删除

选中一个或多个未签出的图库，单击“删除”按钮，弹出删除确认框；确定后这些图库将从服务端删除。

·分发：请参阅“分发/全部分发”章节。


分发全部分发

分发

Navigation: 功能明细 > 数据展示 > 组态展示 >

分发

 Return to chapter overview

分发配置的多个模块中我们进行了多个配置项信息的设置。这些信息/文件被保存在分发服务端。通过分发按钮操作，我们将这些信息/文件推送至其应用场所，即节点。

·分发方式有两种：

§强制分发，强制覆盖目标节点的文件；

§增量分发：若文件发生变更则更新目标节点文件；否则不覆盖目标节点文件。

·触发分发的动作有6类：

§节点列表-分发按钮

§组态画面-分发按钮

§组态函数库脚本-分发按钮

§图库管理--分发按钮

§Web升级包管理--分发按钮

§全部分发按钮

下面我们对详述这6类分发：

·节点列表-分发按钮

节点管理-节点基本信息界面，在节点列表中选中节点，单击分发按钮，弹出分发信息确认框：

在确认框中显示了要分发的节点以及分发内容。对于节点配置信息的分发为强制分发。

单击“分发”按钮，弹出分发结果显示框。

·组态画面-分发按钮

组态画面界面，选中一个或多个组态画面，单击“分发”按钮，弹出分发信息确认框，显示节点信息及分发文件信息：

勾选要分发的节点，选择是否强制分发，单击“分发”按钮，弹出分发结果显示框。

如果要能在组态界面中选点，一定要先把分发配置->节点管理中的可访问的实时数据库配置上，然后部署到该节点上，才可以在编辑态选实时数据库的点

·组态函数库脚本-分发按钮

组态函数库脚本界面，选中一个或多个脚本，单击“分发”按钮，弹出分发信息确认框，显示节点信息及分发文件信息：

勾选要分发的节点，选择是否强制分发，单击“分发”按钮，弹出分发结果显示框。

·图库管理--分发按钮

图库管理界面，选中一个或多个图库，单击“分发”按钮，弹出分发信息确认框，显示节点信息及分发文件信息：

勾选要分发的节点，选择是否强制分发，单击“分发”按钮，弹出分发结果显示框。


组态回放

Navigation: 功能明细 > 数据展示 > 组态展示 >

组态回放

 Return to chapter overview

·控件方式使用组态回放

组态回放功能需要在组态画面添加hdZTPlay控件，通过该控件可以切换历史数据回放和实时数据显示2种模式，切换操作对当前画面运行的客户端有效，建议在导航栏等bsp画面中添加。

下面是2个效果图：

组态编辑中添加ocx控件如下：

注意在组态画面上拖动设置控件合适的大小。

编辑状态下双击控件上的配置按钮，可以设置回放控件默认属性：

配置回放控件上面操作完成就可以了。

另外回放控件提供GetMode()函数供组态脚本调用，获取当前回放模式，返回值为零时表示实时数据显示模式，值为1时表示历史数据回放模式。

组态画面运行时回放控件的按钮可以控制启动和暂停回放、回放快进倍速、停止回放、动态设置回放参数。回放进度条左侧显示当前回放起止时间，右侧显示当前回放时间，拖动进度条可以调整当前回放进度。

· 脚本方式使用组态回放

§方法

组态回放提供一些列的方法，通过调用方法实现界面回放配置与控制。

ü方法说明

方法名称 | 函数说明 | 参数说明
GetStartTime | 获取开始时间 | 输入：空 返回值：字符串组态回放的开始时间 默认值：为当前时间往前一小时
SetStartTime | 设置开始时间 | 输入：组态回放的开始时间,格式为 yyyy-mm-dd hh:mm:ss 返回值：参数正确，返回0，否则，返回错误码 约束：开始时间要小于结束时间
GetEndTime | 获取结束时间 | 输入：空 返回值：组态回放结束时间 默认值：当前时间
SetEndTime | 设置结束时间 | 输入：组态回放的结束时间，格式同开始时间 返回值：字符串同开始时间 约束：结束时间必须大于开始时间
GetPlaySeg | 获取历史数据播放间隔 | 返回值：整型值历史数据播放的间隔 默认值：5秒
SetPlaySeg | 设置历史数据播放间隔 | 输入：播放数据的间隔秒数 返回值：如果设置成功为0， 否则返回错误码 约束：不能小于等于0，也不能大于结束时间减去开始时间的间隔
GetPlayTimeSec | 获取回放控件游标位置的时间 | 输入：空 返回值：long型 ，显示的是从1970年1月1日到现在的秒数。
GetValueMode | 获取取值模式 | 输入：空 返回值：整形0或者1 0表示前向插值，1表示线型插值 默认值：0，前向插值
SetValueMode | 设置取值模式 | 输入：取值模式整形值0 ，或者1 返回值：成功为0，否则错误码 约束：只能是0， 1
GetBackColor | 获取控件背景颜色 | 输入：空 返回值：控件背景颜色的RGB整形值 默认值：黑色
SetBackColor | 设置控件背景颜色 | 输入：vb中直接使用RGB函数 返回值：0 约束：无
GetTextColor | 获取控件上字体颜色 | 输入：空 返回值：控件字体颜色的RGB整形值 默认值：白色
SetTextColor | 设置控件上字体颜色 | 输入：vb中直接使用RGB函数 返回值：0 约束：无
Play | 播放 | 无
Pause | 暂停 | 无
Stop | 停止 | 无
ReSetPlayTime | 重新设置播放节点 | 输入：整型值 返回值：设置成功为0，否则错误码 约束：0-100之间
SpeedUpPlay | 加速播放 | 输入：整型值 返回值：设置成功为0，否则错误码 约束：只能是1，2，4，8，16，32，1表示加速1倍，2表示加速4倍，32表示加速速率为1 默认值：1
GetMode | 获取回放模式 | 输入：空 返回值：整形 ，0表示实时数据回放，1表示历史数据回放

ü方法在Vb中脚本编写样例：

v获取组态回放的配置数据

在Test.bsp中添加4个IO控件，分别为IOStartTime, IOEndTime, IOPlaySeg, IOValueMode,添加2个矩形控件RectangleBGColor，RectangleTextColor；添加一个按钮BsButtonSet,在脚本中添加按钮的Onclick事件，编辑脚本如下：

Sub BSButtonSet_OnClick()

'get config data

IOStartTime.Text = ZTPLAYCONTROL5.GetStartTime

IOEndTime.Text = ZTPLAYCONTROL5.GetEndTime

IOPlaySeg.Text = ZTPLAYCONTROL5.GetPlaySeg

IOValueMode.Text = ZTPLAYCONTROL5.GetValueMode

RectangleBGColor.FillColor ZTPLAYCONTROL5.GetBackColor

RectangleTextColor.FillColor = ZTPLAYCONTROL5.GetTextColor

End Sub

v设置组态回放的参数

在Test.bsp中再添加4个windows的标准Edit控件，分别为EditStartTime, EditEndTime, EditPlaySeg, EditValueMode, EditBGColor,以及 EditTextColor,编辑脚本如下：

Sub BSButtonSet_OnClick()

'get old config data

IOStartTime.Text = ZTPLAYCONTROL5.GetStartTime

IOEndTime.Text = ZTPLAYCONTROL5.GetEndTime

IOPlaySeg.Text = ZTPLAYCONTROL5.GetPlaySeg

IOValueMode.Text = ZTPLAYCONTROL5.GetValueMode

RectangleBGColor.FillColor ZTPLAYCONTROL5.GetBackColor

RectangleTextColor.FillColor = ZTPLAYCONTROL5.GetTextColor

'set new config data

'set start time

If EditStartTime.WindowText<> "" Then

IOStartTime.Text = EditStartTime.WindowText

End If

nRet = ZTPLAYCONTROL5.SetStartTime(IOStartTime.Text)

If nRet <> 0 Then

MsgBox "Start time Invalid"

End If

'set end time

If EditEndTime.WindowText <> "" Then

IOEndTime.Text = EditEndTime.WindowText

End If

nRet = ZTPLAYCONTROL5.SetEndTime(IOEndTime.Text)

If nRet <> 0 Then

MsgBox "End Time Invalid"

End If

'set Play seg

Dim nPlaySeg

strPlaySeg = IOPlaySeg.Text

nPlaySeg = Int(strPlaySeg)

temp = EditPlaySeg.WindowText

If temp <> "" Then

strPlaySeg = EditPlaySeg.WindowText

nPlaySeg = Int(strPlaySeg)

End If

nRet = ZTPLAYCONTROL5.SetPlaySeg(nPlaySeg)

If nRet <> 0 Then

MsgBox "Play Seg Invalid"

End If

'set Value mode

Dim nValueMode

strValueMode = IOValueMode.Text

nValueMode = Int(strValueMode)

If EditValueMode.WindowText <> "" Then

strValueMode = EditValueMode.WindowText

nValueMode = Int(strValueMode)

End If

nRet = ZTPLAYCONTROL5.SetValueMode(nValueMode)

If nRet <> 0 Then

MsgBox "Value Mode Invalid"

End If

'set back color

If EditBGColor.WindowText <> "" Then

strcolor = Split(EditBGColor.WindowText, ",", -1, 1)

RectangleBGColor.FillColor = RGB(strcolor(0),strcolor(1),strcolor(2))

End If

ZTPLAYCONTROL5.SetBackColor RectangleBGColor.FillColor

'set Text color parse RGB value

If EditTextColor.WindowText <> "" Then

strcolor = Split(EditTextColor.WindowText, ",", -1, 1)

RectangleTextColor.FillColor = RGB(strcolor(0),strcolor(1),strcolor(2))

End If

ZTPLAYCONTROL5.SetTextColor RectangleTextColor.FillColor

End Sub

v播放，暂停，停止，加速, 重新设置播放节点

在Test.bsp中加入五个按钮，BSButtonPlay, BSButtonPause, BSButtonAccelerate BSButtonStop，BSButtonReSet，添加EditRate, 和EditPercent输入框，在脚本编辑中添加5个按钮的On_click事件：

Sub BSButtonPlay_OnClick()

ZTPLAYCONTROL5.Play

End Sub

Sub BSButtonPause_OnClick()

ZTPLAYCONTROL5.Pause

End Sub

Sub BSButtonAccelerate_OnClick()

rate = EditRate.WindowText

nRate = Int(rate)

nRet = ZTPLAYCONTROL5.SpeedUpPlay( nRate)

If nRet <> 0 Then

MsgBox "加速速率输入不合法"

End If

End Sub

Sub BSButtonStop_OnClick()

ZTPLAYCONTROL5.Stop

End Sub

Sub BSButtonReSet_OnClick()

percent = EditReSetPlayTime.WindowText

nPer = Int(percent)

nRet = ZTPLAYCONTROL5.ReSetPlayTime(nPer)

If nRet <> 0 Then

MsgBox "设置新的播放节点的值不正确在0-100之间"

End If

End Sub

v获取回放控件游标位置的时间

画面布局如下，目标是通过BSButton按钮获取进度条游标位置的时间，并显示在TEXT处：

脚本如下：

Sub BSButton3_OnClick()

Text2.Text = ZTPLAY1.GetPlayTimeSec()

End Sub

效果如下：

所取得的结果为从1970年1月1日0点0分0秒到游标所在处的秒数，可以折算成游标所处时间，也可以结合GetStartTime()函数，从而计算已播放的时间。

§事件

ü事件说明

事件名称 | 事件说明
ModeChange | 当回放模式变化的时候触发

üvb脚本编写样例

在Test.bsp中，添加一个Text控件，编辑脚本：

Sub ZTPLAYCONTROL5_ModeChange()

Text23.Text = “Hello”

End Sub

©2015. All Rights Reserved.


授权项脚本

授权项展示

Navigation: 功能明细 > 数据展示 > 组态展示 >

授权项展示

 Return to chapter overview

要在脚本中使用授权项，必须首先在权限管理—用户与组管理中添加相关授权项，具体方法可参看 用户与组管理

· 添加授权项

1、添加所需要的授权项,以Auth1为例

2、以用户admin为例，选择“admin”，右键选择“组属性”，添加需要的授权项即可，如图示：

·脚本方式使用授权项

§方法

组态授权项脚本，通过编写脚本的方法调用授权项管理。

1.授权项登陆VFC_Login

输入参数UserName 字符串

输入参数 Password 字符串

使用授权项信息之前，用户需要使用有效的用户名密码登陆

sys.VFC_Login “用户名”, “密码”

2.验证当前用户权限 VerifyCurUserRight

验证当前用户权限，此当前用户就是之前登陆的用户

输入参数szItem 字符串 授权项名称

sys.VerifyCurUserRight "Auth1"

3.获取当前用户名GetiCentroViewUserName

返回当前用户的名称 username

MsgBox sys.GetiCentroViewUserName

4.验证指定用户权限VerifyUserRight

输入参数 szItem 授权项

输入参数 username 用户名

输入参数 passward 密码

MsgBox sys.VerifyUserRight("Auth1", "passward","username")

§Vb中脚本编写样例：

1.授权项登录

在Test.bsp中添加2个TEXT控件,分别写为“用户名”和“密码”，再添加2个editbox(绘图-特殊对象-windows标准控件-编辑框)，分别代表“输入的用户名和密码”，属性名称“UserName 和 Pwd”，再添加一个BSButton控件，名称为“登录”，在脚本中添加按钮的Onclick事件，编辑脚本如下：

Sub BSButton_OnClick()

MsgBox sys.VFC_Login(UserName.WindowText, Pwd.WindowText)

End Sub

2.验证当前用户授权项权限

在Test.bsp中再添加1个TEXT控件,分别写为“授权项名称”，再添加个editbox，分别代表“授权项名称”，再添加一个BSButton控件，名称为“验证当前用户授权项”，在脚本中添加按钮的Onclick事件，编辑脚本如下：

Sub GetCurUser_OnClick()

MsgBox sys.VerifyCurUserRight("Auth1")

End Sub

3.获取当前用户名

在Test.bsp中再添加3个TEXT控件,分别写为“用户名、密码、授权项名称”，再添加3个editbox，分别显示“用户名、密码和授权项名称”，添加一个BSButton控件，名称为“获取当前用户名”，在脚本中添加按钮的Onclick事件，编辑脚本如下：

Sub GetCurrentUserName_OnClick()

MsgBox sys.GetiCentroViewUserName

End Sub

4.验证指定用户权限

在Test.bsp中再添加一个BSButton控件，名称为“验证指定用户权限”，在脚本中添加按钮的Onclick事件，编辑脚本如下：

Sub GetUserAuth_OnClick()

MsgBox sys.VerifyUserRight("SpecialAuth.WindowText，SpecialUser.WindowText,SpecialPwd.WindowText")

End Sub

©2015. All Rights Reserved.


组态实时报警

Navigation: 功能明细 > 数据展示 > 组态展示 >

组态实时报警

 Return to chapter overview

·组态实时报警

§开始使用报警控件

首先，安装iHyperDB客户端，勾选“组态配置与展示”选项。如下图：

假设实时数据库安装在c盘，在路径C:\iHyperDB\executable\zt下打开ZTDesign.exe组态系统。新建一个画面后，在组态菜单栏或者快捷按钮上找到“插入Active控件”。

选择“hdAlarmView Class”拖入组态画面中并保存。画面如下：

支持多个报警控件同时使用！

单击右键菜单选择“编辑脚本”，调用StartRunMode和StopRunMode两个函数，写脚本如下：

1、脚本必须要写，如果不写脚本会导致报警信息错误；

2、目前只支持StartRunMode和StopRunMode两个函数。

单击F6，进入运行态，开始查看实时报警。如下图：

按F7退出组态运行态。

§过滤条件的配置

在组态画面中，右键菜单选择“特殊属性”或者双击控件，右键“设置属性”。如图：

弹出“属性配置对话框”，第一个tab页就是过滤条件设置。如图：

共有6种过滤，每种过滤前的checkbox表示是否启用这项过滤。勾选之后，设置按钮可以用。

ü 报警组过滤设置：

v单击“设置”按钮，弹出对话框。在左侧界面选择报警组，单击“添加”按钮，添加到右侧界面中。

v单击“确认”按钮后，报警组被添加到设置文字框中。如图：

1、报警组以全路径形式表示，多个报警组用“|”分隔；

2、报警组不可以带“|”和“\”。

ü 报警状态过滤设置：

v单击“设置”按钮，弹出对话框。如图：

1、用0和1表示是否启用某一项过滤。如全部勾选“1|1|1|”；

2、已确认已恢复的报警默认不会显示。

ü 报警时间过滤设置：

v单击“设置”按钮，弹出对话框。如图：

1、如果选择介于开始时间1980-1-1 00:00:00到结束时间2014-11-12 00:00:00，那么序列化字符串为：“0|1980-1-1 00:00:00|2014-11-12 00:00:00|”；

2、选择介于、不介于时，开始时间和结束时间都可以填写；

3、选择今天、最近一小时、最近半小时，开始和结束时间都不可以填写；

4、选择大于，大于等于时，只有开始时间可以填写；

5、选择小于，小于等于时，只有结束时间可以填写。

ü 报警优先级过滤设置：

v单击“设置”按钮，弹出对话框。如图：

用0和1表示是否启用某一项过滤。如全部勾选“1|1|1|1|”。

ü 报警类型过滤设置：

v单击“设置”按钮，弹出对话框。如图：

用0和1表示是否启用某一项过滤。如全部勾选“1|1|1|1|1|”。

ü 报警点名过滤设置：

v tag名过滤，支持字符串模糊匹配，只能输入最大长度255的字符

a.“*”查询全部

b.“abc*”查询以abc开头的tag

c.“*abc”查询以abc结尾的tag

§属性列的配置

“属性配置对话框”，第二个tab页就是属性列的设置。将需要显示的列通过箭头按钮移动到右侧区域，单击确认后，报警列表的 列更新。

§声音和颜色的配置

声音配置中可以通过勾选“开启响铃提示”配置是否开启声音。单击铃声设置列表中的报警级别，下方的声音路径文字框中显示该级别对应的声音文件。并可以单击声音文件后的播放按钮进行试听。浏览按钮不可用。

如果需要更改某种级别的报警铃声，需要到对应的路径下同名替换该声音文件。

ü 响铃方式：

v响铃次数：发生报警时播放声音文件的次数，播完配置的次数后停止

v直到确认停止：报警声音将一直重复播放，直到用户确认该报警停止播放

ü颜色的配置：

v四种报警级别分别可以配置报警的颜色，单击“默认值”按钮，恢复如下图的颜色配置。如图：


ICV组态使用实时数据库

Navigation: 功能明细 > 数据展示 > 组态展示 >

ICV组态使用实时数据库

 Return to chapter overview

·安装部署具体操作

需要安装实时数据库CS客户端中的组态运行客户端以及iC配置服务端、配置客户端以及iHD插件，具体安装版本如下：

iHD-HMI：实时数据库2.2.0以上版本的CS客户端安装程序将提供组态运行客户端。

组态配置端：安装iCV5.3.5(P3+P3_Patch3)配置服务端+配置客户端 + iHD plugin setup。

配置iHyperDB数据源：

进入icv客户端配置界面，在全局配置中添加一个iHyperDB服务器，IP地址为iHyperDB服务端IP，如下图所示：

配置完ihd节点后，配置组态画面，如下图所示：

配置完组态画面后，配置iHD_HMI节点：

1、添加一个HMI节点，IP地址为组态运行端(iHD-HMI)的IP。

2、选择HMI节点需要部署的画面，并勾选初始启动画面

3、执行部署配置和组态画面到HMI节点

·运行组态

在iHD-HMI节点的开始菜单有组态运行客户端的快捷方式，点击启动即运行组态系统，将打开配置的初始画面。

其他参考：

组态画面编辑实例（常规组态功能可参考组态帮助文档）。

下面示例在组态画面上显示实时数据库tag数据值：

1.在组态配置客户端运行组态画面编辑，

2、在组态画面插入Text文本动画显示实时数据库的快照数据

勾选“动画”，双击输入框可选择tag变量. （注：第一次配置时可能出现iCV变量选择界面，这时需要点击界面右上角的“切换数据源”按钮，可进入实时数据库变量选择界面如下）

再“确定”，“保存”。

完成画面编辑后，将保存的画面在组态配置客户端签入，然后部署到iHD-HMI客户端，在客户端就可以运行组态画面了。


数据分析

Navigation: 功能明细 >

数据分析

 Return to chapter overview

数据分析与处理主要介绍了如何对采集上来的实时数据进行分析与处理。

·统计与计算

·报警

·SPC报警

©2015. All Rights Reserved.


统计与计算

Navigation: 功能明细 > 数据分析 >

统计与计算

 Return to chapter overview

参考 计算点 和 统计点 的说明。


报警

Navigation: 功能明细 > 数据分析 >

报警

 Return to chapter overview

报警子系统介绍：

报警子系统可以为根据配置好的报警条件产生报警记录，并将报警记录发送到报警客户端进行展示，监控人员根据报警展示进行相应的操作。整个报警子系统分为服务端的报警服务和客户端的报警点管理、报警组管理以及报警记录展示。其中报警点通过Excel插件进行管理和展示，报警组通过配置管理工具的报警组管理模块进行管理和展示，报警记录展示客户端进行报警记录的管理和展示。

本章节内容如下：

§报警点管理

§报警组管理

§报警查看

§报警服务

§报警案例

·系统管理工具中的报警：

系统管理工具中的报警模块，仅仅包括报警组的管理，如果需要实现报警的功能，需要的基本步骤主要包括：数据源配置->数据采集配置->事件报警才能实现，请参考相关章节。

报警组管理系统主要功能包括如下方面：

§显示所有报警组和某个报警组内的报警点信息

§向服务器添加一个报警组

§从服务器中删除一个报警组

§移动报警组位置

§移动一个或多个报警点的位置

©2015. All Rights Reserved.


报警点管理

Navigation: 功能明细 > 数据分析 > 报警 >

报警点管理

 Return to chapter overview

《报警点管理》主要介绍报警点的属性以及如何通过Excel插件管理报警点。

本节内容包括：

§创建报警点

§报警点属性

·创建报警点

参见报警点。

?Tag属性“报警”页面中的监测点是报警的数据来源，监测点可以选择普通点、计算点、统计点，选择好保存以后不可修改。

值死区支持float类型，正数，长度不能超过15位。值死区只针对GT和LT类型的报警，例如：值死区配置为1，条件为GT（10），则当值大于11时触发报警，报警后值小于9时恢复。

时间死区的值为int类型，正整数，长度不能超过9位；时间死区针对所有报警，单位为ms，只有当报警或者恢复时间超过死区时间，报警或恢复才会发生。

·报警点特有的属性

属性 | 中文名 | 类型 | 默认值 | 是否允许修改 | 是否允许为空 | 描述
TEST1 | 条件1 | string |  | 是 | 是 | TEST1与ACTION1对应，必须同时添加或者修改
TEST2 | 条件2 | string |  | 是 | 是 | TEST2与ACTION2对应，必须同时添加或者修改
TEST3 | 条件3 | string |  | 是 | 是 | TEST3与ACTION3对应，必须同时添加或者修改
TEST4 | 条件4 | string |  | 是 | 是 | TEST4与ACTION4对应，必须同时添加或者修改
ACTION1 | 事件1 | string |  | 是 | 是 | ACTION1与TEST1对应，必须同时添加或者修改
ACTION2 | 事件2 | string |  | 是 | 是 | ACTION2与TEST2对应，必须同时添加或者修改
ACTION3 | 事件3 | string |  | 是 | 是 | ACTION3与TEST3对应，必须同时添加或者修改
ACTION4 | 事件4 | string |  | 是 | 是 | ACTION4与TEST4对应，必须同时添加或者修改
SourceTagName | 监测点 | string |  | 是 | 是 | 被报警点监测的Tag点名称
AlarmGroupID | 报警组ID | uint32 |  | 是 | 是 | 报警点所属的组ID
AutoAck | 自动确认状态 | uint8 | 0 | 是 | 是 | 是否自动确认，默认为否。0表示否，1表示是。
ValueDeadBand | 值死区 | float | 0.0 | 是 | 否 | 只针对GT和LT类型的报警，如值死区配置为1条件为GT(10)当值大于11时报警，报警后值小于9时恢复
TimeDeadBand | 时间死区 | int32 | 0 | 是 | 否 | 针对所有的报警，单位为毫秒，只有报警或恢复持续的时间超过死区时间，报警或恢复才会发生

条件”属性与“事件”属性成对使用，前者是报警产生的条件，后者是产生的报警结果。

报警条件 | 描述 | 监测点类型 | 举例
GT | 大于 | 数值型 | GT(10)
LT | 小于 | 数值型 | LT(10)
EQ | 等于 | 数值型、string | EQ(10) EQ("string")
NE | 不等于 | 数值型、string | NE(10) NE("string")
IS_IN | 在某一区间内 | 数值型 | IS_IN（-10,10）
NOT_IN | 不在某一区间内 | 数值型 | NOT_IN（-10,10)

“事件”属性对应于满足“条件”后产生的事件，为digitalset里面的一个状态，由"优先级_报警类型_确认状态"组成，比如1_low_unack,其中1为表示报警优先级为1；low表示报警类型为low；unack表示报警记录的确认状态为未确认。

优先级

优先级 | 描述
1 | 重要性最低
2 |
3 |
4 | 重要性最高

报警类型

报警类型 | 描述
hihi | 高高报警，一般超过报警上上限产生该报警
high | 高报警，一般超过报警上限产生该报警
low | 低报警，一般低于低报警下限产生该报警
lolo | 低低报警，一般低于下下限产生该报警
change | 变化报警，一般值不等于设定值时会产生该报警

确认状态

确认状态 | 描述
ack | 报警已确认
unack | 报警未确认


报警组管理

Navigation: 功能明细 > 数据分析 > 报警 >

报警组管理

 Return to chapter overview

报警组管理系统是iHyperDB系统管理平台中的一个应用，用来配置各个服务器中的报警组和报警点相关信息。

请注意：本节（即系统管理中的报警）只涉及介绍报警组管理，要查看实时数据产生的报警，请使用“报警查看”工具。

要想在系统管理工具中实现报警组的功能，请确保：

1.连接上了“服务器连接管理器”中的服务是连接状态，具体请参考： 连接管理

2.“报警服务”的开启，具体请参考：报警服务，否则可能出现连不上报警服务的情况。

本节内容主要包括：

§查看报警组

§添加一个报警组

§删除一个报警组

§移动报警组位置

§显示报警组及报警组内报警点

从开始菜单进入“系统管理工具”，双击"报警组管理",可以看到下图,此时说明,报警组管理的功能正常启动:

·添加一个报警组

在“报警组”管理页面，在空白处单击右键

选择“新建报警组”，弹出“新建报警组”对话框，填写报警组名和描述

新的报警组就在报警组下被创建

在新建的报警组“test”下仍然可以建立新的报警组，如下图

·删除一个报警组

右键单击一个报警组，弹出报警组的功能选择菜单

选择“删除报警组”，弹出确认删除对话框

单击确认后该报警组被删除，树形结构中该报警组也不再显示该报警组

1.有子组的报警组不可以删除

2.其下有报警点的报警组不可以删除

3.“未分组”不可以删除

4.服务器不可以删除

·移动报警组位置

右键单击一个报警组，弹出报警组的功能选择菜单，

选择“移动报警组”，弹出移动选择对话框

在移动选择对话框中，显示了当前所有的报警组，从其中选择一个组作为移动的目标组，

单击确认后，移动选择对话框关闭，之前选中的报警组及其子组会被移动至该组下

1.“未分组”不可以被移动

2.服务器不可以被移动

3.不可以跨服务器移动

4.父组不可以向其子组移动

§为报警点选择一个分组

首先，根据上面的步骤创建好报警分组，接着双击“未分组”，如果之前没有对报警点进行过分组，那么报警点都在“未分组”中，双击“未分组”就可以看到全部的报警点。

§移动一个或多个报警点的位置

选择一个或者多个报警点，右键弹出报警点的功能选择菜单，选择“移动报警点”，弹出移动选择对话框。在移动选择对话框中，显示了当前所有的报警组，从其中选择一个组作为移动的目标组，单击确认后，移动选择对话框关闭，之前选中的报警点会被移动至该组下。

注意：

1.报警点不可以向某个服务器移动

2.不可以跨服务器移动

3.不可以向所在的报警组本身移动

·显示报警组及报警组内报警点

在iHyperDB系统管理平台中双击任务面板中的报警组管理选项，会在平台的右边显示区载入报警组管理界面。

在报警组管理界面的左侧以树形结构显示当前已连接的服务器及其下的报警组。

双击一个报警组，报警组管理界面的右侧区域显示该报警组下的所有报警点的名字和描述。


报警服务

Navigation: 功能明细 > 数据分析 > 报警 >

报警服务

 Return to chapter overview

报警服务部署在服务端，为报警系统提供报警服务。

1.报警点对应的数据点如果开启了压缩，可能导致报警记录对应的源值和实际数据对应的源值有细微差别，也可能最近的历史报警没有对应的原值。这是开启有损压缩的结果，属于正常现象。

2.如果报警的服务重启，实时记录对应的原值，可能显示在AlarmView中为空。

需要注意：

报警服务需要在hdNetMgr.exe和hdKernel.exe运行后再启动。


报警案例

Navigation: 功能明细 > 数据分析 > 报警 >

报警案例

 Return to chapter overview

案例: 本案例将创建一个报警点（名称为Digital）,该报警点将用来监测普通点（名称为DATA），当DATA的当前记录值超过100时产生高高报警，当DATA的当前记录值低于15时产生低报警。

要产生报警需要经过一下配置：

1. 采集器的配置：

§采集器的配置步骤

采集器、设备的配置在“采集器配置工具”中完成，可参考数据采集器OPC配置案例。

首先，从“系统管理平台->采集器配置”添加好采集器、设备、扫描组，然后，在采集器配置工具中，选择一个采集器作为本地采集器即可。

本例中，采集器将以“OPC”命名，设备名为opc模拟器的“Matrikon.OPC.Simulation”，扫描组以"Demo"命名。

上传到iHyperDB服务器的采集器、扫描组和设备信息将在采集Tag点的配置页面中使用。

2. Tag点配置：

普通点配置：一个普通点的配置主要包括基本属性的配置、采集器的配置以及设备的配置。

§普通点的配置步骤

在“iHyperDB系统管理工具”中连接服务器，然后，在系统管理平台中选择“数据源”中的“Tag变量配置”，

新增普通Tag点DATA，类别为“普通点”，类型选择int8

普通点的数据需要通过采集器采集，因此需要配置采集页面，其中设备名为MatrikonOPC.Simulation，扫描组为AlarmScanner，设备点由设备决定

点击确定，新增普通Tag点DATA成功。

为保证在“采集器名”、“设备名”和“扫描组”下拉框中找到已经配置的设备，请确保事先已设置好的相应的配置已经保存。

报警点配置：一个报警点的配置主要包括“基本属性”的配置、“判断条件和报警条件”的配置以及“监测点”的配置。

§报警点的配置步骤

在系统管理平台中选择“数据源”中的“数据源配置”，

新增报警Tag点Digital，类别为“报警点”，类型不可选为digital

报警点需要通过监测普通点而产生报警，因此需要配置报警页面，其中“判断条件和报警事件”需要填写，

点击确定，新增报警Tag点Digital成功。

请注意，报警点的“监测点”是必须填写的，且被监测的点必须是普通点，本例中填写已经创建的普通点DATA。

3. 报警组管理：报警点的默认分组为“未分组”，也可以新建报警组，将报警点移动到新的报警组，本例中将默认到“未分组

”组。可参考 报警组管理

4. 事件报警显示：报警的显示查看工具为“报警查看”

§使用“报警查看”工具查看报警

此时当有报警来时，会在“报警查看”页面的“实时报警”中显示，已经确认的报警将在历史报警中显示，如下图

高高报警：


CS SPC报警点管理

SPC报警点管理

Navigation: 功能明细 > 数据分析 >

SPC报警点管理

 Return to chapter overview

SPC报警点管理主要介绍SPC报警点的属性以及如何创建、修改、删除SPC报警点。其中，SPC报警点配置有两个入口，分别是

1.数据源→Tag变量配置→添加SPC报警点

2.报警→SPC报警点，管理配置SPC报警点

SPC报警点的记录可以通过报警客户端查看。


数据转储

Navigation: 功能明细 >

数据转储

 Return to chapter overview

本章介绍了存储引擎数据转储。

其中：

《存储引擎》中主要介绍了系统的配置文件，数据源属性以及支持的数据类型；

《数据转储》介绍了将实时数据库数据转储到关系数据库的功能，包含支持的转储方式、转储规则的配置等内容。

主要内容包括：

·存储引擎

·数据转储

©2015. All Rights Reserved.


存储引擎

Navigation: 功能明细 > 数据转储 >

存储引擎

 Return to chapter overview

本章节主要内容包括:

§支持的数据类型

§数据源属性

©2015. All Rights Reserved.


支持的数据类型

Navigation: 功能明细 > 数据转储 > 存储引擎 >

支持的数据类型

 Return to chapter overview

支持的数据类型：

·int8 : 单字节长度的整型

·int16 : 双字节长度的整型

·int32 : 4个字节长度的整型

·float32 : 32位浮点数据

·float64 : 64位浮点数据

·digital : 数字量

·string : 字符串

·blob : 二进制数据

©2015. All Rights Reserved.


数据源属性

Navigation: 功能明细 > 数据转储 > 存储引擎 >

数据源属性

 Return to chapter overview

数据源属性列表：

数据项 | 数据项名称 | 解释 | 类型 | 默认值 | 必填项 | 查询操作方式 | 可修改项 | 取值范围 | 备注
Archiving | 归档状态 | 表明该tag点数据是否需要归档，为1表示需要，为0表示不需要 | bool | true | 否 | = <> | 是 | true或false |
OpcState | OPCServer发布状态 | 是否允许该点发布到HDOPCServer | bool | false | 否 | = <> | 是 | true或false |
CompDev | 压缩误差 | 压缩误差，一般为设备可以检测到的最小量程 | float | 0 | 否 | = <> > < >= <= | 是 | >=0 | 在同CompDevPercent一起使用的时候，后者的优先权要高。为0表示不启用
CompMaxTime | 压缩超时 | 以秒数为单位的最大时间，无论压缩结果如何，超出前一条CompMax秒的记录将被归档 | int32 | 28800 | 否 | = <> > < >= <= | 是 | =0且=CompMin | 为零时表示不启用本属性，通常设定为28800秒，也就是8个小时.CompMax和CompMin必须同时添加和修改
CompMin | 压缩时间精度 | 以秒数为单位的最小时间，无论压缩结果如何，未超过前一条CompMin秒的记录不会被归档 | int16 | 0 | 否 | = <> > < >= <= | 是 | =0 | 为零时表示不启用本属性,与前一条记录间隔时间在(CompMin，CompMax)区间的记录根据压缩结果决定是否归档。CompMax和CompMin必须同时添加和修改
CompType | 压缩类型 | 采用的压缩方法，0为不压缩 | uint8 | 0 | 否 | = <> | 是 | 0-COMP_TYPE_MAX | 当tagtype为string,blob,digital是只能为不压缩
ChangeDate | Tag修改日期 | tag最近一次的修改日期 | date | 系统自动生成 | 否 | = <> > < >= <= | 否 |  |
Changer | Tag修改者 | tag最近一次的修改者 | varchar | 系统自动生成 | 否 | = like | 否 |  | 最大长度为HD_LEN_USER_NAME，包括\0
CreationDate | Tag创建日期 | tag的创建日期 | data | 系统自动生成 | 否 | = <> > < >= <= | 否 |  |
Creator | Tag创建者 | tag的创建者 | varchar | 系统自动生成 | 否 | = <> like | 否 | 最大长度为HD_LEN_USER_NAME，包括\0 |
Descriptor | Tag描述 | 该点的描述 | varchar |  | 否 | = <> like | 是 | 最大长度为EC_HD_API_INVALID _TAG_DESC，包括\0 |
DigitalSet | 数字量集 | 数字量点所对应的数字状态集合的ID，必须设定，否则该数字类型点无法导入数据库，所以必须事先建立状态集合 | varchar | 必须先创建好 | 否 | = <> like | 是 |  | DigitalStateSet表中的状态集名
EngUnits | 工程单位 | 工程量单位 | varchar | 空 | 否 | = <> like | 是 |  |
ExcMax | 报警上限 | 记录值超过此属性设置的值时会有异常报告 | float | 0 | 否 | = <> > < >= <= | 是 | =0且=ExcMin | ExcMax与ExcMin必须同时添加和修改
ExcMin | 报警下限 | 记录值小于此属性设置的值时会有异常报告 | float | 0 | 否 | = <> > < >= <= | 是 | 0 | ExcMax与ExcMin必须同时添加和修改
InstrumentPoint | 设备点名 | 对应的设备点名称，同时根据接口机类型的不同，具有不同的用法，在OPC接口机中用来跟DCS的设备点建立映射关系 | varchar | 空 | 否 | = <> like | 是 |  | 不填写该字段，则无法采集数据
InterfaceName | 采集接口名 | 用来跟接口机的标识符进行映射，两者要相同，才表示该点属于该接口机所需要采集的点 | varchar | 空 | 否 | = <> like | 是 |  | 不填写该字段，则无法采集数据
RecAccess | 记录访问权限 | 控制记录级别的权限，如o:rw g:r w:r，其中o表示owner，g表示group，w表示world，冒号后的r表示可读，w表示可写 | uint8 | o:rw g:rw w:rw | 否 | = <> | 是 |  |
RecGroup | 记录权限组 | 表示该点的数值属于哪个用户组 | varchar | admin | 否 | = <> like | 是 |  |
RecOwner | 记录所有者 | 表示该点的数值属于哪个owner所拥有 | varchar | admin | 否 | = <> like | 是 |  |
Scan | 扫描状态 | 设定该点是否被接口机轮询标志 | bool | true | 否 | = <> | 是 | true或false | 设定为1表示会被轮询，设定为0表示不被轮询
ScanPeriod | 扫描周期 | 扫描周期，本次采集和下一次采集的间隔时间 | int32 | 5000 | 否 | = <> > < >= <= | 是 | >0 | 单位为毫秒
ScanPhase | 扫描相位 | 扫描相位 | int32 | -1 | 否 | = <> > < >= <= | 是 |  | 单位为毫秒，相对于子夜0:00的偏移量，-1表示由采集接口自主决定，可以动态平衡采集负荷
Span | 记录取值范围 | 设定为该点值的跨度 | >float | 0 | 否 | = <> > < >= <= | 是 | >=0 | 为零表示不启用
TagAccess | Tag访问权限 | 用来控制Tag配置级别的权限,如o:rw g:r w:r，其中o表示owner，g表示group，w表示world，冒号后的r表示可读，w表示可写 | uint8 | o:rw g:rw w:rw | 否 | = <> | 是 |  |
TagGroup | Tag权限组 | 控制Tag配置级别对应的group | varchar | admin | 否 | = <> like | 是 |  |
Tag ID | Tag ID | 数据源的ID，一个数据源只有唯一一个ID | uint32 | 系统自动生成 | 否 | = <> > < >= <= | 否 | >0 |
TagName | Tag名称 | 数据源名称，在数据库内唯一 | varchar(128) | 无 | 是 | = <> like | 否 |  | 最多127个英文字符，63个中文字符
TagOwner | Tag所有者 | 控制点配置级别对应属于的owner | varchar | admin | 否 | = <> like | 是 |  |
TagType | Tag类型 | 数据类型，所有DI点类型为digital，所有AI点类型为float32 | uint8 | 无 | 是 | <> | 否 | 0-TAG_TYPE_MAX |
Param1 | 保留参数1 | 保留字段 | unit8 | 0 | 否 | = <> > < >= <= | 是 |  |
Param2 | 保留参数2 | 保留字段 | unit8 | 0 | 否 | = <> > < >= <= | 是 |  |
Param3 | 保留参数3 | 保留字段 | unit8 | 0 | 否 | = <> > < >= <= | 是 |  |
Param4 | 保留参数4 | 保留字段 | unit8 | 0 | 否 | = <> > < >= <= | 是 |  |
Param5 | 保留参数5 | 保留字段 | unit8 | 0 | 否 | = <> > < >= <= | 是 |  |


数据转储（到关系数据库）

Navigation: 功能明细 > 数据转储 >

数据转储（到关系数据库）

 Return to chapter overview

数据转储的作用是将iHyperDB中存储的记录数据转储到关系数据库中（Relational Database，RDB），便于利用关系数据库的数据关联性分析，提供有效的数据分析和统计，实现数据的有效利用和价值利用。

转储服务支持SQLServer2005及以上，MySQL5.5及以上，Oracle10g及以上版本的关系数据库。

转储服务支持SQLServer版本2005及以上，MySQL版本5.5及以上，Oracle版本10g及以上，DB2版本6.x及以上的关系数据库。其中脚本转储暂未支持DB2数据库。

数据转储需要对转储服务所在操作系统进行必要的环境配置（包括Python2.7环境配置和关系数据库客户端配置），详细内容见转储环境配置。

·iHyperDB转储将关系数据库中存储数据的表分为两种类型，窄表和宽表：

§窄表指该表的一行数据只包含一个Tag点的一条记录。

§宽表指该表的一行数据可以包含多个相关Tag点的记录。

·界面配置实时数据库转储到关系数据库时，支持以下多种方式：

§数值以及字符串类型普通点、统计点、计算点记录原始值转储。

§数值以及字符串类型普通点、统计点、计算点记录插值转储，插值模式有：前值插值、 线性插值（注意字符串类型的普通点记录的线性插值得到的数据与前值插值得到的数据相同。对字符串的精确插值无意义)。

§报警记录原始值转储。

脚本配置实时数据库转储到关系数据库时，支持以下多种方式：

§普通点、统计点、计算点记录线性插值模式数据转储。

§普通点、统计点、计算点记录指定插值模式数据转储（对每个Tag点指定插值模式，插值模式有：前值插值、线性插值）。

§报警点记录原始值数据转储。

转储服务不是实时数据的转储，它转储的数据和iHyperDB系统管理平台上看到的数据具有一定的延迟。

本章节主要内容包括：

§转储环境配置

§转储的概念与要求

§关系数据库连接配置

§表映射配置

§规则配置

§脚本配置转储

©2015. All Rights Reserved.


转储环境配置

Navigation: 功能明细 > 数据转储 > 数据转储（到关系数据库） >

转储环境配置

 Return to chapter overview

《转储环境配置》主要介绍在转储之前对转储环境的配置：

1. Python环境配置：

预先安装python2.7，并检查环境变量PYTHONHOME的路径是否正确。如果64位的iHyperDB客户端，注意需要64位的Python环境。

转储服务运行错误ImportError：No Module name sited，表示无法找到可用的python环境，请检查本地Python环境是否正确。

2. 配置转储数据到其他数据库：如果转储记录中含有中文内容，关系数据库编码格式须支持中文，例如对于MySQL，建议安装时指定编码格式为UTF-8。转储到不同关系数据库要对iHyperDB转储服务所在的系统进行不同的环境配置。

·SQLServer：不需要特殊配置。

·PostgreSQL：需安装VC2013运行库。

·MySQL：推荐两种方式：

a. 将对应MySQL服务端安装目录下的lib/libmysql.dll拷贝到客户端executable 目录下即可；

b. 若本机安装了该版本的MySQL，将本机MySQL安装路径添加至环境变量path中即可。

·Oracle：转储服务所在机器需要配置Oracle客户端。下面给出一种推荐的方式：

a.从Oracle官方网站下载InstantClient压缩包，将压缩包中的DLL文件、可执行文件等全部解压到转储客户端所在的机器上，比如“D:\instantclient_11_2”;

b.在“D:\instantclient_11_2”目录下创建tnsnames.ora文本文件，从Oracle服务端的tnsnames.ora文本文件中拷贝需要用到的dsn（DataSourceName，数据源名称）；

c. 将该InstantClient解压目录D:\instantclient_11_2添加到环境变量path中；

d. 创建环境变量 name：TNS_ADMIN，value：D:\instantclient_11_2;

e. 创建环境变量 name：NLS_LANG， value:AMERICAN_AMERICA.ZHS16GBK;

对于Oracle数据库，可用第三方客户端查看能否正确连接改数据库。

·DB2：转储服务所在机器需要配置DB2客户端。下面给出一种推荐的方式：

a.安装DB2运行时客户机；

b.节点编目

运行命令行窗口（winxp以上需要管理员权限），运行db2cmd db2 catalog tcpip node node_name remote server_ip server server_port

其中

node_name：所要编目的节点名，即服务器内的实例名。实例名在一台机器上必须是惟一的，可输入纯字母或字母与数字的组合，字母不区分大小写。注意实例名不能命名为"DB2"，且不支持特殊字符。

server_ip：所要编目的服务器的IP地址。

server_port：所要编目的服务器的端口号，默认为50000。

c.数据库编目

运行命令行窗口（winxp以上需要管理员权限），运行db2cmd db2 catalog db db_name as db_alias at node node_name

其中

db_name：要编目的数据库名称

db_alias：数据库编目到客户端所用的别名

node_name：所要编目的数据库所在的节点名称。

注意：

在转储报警记录中，我们的推荐字段涵盖了报警记录的16个属性，总长度最长上限为4300字节左右。而DB2数据库的创建配置中，默认配置“表空间”大小为4K，其对应的表行长度上限为4005字节。因此，实施人员需要从下面解决方法中选择一个：

1、转储新建表字段长度总和少于4000，例如将报警注释、原始点源值的字段长度合理变小；

创建新的DB2数据库，在创建DB2表空间时，不推荐使用默认表空间大小，而使用8K（对应8101字节）或8K以上的大小。

关系数据库客户端环境配置完成后，可以通过系统管理平台验证配置是否正确。验证方式：打开实时数据库系统管理平台，进入数据转储--关系数据库，点击“添加连接”按钮，在弹出的输入框中正确输入关系数据库信息，点击测试连接。如果弹出连接成功消息，则环境配置正确。

例如，测试连接MySQL数据库：

未配置Oracle客户端情况下直接测试连接Oracle：

·GBase：转储服务所在机器需要安装ODBC驱动。下面给出一种推荐的方式：

a.安装ODBC；安装ODBC，解压zip包，生成的gbase8s-odbc-driver放置于D:\目录下。

在我的电脑->系统属性->高级->环境变量 中，增加环境变量GBASEDBTDIR 指向D:\gbase8s-odbc-driver，Path中增加%GBASEDBTDIR%\bin;（路径按照实际存放位置填写）

使用管理员权限运行00注册ODBC_管理员权限运行.cmd

b.配置ODBC，64位系统打开C:\Windows\System32\odbcad32.exe，点击添加，选择GBase ODBC DRIVER。

配置数据源名称，也是GBase ODBC的名称

配置连接信息，包括服务器名字，地址，端口，数据库名称（schema），用户ID,密码等。

点击应用并测试连接，连接上数据库表示ODBC驱动安装完成。


转储的概念与要求

Navigation: 功能明细 > 数据转储 > 数据转储（到关系数据库） >

转储的概念与要求

 Return to chapter overview

·关系数据库连接名称：

关系数据库连接名称由用户在添加关系数据库连接时自行指定，用于惟一识别该连接，因此不得与已有连接名同名。

关系数据库连接名不得为空，最大长度64字节。

·关系数据库名、地址、端口号（MySQL,SQLServer)：

请参阅关系数据库相关文档。

关系数据库名不得为空，最大长度64字节。

关系数据库地址不得为空，最大长度256字节。

关系数据库端口号：不得为空，如果使用默认端口号，输入-1；否则输入合法端口号，范围：[0, 65535]。

·数据源名称（Oracle，DB2）：

Oracle数据库的数据源，可从Oracle服务端的tnsnames.ora文件中获得。

DB2数据库的数据源，若为本地数据库，其为数据库名称；若为远程数据库，其为DB2数据库编目到客户端所用的别名。

数据源名称不可为空，最大长度64字节。

·关系数据库用户名：

系统管理平台配置转储，需要对关系数据库表进行创建、修改、删除操作；转储服务执行时，需要向关系数据库中插入记录；脚本转储时可能也需要对关系数据库表进行创建、修改、删除操作（视脚本中具体执行的SQL语句而定）。在配置关系数据库连接时，需要使用具有足够权限的关系数据库用户名。

关系数据库用户名不得为空，最大长度512字节。

·关系数据库密码：

关系数据库密码最大长度256，可为空。

·关系数据库表名：

转储服务要求关系数据库表名不得含有中文，不得含有空格，不得为空，最大长度256字节。

·关系数据库字段：

关系数据库字段名不得包含中文，不得包含空格，不得为空，最大长度256字节。为字符型时，允许输入最多十位数字。

·表映射：

我们使用表映射这一名词来表示转储规则与关系数据库中的表的对应关系，其保存了转储数据类型、存储数据方式等信息。

表别名（表映射名）不得为空，最大长度256字节。

·规则名：

我们使用规则名来代表一个转储规则。规则名不得为空，最大长度63字节。

·记录起始时间：

要转储的记录的时间戳的最小值（包含该时间），对应于非报警点的时间戳和报警点的开始时间。记录起始时间不得小于“1970/01/01 00:00:00”，不得大于“2038/01/19 03:14:06”。

·记录间隔时间：

要转储的插值记录的插值间隔，即间隔多长时间取一条插值数据，不得大于8760时59分59秒。

·记录结束时间：

要转储的记录的时间戳的最大值（包含该时间），对应于非报警点的时间戳和报警点的开始时间。记录结束时间不得小于“1970/01/01 00:00:00”，不得大于“2038/01/19 03:14:06”。

·执行起始时间：

转储定时任务（转储规则）首次执行的时间。执行起始时间不得小于“1970/01/01 00:00:00”，不得大于“2038/01/19 03:14:06”。

·执行间隔时间：

转储定时任务调度周期，即最短间隔多久再次执行该转换任务，不得大于8760时59分59秒。

·窄表、宽表：

iHyperDB中的数据分为普通点记录、统计点记录、计算点记录、报警点记录，存储这些记录需要特定的关系数据库表。我们将关系数据库中的表分为两种类型：窄表和宽表。

窄表：该表的一行数据只包含一个Tag点的一条记录。

宽表：该表的一行数据包含一条或一条以上Tag点记录。

宽表转储支持多个表映射关联到同一张数据库表。

对于普通点记录、统计点记录和计算点记录，其既可以以窄表方式存储于关系数据库，也可以以宽表方式存储于关系数据库。

存储为窄表时，数据方式如下图：

存储为宽表时，数据方式如下图：

对于报警点记录，其只能以窄表方式存储于关系数据库中。数据方式如下图：

·普通点、计算点、统计点记录字段设置：

客户端添加表映射--创建表时，点击添加推荐字段，可以获取系统推荐的字段。

1. 存储方式为窄表

我们将这些类别的Tag点的记录的项目分为两个部分，基本项为必须转储的信息；可选项为用户自行决定是否转储的信息。

具体限制如下表：

 | 名称 | 占用空间 | 表字段类型要求 | 说明 | 客户端配置限制
基本项 | Tag点名 | char[128] | 最大长度不小于128的字符型 | 若报警点名中存在中文，需要支持中文的关系数据库，此时建议为“ 最大长度不小于384（3*128）的字符型” | 最大长度不小于128的字符型
 | 时间戳 | HDTime(nSec,nMsec) | 最大长度不小于23的字符串 | 精确到毫秒的时间记录，格式为”YYYY-MM-DD HH:MM:SS MMM” | 最大长度不小于23的字符型
 | 数据值 | int8 | 兼容32位整型的数值型或最大长度不小于12的字符型 | 用户保证字段类型正确 | 未限制
 |  | int16 | 兼容32位整型的数值型或最大长度不小于12的字符型 | 用户保证字段类型正确 | 未限制
 |  | int32 | 兼容32位整型的数值型或最大长度不小于12的字符型 | 用户保证字段类型正确 | 未限制
 |  | float32 | 双精度浮点型或最大长度不小于40的字符型 | 用户保证字段类型正确 | 未限制
 |  | float64 | 双精度浮点型或最大长度不小于40的字符型 | 用户保证字段类型正确 | 未限制
 |  | digital | 同int8 | 用户保证字段类型正确 | 未限制
 |  | string | 最大长度不小于1000的字符型 | 用户保证字段类型正确 | 未限制
可选项 | 数据质量 | uint16 | Uint16整型、浮点型或最大长度不小于5的字符型 |  | Uint16整型、浮点型或最大长度不小于5的字符型

2. 存储方式为宽表

由于不同记录的时间戳不同，存储为宽表时需要取Tag点的插值记录。关系数据库表的字段必须和Tag点进行对应。具体说来，如果转储一个Tag点的数据值，则必须有字段符合该Tag点数据值的要求。存储为宽表时，记录信息中Tag点名、时间戳、数据值、数据质量的字段类型限制与存储为窄表时相同。

注: 时间戳字段测试支持下列字段.

oracle :timestamp

sqlserver: datetime

mysql: datetime

postgresql: timestamp without time zone

db2:timestamp

·报警点记录字段设置：

如果转储报警点记录到关系数据库中，则只能转储为窄表。我们将报警点记录的项目分为两个部分，基本项为必须转储的信息；可选项为用户自行决定是否转储的信息。

具体限制如下表：

 | 名称 | 占用空间 | 表字段类型要求 | 说明 | 客户端配置限制
基本项 | 报警点名 | char[128] | 最大长度不小于128的字符型 | 若报警点名中存在中文，需要支持中文的关系数据库，此时建议为“ 最大长度不小于384（3*128）的字符串” | 最大长度不小于128的字符型
 | 开始时间 | HDTime(nSec,nMsec) | 最大长度不小于23的字符型 | 精确到毫秒的时间记录，格式为”YYYY-MM-DD HH:MM:SS MMM” | 最大长度不小于23的字符型
可选项 | 结束时间 | HDTime(nSec,nMsec) | 最大长度不小于23的字符型 | 精确到毫秒的时间记录，格式为”YYYY-MM-DD HH:MM:SS MMM” | 最大长度不小于23的字符型
 | 报警优先级 | uint8 | 整型或最大长度不小于3的字符型 |  | 整型或最大长度不小于3的字符型
 | 源值 | char[1000] | 视被监视Tag点的数据值而定 | 用户保证字段类型正确。建议为“最大长度不小于1000的字符型” | 未限制
 | 报警条件 | char[128] | 最大长度不小于128的字符型 |  | 最大长度不小于128的字符型
 | 是否确认 | uint8 | 整型或最大长度不小于3的字符型 |  | 整型或最大长度不小于3的字符型
 | 报警类型 | uint8 | 整型或最大长度不小于3的字符型 |  | 整型或最大长度不小于3的字符型
 | 源点名 | char[128] | 最大长度不小于128的字符型 | 若源点名中存在中文，需要支持中文的关系数据库，此时建议为“ 最大长度不小于384（3*128）的字符串” | 最大长度不小于128的字符型
 | 是否恢复 | uint8 | 整型或最大长度不小于3的字符型 |  | 整型或最大长度不小于3的字符型
 | 确认类型 | uint8 | 整型或最大长度不小于3的字符型 |  | 整型或最大长度不小于3的字符型
 | 确认时间 | HDTime(nSec,nMsec) | 最大长度不小于23的字符型 | 精确到毫秒的时间记录，格式为”YYYY-MM-DD HH:MM:SS MMM” | 最大长度不小于23的字符型
 | 确认者 | char[32] | 最大长度不小于32的字符型 | 若确认者名称中存在中文，需要支持中文的关系数据库，此时建议为“ 最大长度不小于384（3*128）的字符型” | 最大长度不小于32的字符型
 | 注释 | char[1000] | 最大长度不小于256的字符型 | 若注释中存在中文，需要支持中文的关系数据库，此时建议为“ 最大长度不小于768（3*256）的字符型” | 最大长度不小于256的字符型
 | 注释时间 | HDTime(nSec,nMsec) | 最大长度不小于23的字符型 | 精确到毫秒的时间记录，格式为”YYYY-MM-DD HH:MM:SS MMM” | 最大长度不小于23的字符型
 | 注释者 | char[32] | 最大长度不小于32的字符型 |  | 最大长度不小于32的字符型


关系数据库连接配置

Navigation: 功能明细 > 数据转储 > 数据转储（到关系数据库） >

关系数据库连接配置

 Return to chapter overview

转储服务支持Oracle、PostgreSQL、MySQL和SQLServer数据库。配置关系数据库连接前，请参阅“转储环境配置”章节，确认已进行关系数据库客户端设置。

本章节主要内容包括：

· 配置转储参数

· 查看连接

· 修改连接

· 删除连接

· 启动“转储到关系数据库”进程

· 导入/导出转储配置

·配置转储参数

在系统管理平台中打开任务面板中点击 数据转储 -> 关系数据库，打开转储配置界面。

点击添加连接按钮，将弹出“添加关系数据库连接”窗口：

选择数据库类型，根据数据库类型输入对应的连接信息。输入完成后可点击“测试连接”按钮测试是否能够连接。

单击确定以完成添加。

·查看连接

系统管理平台-->数据转储-->关系数据库转储页面，单击关系数据库树中的连接名，在右边显示数据库连接信息。

·修改连接

查看连接信息页面，单击信息框中的“修改连接”按钮，进入修改关系数据库连接参数页面。

输入新的连接信息，单击确定完成修改。

注意事项:

1、关系数据库连接名称用来识别该连接，不得与已有关系数据库重名；

2、对于Oracle数据库，新的数据源名称不得与已添加的其它Oracle数据库连接的数据源名称相同；

3、对于DB2数据库，新的数据源名称不得与已添加的其它DB2数据库连接的数据源名称相同；

4、对于MySQL、SQLServer数据库，新的连接信息中的【“数据库名”+“数据库地址”+“数据库端口”】不得与已添加的其它相同类型数据库连接的信息相同。也就是说，由数据库名+数据库地址+数据库端口组成的MySQL、SQLServer数据源惟一。

5、对于MySQL客户端，在某些情况下使用0端口也能正常连接MySQL数据库。我们建议不使用0端口，使用-1（默认端口，实际为3306）连接MySQL数据库。

·删除连接

系统管理平台--数据转储--关系数据库页面，选中要删除的连接，单击“删除连接”按钮，弹出提示框。

确定后，删除该关系数据库连接。

删除关系数据库连接操作将删除该关系数据库下所有的表映射、转储规则，请谨慎操作。

·启动“转储到关系数据库”进程

在系统管理工具中，点击数据转储中的关系数据库，弹出如下界面，点击界面下方的“启动服务”。

弹出该工具，界面如下：

操作说明：

v安装——将所管理的文件装成服务。

v卸载——将已安装的服务卸载。

v启动——如果已安装成服务则启动服务；如果没安装成服务则启动进程。

v停止——如果已安装成服务则停止服务；如果没安装成服务则停止进程。

v刷新——重新获取服务的状态。

状态显示：

该工具根据服务和进程的状态，会显示4种状态：

v1.服务未安装

v2.服务-已停止

表示已安装成服务，但是未启动。

v3. 服务-正在运行

v4. 进程-正在运行


导入/导出转储配置

Navigation: 功能明细 > 数据转储 > 数据转储（到关系数据库） > 关系数据库连接配置 >

导入/导出转储配置

 Return to chapter overview

关系数据库连接配置支持配置信息“导入/导出”管理。

1.导出配置到Excel文件

步骤

1.系统管理平台->数据转储->关系数据库->导出

2.选择导出Excel文件的存储位置和文件名

3.导出成功

界面如图：

2.导入Excel格式配置参数

步骤

1.系统管理平台-》数据转储-》关系数据库-》导入

2.选择导入配置好的Excel文件

3.选择是否备份当前XML配置文件

4.导入成功，将excel配置参数保存到xml配置文件

3.Excel表格式及内容

Excel文件有四个sheet，分别对应名称为“Connect，Table，Rule，Tag”

vConnect对应的是关系数据库连接功能

第一行为连接的标题，详细如下：

连接名 数据库名 数据库地址 数据库类型 数据库端口号 用户名 密码

对不同单元格详细说明（有【】的只能填写里面内容，多选一）：

连接名：连接名称（唯一，不能重复）

数据库名：关系数据库的名称，（DB2不填）

数据库地址：关系数据库的IP地址

数据库类型：[DB2、Oracle、MySQL、SQLserver]

数据库端口号：连接关系数据库的端口号，默认为-1，（DB2不填）

用户名：关系数据库用户名

密码：关系数据库的密码

vTable是表映射

第一行为连接的标题，详细如下：

连接名 表名 表别名 表类型 Tag类型 Tag名 数据质量 数据值 时间戳 报警点名 开始时间 结束时间 确认时间 确认类型 是否确认 是否恢复 源值 源点 确认者 注释 注释者 注释时间 报警条件 报警优先级 报警类型

对不同单元格详细说明：

连接名：对应的Connect中的连接名

表名：表名称（唯一，不能重复）

表别名：别名

表类型：[narrow、wide]对应的窄表和宽表

Tag类型：[alarmraw、nscraw、nscinterp]对应的报警原始值、普通原始值、普通插值

(以下为普通点/统计点/计算点配置，报警点无需填写，，对应的关系数据库的字段，无对应则为空)

Tag名

数据质量

数据值

时间戳

(以下为报警点配置，普通点/统计点/计算点无需填写，，对应的关系数据库的字段，无对应则为空)

报警点名

开始时间

结束时间

确认时间

确认类型

是否确认

是否恢复

源值

源点

确认者

注释

注释者

注释时间

报警条件

报警优先级

报警类型

vRule是规则

第一行为连接的标题，详细如下：

连接名 表名 规则名 开始时间 记录间隔时间 结束时间 开始时间 执行间隔

对不同单元格详细说明：

连接名：对应的Connect中的连接名

表名：对应的Table中的表名

规则名：规则名称（唯一，不能重复）

开始时间：时间格式如：【2017-11-22 13:38:20】

记录间隔时间：整型，单位为秒，格式如【1】表示一秒

结束时间：时间格式如：【2017-11-22 13:38:20】

开始时间：时间格式如：【2017-11-22 13:38:20】

执行间隔：整型，单位为秒

vTag是规则里面的tag点

第一行为连接的标题，详细如下：

连接名 表名 规则名 Tag名 Tag类型 Tag描述 数据值 取值模式 数据质量

对不同单元格详细说明：

连接名：对应的Connect中的连接名

表名：对应的Table中的表名

规则名：对应的Rule中的规则名

Tag名：Tag名称（唯一，不能重复）

Tag类型：如【int8、float32、digital…】

Tag描述：Tag点的描述

数据值：（宽表选填）对应关系数据库中表字段，无则空

取值模式：（宽表选填）【pre_neighbor、linear】 前值插值，线性插值

数据质量：（宽表选填）对应关系数据库中表字段，无则空


表映射配置

Navigation: 功能明细 > 数据转储 > 数据转储（到关系数据库） >

表映射配置

 Return to chapter overview

本章节主要内容包括：

§添加表映射

§查看表映射

§删除表映射

©2015. All Rights Reserved.


添加表映射

Navigation: 功能明细 > 数据转储 > 数据转储（到关系数据库） > 表映射配置 >

添加表映射

 Return to chapter overview

查看关系数据库连接界面，选中用于转储数据的关系数据库连接，单击“添加表映射”按钮，进入添加表映射界面。下图为使用某MySQL数据库时添加表映射界面。

界面左上方显示了关系数据库中符合转储要求的表的列表。转储服务要求关系数据库中的表名不得含有中文，不得含有空格。右上方显示了选中的表的结构信息。

列表下方提供了三种关系数据库表的操作：新加表、修改表结构、删除表。在做这三种操作时，转储配置将再次校验关系数据库密码。

界面中部显示了表别名输入框、转储方式下拉列表和单选框，以及记录属性窄表字段匹配。初始进入添加表映射时默认未选中表，因此表别名输入框、转储方式、字段匹配均灰化。

Tag点类别下拉框中有“普通点/统计点/计算点”和“报警点”两项。

数据模式下拉框中有“原始值”和“插值”两项。

存储方式单选框有“窄表”和“宽表”两项。

选中要使用的关系数据库表后，依次输入表别名、选择转储方式，然后进行记录属性字段匹配。

下面给出所有的组合：

1、普通点/统计点/计算点，原始值，窄表；

2、普通点/统计点/计算点，插值，窄表；

3、普通点/统计点/计算点，插值，宽表；

4、报警点，原始值，窄表。

每部分的详细匹配信息请查看【转储概念与要求】中的字段匹配部分。匹配失败，则弹出提示框，告知错误位置。下拉框复位为未选中。

例如：

Tips：

在配置字段匹配时，如果当前属性X匹配了字段B，属性Y匹配了字段A，而实际上想X匹配A，Y匹配B，可作如下操作：

属性X匹配A，弹出A已匹配提示，X的匹配内容清空；

属性Y匹配B，成功；

属性X匹配A，成功。

1、普通点/统计点/计算点，原始值，窄表

字段匹配要求表中须有字段和Tag名、记录时间、数据值相匹配；如果转储数据质量，则表中也应有字段和数据质量相匹配。

默认“数据质量”是否转储勾选框未勾选。

配置完成后，单击添加表映射页面的“确定”按钮，完成添加。

2、普通点/统计点/计算点，插值，窄表

本部分内容同普通点/统计点/计算点，原始值，窄表。

3、普通点/统计点/计算点，插值，宽表

转储为宽表时，表中应有字段和Tag点的数据值和（或）数据质量相对应。此时应导入Tag点，再进行宽表字段匹配。

注意：添加表映射时，如上图，当选择数据类型为VARCHAR时，推荐字段长度为256，当变量类型为String或者BLOB时，推荐字段长度大于1000。

导入Tag点界面，单击“导入Tag点”按钮，进入Tag查询页面，根据用户需要自行添加需要的tag点。

服务器列表中显示了客户端连接管理器中的实时数据库连接和转储已配置的实时数据库连接。

导入Tag点后，使用“前值插值”和“线性插值”单选框快速配置插值模式，或者对于每个Tag点，单独进行插值模式配置。

如果要移除某些Tag点，选中这些Tag点，点击“移除Tag点”按钮，确认后移除，如下图。

移除Tag点时将从右端字段匹配中删除关联的字段匹配。请谨慎操作。

导入Tag点后，记录属性宽表字段匹配中的Tag名自动更新已导入的Tag点。如下图。

配置完成后，单击添加表映射页面的“确定”按钮，完成添加。

4、报警点，原始值，窄表

Tag点类别选中“报警点”时，自动进行报警窄表字段匹配：从关系数据库中依次读取字段信息，按照先后顺序进行基本属性匹配。

如果匹配成功，那么对应的下拉列表中将该字段作为当前项，勾选其后的是否转储勾选框；否则下拉列表重置为未选中，不勾选其后的是否转储勾选框。

报警记录一共有16个属性，界面左部分进行常用的7个属性匹配，依次为：报警点名（必须转储）、开始时间（必须转储）、结束时间、报警优先级、源值、报警条件、是否确认；

界面右部分进行剩余9个属性匹配，依次为：报警类型、源点名、是否恢复、确认时间、确认类型、确认者、注释、注释时间、注释者。

详细匹配信息请参阅转储的概念与要求中的字段匹配部分。

配置完成后，单击“确定”，完成表映射添加。

本章节主要内容包括：

·新建表

·修改表结构

·删除表

©2015. All Rights Reserved.


新建表

Navigation: 功能明细 > 数据转储 > 数据转储（到关系数据库） > 表映射配置 > 添加表映射 >

新建表

 Return to chapter overview

添加表映射界面，单击“新建表”按钮，进入新建表界面。如下图所示。

输入表名，字段名，选择字段类型，单击“添加字段”按钮，添加字段。

若要删除字段，选中字段，点击“删除字段”按钮，弹出提示框。确认后删除选中的字段。

若要进行快速配置，可单击“添加推荐字段”按钮，通过选择转储方式，添加转储配置推荐的字段。

根据不同的转储方式、不同的关系数据库，系统提供不同的推荐字段。

例如，在MySQL情况下，普通点插值窄表推荐字段为：

在MySQL情况下，报警点原始值转储推荐字段为：

单击“新建表”界面的确定按钮，输入关系数据库密码，完成新建表。回到添加表映界面，数据库中存在表中已有新建的表。


修改表结构

Navigation: 功能明细 > 数据转储 > 数据转储（到关系数据库） > 表映射配置 > 添加表映射 >

修改表结构

 Return to chapter overview

添加表映射界面，选中要修改的表，单击“修改表结构”按钮，进入修改表结构界面。如下图所示。

在添加字段框内依次输入字段名，选择字段类型，输入字段长度。点击“添加字段”进行添加。

如要删除已添加的字段，选中这些字段，单击“删除字段”按钮，确认后删除选中的字段。

新增字段输入后，单击确定，弹出输入密码提示框。输入并确定后，弹出修改结果。


删除表

Navigation: 功能明细 > 数据转储 > 数据转储（到关系数据库） > 表映射配置 > 添加表映射 >

删除表

 Return to chapter overview

添加表映射界面，选中要删除的表，单击“删除表”按钮，弹出清除表映射信息提示框。如下图所示。

确定后，弹出输入密码提示框。输入密码并确定后，删除表，弹出删除结果。


查看表映射

Navigation: 功能明细 > 数据转储 > 数据转储（到关系数据库） > 表映射配置 >

查看表映射

 Return to chapter overview

系统管理平台--数据转储--关系数据库页面，选中已添加的表映射，右端显示表映射详细信息。如下图。

根据转储方式的不同，右端分别可以进行窄表规则配置、宽表规则配置。请参考规则配置 。


删除表映射

Navigation: 功能明细 > 数据转储 > 数据转储（到关系数据库） > 表映射配置 >

删除表映射

 Return to chapter overview

系统管理平台--数据转储--关系数据库页面，选中已添加的表映射，单击下方的“删除表映射”按钮，弹出删除提示框。确认后删除该表映射。如下图。

删除表映射时，将删除该表映射下所有的转储规则，请谨慎操作。


规则配置

Navigation: 功能明细 > 数据转储 > 数据转储（到关系数据库） >

规则配置

 Return to chapter overview

对于转储服务而言，一个转储规则对应于一个转储定时任务。因此，必须进行转储规则的配置。

规则配置中需要设置多个时间，请参阅转储的概念与要求中关于时间的叙述。

若要进行规则配置，建议在停止转储服务的情况下配置规则。

配置完成后，需将转储服务重新启动。

若尚未完全配置好规则，则转储服务执行结果是未定义的。

本章节主要内容包括：

·窄表规则配置

·宽表规则配置

©2015. All Rights Reserved.


窄表规则配置

Navigation: 功能明细 > 数据转储 > 数据转储（到关系数据库） > 规则配置 >

窄表规则配置

 Return to chapter overview

查看已添加的表映射，其转储方式为窄表。则可进行窄表规则配置。

一个窄表可对应一个或一个以上的转储规则，如下图所示。

同一表映射下不同规则不允许同名。

1、新建规则

点击“新建规则”按钮，进入新建规则界面。下图分别为原始值窄表下的新建规则界面、插值窄表下的新建规则界面。插值时需要用户配置插值模式。

依次设置“记录起始时间”、“记录间隔时间”、“执行起始时间”、“执行间隔时间”。若要配置记录结束时间，勾选“启用记录结束时间”，配置记录结束时间。

点击“导入Tag点”按钮，配置该规则需要转储哪些Tag点的数据。如果是插值模式，则进一步配置每个Tag点的插值模式。默认导入的Tag点使用前值插值模式。使用“全选前值插值”和“全选线性插值”单选框进行快速插值模式配置。

2、修改规则

选中要修改的规则，单击“修改规则”按钮修改规则。如下图所示。

若要导入新的Tag点，单击“导入Tag点”按钮；若要移除已导入的Tag点，选中欲移除的点，单击“移除Tag点”按钮，确认后移除这些选中的Tag点。

输入新的规则信息后，单击确定完成修改。

3、删除规则

选中欲删除的规则，单击“删除规则”按钮，弹出提示框。

点击确定，删除规则；或点击取消，不删除规则。


宽表规则配置

Navigation: 功能明细 > 数据转储 > 数据转储（到关系数据库） > 规则配置 >

宽表规则配置

 Return to chapter overview

查看已添加的表映射，其转储方式为普通点/统计点/计算点，插值，宽表。则可进行宽表规则配置。

一个宽表只能对应一个转储规则，如下图所示。

默认配置为未启用宽表规则。

若要配置宽表规则，勾选“启用宽表规则”，依次设置“记录起始时间”、“记录间隔时间”、“执行起始时间”、“执行间隔时间”。若要配置记录结束时间，勾选“启用记录结束时间”，配置记录结束时间。

配置完成后，点击规则信息中的保存按钮，保存该转储规则。

若要停用宽表规则，则取消“启用宽表规则”勾选框，点击保存，停用宽表规则。


脚本配置转储

Navigation: 功能明细 > 数据转储 > 数据转储（到关系数据库） >

脚本配置转储

 Return to chapter overview

iHyperDB转储支持将python脚本文件作为转储规则，每个规则转储其指定的iHyperDB中一个或者多个Tag点的数据到关系数据库的一张表中。脚本自行决定将数据存储为窄表或者宽表。关于窄表、宽表的定义和字段限制，请参考添加转储表章节和安装路径：$当前安装位置/config/ExportScript/ 目录下的Python脚本示例.

下面介绍如何配置python脚本转储以及脚本编写说明。

·配置python文件

·创建python脚本

©2015. All Rights Reserved.


创建python脚本

Navigation: 功能明细 > 数据转储 > 数据转储（到关系数据库） > 脚本配置转储 >

创建python脚本

 Return to chapter overview

本节介绍怎样创建python脚本，详细内容请参照iHyperDB安装目录下/config/ExportScripts文件夹中的示例脚本。

setEnviron(functionContainer)

传递主程序的回调函数供使用，之后通过functionContainer.function()来调用相应的函数，我们已经提供默认实现，将funcntionContainer赋值给全局变量functions,之后的函数调用可以通过functions来使用。

Init()

初始化函数，可在其中进行注册规则、添加tag点、创建关系数据库表等初始化工作。

fini()

清理函数,我们已经提供了默认实现。

getExportedMaxTime()

返回已转储数据的最大时间戳至转储服务，需要返回指定模式的时间戳，形如：convertedTime = [2012,8,8,20,8,8,0],列表中数据依次为年，月，日，时，分，秒，毫秒。若无法给出正确的上一次转储最后一条数据的时间戳，本函数返回的时间戳需要早于该时间。

可以格式化要存入关系数据库的时间字段，用逆序查询即可，也可以再表的创建语句中加入自增ID字段，根据该ID查询。

·脚本需要提供的可选函数

三选一,根据脚本类型("interpolate","specify_interfolate","alarm_raw"),选择不同的实现.

§脚本类型为:"interpolate","specify_interfolate":

onInterpolateTimer(timestamp,DataArray)

转储插值定时器处理函数，参数DataArray是一个结构体数组(list of dictionary),每个结构体包含内容依次为：tag名、数据质量和数据值。函数体内组织sql语句，将这些数据写入关系数据库中。

§脚本类型为:"alarm_raw":

onAlarmRawTimer(DataArray)

转储报警记录，参数DataArray是一个结构体数组(list of dictionary)，每个结构体中包含报警记录相关的16个属性。函数体内组织sql语句，将这些数据写入关系数据库中。

·脚本可调用的回调函数

脚本可调用的回调函数，通过setEnviron传递过来的functionContainer来调用。

§注册规则

retValue=functions.regRule(iHDSrvInfo,rdbInfo,ruleInfo)

函数参数：

iHDSrvInfo：实时数据库服务器信息；

rdbInfo：关系数据库服务器信息；

ruleInfo:规则时间类型信息。

函数返回值：

dictionary，元素为"errorcode"，得到错误码。

使用方式：

init中调用

§添加Tag点信息到规则中

retValue=functions.addTag2rule(tag)

函数参数：

tag：tag点信息

函数返回值：

dictionary，元素为"errorcode"，得到错误码。

使用方式：

init中调用

§执行SQL语句

retValue=functions.execSql(rdbInfo,sql)

函数参数：

rdbInfo：规则时间类型信息；

sql：要执行的sql语句

函数返回值：

dictionary，元素为"errorcode"，得到错误码；

number，得到查询结果行数，如果查询结果行数大于0，则获取元素“result”，得到sql查询的结果列表，保持查询返回的记录顺序，结果列表中的每个元素为记录字典，key为查询的字段名。

使用方式：

创建关系数据库表；插入记录；查询记录；

§注销规则

functions.unRegRule()

函数参数：无

返回值：无

使用方式：

fini()中调用

§保持和关系数据库的连接

retValue=functions.keepRDBConnection(rdbInfo)

函数参数：

rdbInfo：关系数据库服务器信息；

函数返回值：

dictionary，元素为"errorcode"，得到关系数据库连接错误码，0表示已成功连接；

使用方式：

调用execsql前调用，若无法连接至关系数据库，返回该错误至转储服务。


配置python文件

Navigation: 功能明细 > 数据转储 > 数据转储（到关系数据库） > 脚本配置转储 >

配置python文件

 Return to chapter overview

本节介绍配置python文件，本节内容包括：

·添加python脚本

·删除python脚本

·修改python脚本

·数据转储python脚本的开发与配置，步骤如下：

1.根据脚本二次开发范例编写定制的python脚本文件，将该文件放入目录$当前安装目录/config/ExportScripts下。脚本文件名称限制：合法文件名，以“.py”为后缀，并且去除后缀后不得包含英文标点“.”。

2.打开系统管理工具→数据转储→关系数据库，在界面右侧出现自定义脚本面板，如下图：

3.点击“添加”，弹出打开对话框，选择刚才编写好的脚本，点击“打开”，对话框关闭，选择的脚本添加到脚本列表中，如下图：

如果试图手动输入不存在的文件，点击打开时报错：

4.在脚本列表中，可以双击要修改的脚本描述列，编辑该脚本的描述，如下图：

5.点击保存，配置的脚本信息被写到配置文件中。

Python文件配置完成后，转储服务便能够读入该脚本规则，执行规则任务。

·删除python脚本

用户可以通过从配置文件中删除脚本项来停止某一脚本，当转储服务空闲超过1分钟时，服务将检查配置文件中的脚本规则列表，停止已经不存在的脚本规则。

1.打开系统管理工具→数据转储→关系数据库，在界面右侧出现自定义脚本面板；

2.在脚本列表中选择要删除的脚本名称，点击右侧的“删除”按钮，脚本在列表中被删除；

3.点击保存，修改转储的配置文件。

一定别忘了点击保存，否则删除不能生效。

·修改python脚本

用户可以在转储服务启动后随时修改脚本内容,当转储服务空闲超过1分钟时,转储服务将检查已添加的各脚本文件的修改状态,如果其加载的脚本不是最新,则停止已有脚本规则,重新载入该脚本执行.


大数据采集器安装及配置

Navigation: 功能明细 > 数据转储 >

大数据采集器安装及配置

 Return to chapter overview

功能：将采集实时数据库中的数据上传到xinsight大数据平台中。

安装：

有两个安装途径：

1.安装iHyperDB的过程中，选择安装，详见整体安装说明；

2.选择大数据采集器安装包安装，详见单独安装说明；

修改大数据连接配置：

详见连接配置修改说明；

启用大数据服务：

详见启用服务说明；

整体安装：

安装iHyperDB数据节点的时候选择安装大数据采集器(iHyperDB安装过程请参考帮助文件：安装和卸载下的相关章节)，在安装过程中出现下图，点选“大数据采集转发服务”，并点击“下一步”。

进入“大数据平台参数设置”画面，如下图：

填写大数据采集器连接的“URI，Token，identifier”三个连接参数，具体参数请咨询大数据平台产品的应用支持人员。

点击“安装”，开始安装。

单独安装：

在iHyperDB安装包里双击“BigdataCollector.exe”，这是大数据采集转发服务的安装包。

如下图，出现安装向导画面，点击下一步：

如下图，选择安装位置，并点击“下一步”：

iHyperDB3.5版本及以前会如下图，进入“配置中心服务设置”画面。iHyperDB3.6版本会跳过此步骤，直接进入下一个步骤。

iHyperDB配置服务参数：

Ø设置本机IP:由于安装机器可能有多块网卡，请于此处选择计划与大数据平台系统网络通讯用网卡IP；

Ø配置中心服务端口：通讯端口缺省“5673”，如无必要请勿修改；

如果没有安装过PostgreSQL,请先点击安装，再填写连接参数。如果已安装，可填写PostgreSQL关系库连接参数后，点击“下一步”。

进入“大数据平台参数设置”画面，如下图：

填写大数据采集器连接的“URI，Token，identifier”三个连接参数，具体参数请咨询大数据平台产品的应用支持人员。

点击“安装”，开始安装。

修改大数据连接配置：

注：如果在安装过程没有填写配置项，也可待安装完毕，在“数据节点服务管理工具”中配置添加或修改，如下图：

另外，也可通过直接修改配置文件（BigDataConfig.xml）的方式修改。该配置文件在采集器安装目录下的executable文件夹中（Unix版本在ihyperdb\runtime下）。如下图：

修改BigData下的URI，Token，identifier三个配置项，对应大数据平台。Threadpoolnum是大数据采集器内部并发的工作线程数，默认是5，可根据现场tag点数和机器性能来修改，最小为1，最大为20；可以根据“tag总点数\2万点”，来计算得到该线程数的值。

启用服务器：

v启动大数据平台采集服务。

完整安装后，点击目录下的“数据节点服务管理工具”，如下图。

在数据节点服务管理工具的进程管理中可查看大数据采集器服务（hdBigdataCollector）状态，以及启动/停止服务，如下图

独立安装大数据采集器方式，需运行安装目录executable文件夹下hdBigdataServiceManager.exe，进行安装服务、启停服务等操作。

v配置数据源Tag点：

1)在管理工具的进程管理中，确认大数据采集服务已正常启动。

2)使用系统管理工具（hdSysMgrTool.exe）和OPC采集器配置工具（hdCollectorConfigTool.exe）配置tag点和OPC采集

采集的步骤参见OPC采集tag点经典案例

v相关OPC配置的tag点自动在大数据平台中注册。

v在大数据平台中，如果是pds则需要新建实例，并关联或者勾选上传Tag点。具体步骤参见大数据平台用户手册；

如果是tsdb，不需要新建实例，已默认上传，可在大数据平台直接修改tag压缩等属性。

v此时OPC采集的数据会自动上传到大数据平台。在平台的实时数据查看页面和历史数据查看页面都可以查看。

v大数据采集器支持计算点和统计点。


典型案例6-普通点插值数据转储到MySQL

Navigation: 功能明细 > 数据转储 >

典型案例6-普通点插值数据转储到MySQL

 Return to chapter overview

配置案例：本案例中的关系数据库采用MySQL（版本为5.5及以上），通过在系统管理工具界面中配置转储界面,实现将iHyperDB服务器中的普通点的插值数据转储到关系数据库中的功能。

准备工作：服务端运行正常，客户端可以查询到待转储的历史数据。

配置步骤如下：

1.配置转储环境:

对于MySQL,安装时建议指定的编码格式为UTF-8,这样转储记录中如果有中文记录，关系数据库中编码格式需要支持；

MySQL环境配置有以下两种方式：

A．将对应MySQL服务端安装目录下的lib/libmysql.dll拷贝$iHyperDB/executable 目录下即可；

B．若本机安装了该版本的MySQL，将本机MySQL安装路径添加至环境变量path中即可。

对于不同关系数据库转储环境如何配置，详细可以参考：转储环境配置

2.添加数据库：

i.在系统管理平台中打开任务面板中数据转储，双击关系数据库，打开转储配置界面。

ii.点击添加数据库按钮弹出添加数据库窗口：

其中，数据库类型：目前关系数据库支持MySQL，SQLServer，Oracle和DB2四种类型；

对于MySQL，有如下几项填写信息：

ü 连接名称：用户自定义连接名称，不得与已有的连接重名；

ü 数据库名：填写要转到的数据库实例的名称，此处MySQL数据库名称为test；

ü 数据库地址：数据库服务器IP地址或者主机名；

ü 数据库端口：数据库服务器端口（如果使用默认端口，填写-1，否则填写实际端口号）；

ü 用户名和密码：分别是MySQL数据库自定义的用户名和密码；

iii.点击测试连接，可以测试能否连接该关系数据库。

iv.点击确定，添加数据库完成。

3.添加表映射

i.选中关系数据库连接名，点击添加表映射按钮，弹出添加表映射窗口。

ii.可以选择已有表或者新建表，本案例中新建一个表，点击浏览表名下方的新建表按钮，弹出窗口如下图所示。

iii.输入表名、添加所需要的字段。字段数量、类型，请参考：字段限制。也可以通过添加推荐字段按钮快速添加字段。此处使用点击添加推荐字段方式。

iv.选择好转储方式后，点击确定，自动生成新建关系数据库表所需字段。

v.点击确定，输入关系数据库密码，完成新建表。回到添加表映射页面。

vi.在添加表映射页面，单击新建的表，右端可见该表结构。依次输入表别名，选择转储方式，设置记录属性窄表字段匹配。

vii.单击确定，完成表映射添加。关系数据库树上显示该表映射。

4.新建转储规则

i.点击树上的表别名，界面右方显示表映射信息。

ii.在规则信息框内，点击新建规则按钮，弹出新建规则界面，设置规则名和转储时间。规则时间的意义请查询帮助手册--数据转储部分。

iii.点击导入Tag点按钮，导入要转储记录所属Tag点。

iv.导入Tag点后，根据需求调整插值模式，单击确定完成新建规则。

5.开启关系数据库转储进程

i.在转储配置界面选择保存配置后，才选择启动服务按钮。可选择安装windows服务或者直接启动进程。

ii.选择启动进程，弹出如下对话框。如果选择安装服务后启动，则没有黑窗口。

iii.运行上述步骤，即可完成普通点插值数据转储到MySQL数据库功能。这时我们可以看到转储到关系数据库中的数据。


典型案例7-报警点原始数据转储到SQLServer

Navigation: 功能明细 > 数据转储 >

典型案例7-报警点原始数据转储到SQLServer

 Return to chapter overview

配置案例：本案例中的关系数据库采用SQLServer（版本为2005及以上），通过在系统管理平台中配置转储，实现将iHyperDB服务器中的报警点原始记录转储到关系数据库的功能。

准备工作：服务端运行正常，客户端报警查询工具可以查询到报警记录。

配置步骤如下：

1.配置转储环境:

对于SQLServer数据库，不需要进行额外的转储环境配置。

2.添加数据库：

i.在系统管理平台中打开任务面板中数据转储，双击关系数据库，打开转储配置界面。

ii.点击添加数据库按钮弹出添加数据库窗口：

其中，数据库类型：目前关系数据库支持MySQL，SQLServer，Oracle和DB2四种类型；

对于SQLServer，有如下几项填写信息：

ü 连接名称：用户自定义连接名称，不得与已有的连接重名；

ü 数据库名：填写要转到的数据库实例的名称，此处SQLServer数据库名称为test；

ü 数据库地址：数据库服务器IP地址或者主机名；

ü 数据库端口：数据库服务器端口（如果使用默认端口，填写-1，否则填写实际端口号）；

ü 用户名和密码：分别是SQLServer数据库自定义的用户名和密码；

iii.点击测试连接，可以测试能否连接该关系数据库。

iv.添加关系数据库连接界面点击确定，添加数据库完成。

3.添加表映射

i.选中关系数据库连接名，点击添加表映射按钮，弹出添加表映射窗口。

ii.可以选择已有表或者新建表，本案例中使用有可创建表权限的SQLServer用户，新建一个表。

iii.点击浏览表名下方的新建表按钮，弹出窗口如下图所示。

iv.输入表名、添加所需要的字段。字段数量、类型，请参考：字段限制。也可以通过添加推荐字段按钮快速添加字段。此处使用点击添加推荐字段方式。

v.选择好转储方式后，点击确定，自动生成新建表所需字段。

vi.点击确定，输入关系数据库密码，完成新建表。回到添加表映射页面。

vii.在添加表映射页面，单击新建的表，右端可见该表结构。依次输入表别名，选择转储方式，设置记录属性窄表字段匹配。

viii.单击确定，完成表映射添加。关系数据库树上显示该表映射。

4.新建转储规则

i.点击树上的表别名，界面右方显示表映射信息。

ii.在规则信息框内，点击新建规则按钮，弹出新建规则界面，设置规则名和转储时间。规则时间的意义请查询帮助手册--数据转储部分。

iii.点击导入Tag点按钮，导入要转储记录所属Tag点。

iv.确定后导入选中的Tag 点。

v.单击确定，完成新建规则。

5.开启关系数据库转储进程

i.在开始菜单中选择启动转储到关系数据库进程选项，会弹出对话框，hdRDBExporter是启动进程还是安装该服务。

ii.选择启动进程，弹出如下对话框

iii.运行上述步骤，即可完成报警点原始数据转储到SQLServer数据库功能。这时我们可以看到转储到关系数据库中的数据。


典型案例8-普通点原始值数据转储到Oracle

Navigation: 功能明细 > 数据转储 >

典型案例8-普通点原始值数据转储到Oracle

 Return to chapter overview

配置案例：本案例中的关系数据库采用Oracle（版本为10g及以上），通过再系统管理平台中配置转储，实现将实时iHyperDB服务器中的普通点原始记录转储到关系数据库的功能。

准备工作：服务端运行正常，客户端可以查询到待转储的历史数据。

本案例中的关系数据库采用Oracle（版本为10g及以上），通过系统管理平台中配置转储，实现将实时iHyperDB服务器中的普通点原始记录转储到关系数据库的功能。

配置步骤如下：

1.配置转储环境:

对于Oracle数据库，系统管理平台所在机器需要配置Oracle客户端。下面给出一种推荐的方式：

a.从Oracle官方网站下载InstantClient压缩包，将压缩包中的DLL文件、可执行文件等全部解压到转储客户端所在的机器上，比如“D:\instantclient_11_2”;

b.在“D:\instantclient_11_2”目录下创建tnsnames.ora文本文件，从Oracle服务端的tnsnames.ora文本文件中拷贝需要用到的dsn（DataSourceName，数据源名称）；

c.将该InstantClient解压目录D:\instantclient_11_2添加到环境变量path中；

d.创建环境变量 name：TNS_ADMIN，value：D:\instantclient_11_2;

e.创建环境变量 name：NLS_LANG， value:AMERICAN_AMERICA.ZHS16GBK;

对于不同关系数据库转储环境如何配置，详细可以参考：转储环境配置

2.添加数据库：

i.在系统管理平台中打开任务面板中数据转储，双击关系数据库，打开转储配置界面。

ii.点击添加数据库按钮弹出添加数据库窗口：

其中，数据库类型：目前关系数据库支持MySQL，SQLServer，Oracle和DB2四种类型；

对于Oracle，有如下几项填写信息：

ü 连接名称：用户自定义连接名称，不得与已有的连接重名；

ü 数据源名称：tnsnames.ora中要用到的数据源名称；

ü 用户名和密码:分别是Oracle数据库自定义的用户名和密码。

注意，如果数据库中没有合适的表，配置转储时需要在Oracle数据库中创建表，这里需要使用有创建表权限的用户。

iii.点击测试连接，可以测试能否连接该关系数据库。

iv.添加关系数据库连接界面点击确定，添加数据库完成。

3.添加表映射

i.选中关系数据库连接名，点击添加表映射按钮，弹出添加表映射窗口。

ii.可以选择已有表或者新建表，本案例中使用有可创建表权限的Oracle用户，新建一个表。

iii.点击浏览表名下方的新建表按钮，弹出窗口如下图所示。

iv.输入表名、添加所需要的字段。字段数量、类型，请参考：字段限制。也可以通过添加推荐字段按钮快速添加字段。此处使用点击添加推荐字段方式。

v.选择好转储方式后，点击确定，自动生成新建表所需字段。

vi.点击确定，输入关系数据库密码，完成新建表。回到添加表映射页面。

vii.在添加表映射页面，单击新建的表，右端可见该表结构。依次输入表别名，选择转储方式，设置记录属性窄表字段匹配。

viii.单击确定，完成表映射添加。关系数据库树上显示该表映射。

4.新建转储规则

i.点击树上的表别名，界面右方显示表映射信息。

ii.在规则信息框内，点击新建规则按钮，弹出新建规则界面，设置规则名和转储时间。规则时间的意义请查询帮助手册--数据转储部分。

iii.点击导入Tag点按钮，导入要转储记录所属Tag点。

iv.确定后导入选中的Tag 点。

v.单击确定，完成新建规则。

5.开启关系数据库转储进程

i.在开始菜单中选择启动转储到关系数据库进程选项，会弹出对话框，hdRDBExporter是启动进程还是安装该服务。

ii.选择启动进程，会弹出如下对话框

iii.运行上述步骤，即可完成普通点原始数据转储到Oracle数据库功能。这时我们可以看到转储到关系数据库中的数据。


典型案例9-普通点原始值数据转储到DB2

Navigation: 功能明细 > 数据转储 >

典型案例9-普通点原始值数据转储到DB2

 Return to chapter overview

本案例中的关系数据库采用DB2版本为6.x及以上，通过在系统管理工具界面中配置转储界面，实现将iHyperDB服务器中的普通点的原始值逐句转储到关系数据库中的功能。

准备工作：服务端运行正常，客户端可以查询到待转储的历史数据。

1.配置转储环境:

DB2：转储服务所在机器需要配置DB2客户端。下面给出一种推荐的方式：

a.安装DB2运行时客户机；

b.节点编目

运行命令行窗口（winxp以上需要管理员权限），运行db2cmd db2 catalog tcpip node node_name remote server_ip server server_port

其中

node_name：所要编目的节点名，即服务器内的实例名。实例名在一台机器上必须是惟一的，可输入纯字母或字母与数字的组合，字母不区分大小写。注意实例名不能命名为"DB2"，且不支持特殊字符。

server_ip：所要编目的服务器的IP地址。

server_port：所要编目的服务器的端口号，默认为50000。

c.数据库编目

运行命令行窗口（winxp以上需要管理员权限），运行db2cmd db2 catalog db db_name as db_alias at node node_name

其中

db_name：要编目的数据库名称

db_alias：数据库编目到客户端所用的别名

node_name：所要编目的数据库所在的节点名称。

对于不同关系数据库转储环境如何配置，详细可以参考：转储环境配置

2.添加数据库：

点击添加数据库按钮弹出添加数据库窗口：

其中，数据库类型：目前关系数据库支持MySQL，SQLServer，Oracle和DB2四种类型；

对于DB2，有如下几项填写信息：

连接名称：用户自定义连接名称，不得与已有的连接重名；

数据源名称：数据库编目到客户端的别名或本地数据库名；

用户名和密码分别是DB2数据库的用户名和密码。

注意，如果数据库中没有合适的表，配置转储时需要在Oracle数据库中创建表，这里需要使用有创建表权限的用户。

点击测试连接，可以测试能否连接该关系数据库。

添加关系数据库连接界面点击确定，添加数据库完成。

剩余操作请参考界面配置普通点原始值数据转储到Oracle。


典型案例10-普通点原始值数据转储到GBase

Navigation: 功能明细 > 数据转储 >

典型案例10-普通点原始值数据转储到GBase

 Return to chapter overview

本案例中的关系数据库采用GBase，通过在系统管理工具界面中配置转储界面，实现将iHyperDB服务器中的普通点的原始值逐句转储到关系数据库中的功能。

准备工作：服务端运行正常，客户端可以查询到待转储的历史数据。

根据gbase提供的资料T_连接到GBase 8s数据库示例_V1.3_20210409.docx，发现连接到gbase数据库在不同的环境下主要有ODBC和JDBC两种。

更符合我们使用的场景是使用ODBC去进行连接。

1.配置转储环境:

Windows系统：

a.下载https://gbasedbt.com/odbc/GBase8s_3.0-Win64-ODBC-Driver.zip

b.安装ODBC，解压zip包，生成的gbase8s-odbc-driver放置于D:\目录下。

在我的电脑->系统属性->高级->环境变量 中，增加环境变量GBASEDBTDIR 指向D:\gbase8s-odbc-driver，Path中增加%GBASEDBTDIR%\bin;（路径按照实际存放位置填写）

使用管理员权限运行00注册ODBC_管理员权限运行.cmd

c.配置ODBC，64位系统打开C:\Windows\System32\odbcad32.exe，点击添加，选择GBase ODBC DRIVER。

配置数据源名称，也是gbase ODBC的名称

配置连接信息，包括服务器名字，地址，端口，数据库名称（schema），用户ID,密码等。

点击应用并测试连接，连接上数据库表示ODBC驱动安装完成

2.添加数据库：

点击添加连接按钮弹出添加数据库窗口：

其中，数据库类型：目前关系数据库支持MySQL，SQLServer，Oracle、DB2、GBase几种类型；

对于GBase，有如下几项填写信息：

连接名称：用户自定义连接名称，不得与已有的连接重名；

数据源名称：数据库编目到客户端的别名或本地数据库名；使用配置ODBC驱动时所配的

用户名和密码分别是GBase数据库的用户名和密码。使用配置ODBC驱动时所配的

2.测试连接数据库：

点击测试连接，可以测试能否连接该关系数据库；添加关系数据库连接界面点击确定，添加数据库完成。


iHD实时数据库序列缓存重置工具

Navigation: 功能明细 > 数据转储 >

iHD实时数据库序列缓存重置工具

 Return to chapter overview

1.概述：
iHD修改序列缓存属性或发生一些问题时，需要重新生成序列缓存文件，新增了此工具可以进行自动重置。

2.使用方法：

windows:

停止ihd服务，修改ServerCfg.xml,确认配置正确后，运行executable_x64下SeqCacheResetTool.exe，再启动ihd服务。

linux:

停止ihd服务，修改ServerCfg.xml,确认配置正确后，在runtime下../executable/SeqCacheResetTool，再启动ihd服务。


数据上云配置

数据上云

Navigation: 功能明细 > 数据转储 >

数据上云

 Return to chapter overview

1.概述

配置更新：

上云配置更新服务通过ICE提供上云配置更新的相关接口，BB调用该接口将配置json传输到上云配置更新服务，对上云配置进行更新。

状态查询：

上云配置更新服务通过ICE提供状态查询的相关接口，BB调用该接口将查询ihd配置状态。

BB接口：详见子目录“Tag点上云接口”

配置文件说明：

ihd.connection用于配置ihd连接。

HDConfigHandler.Endpoints用于配置服务对外端口，一般只需修改tcp端口即可。

# The server creates one single object adapter with the name

# "HDConfigHandler". The following line sets the endpoints for this

# adapter.

#

IdentityName=HDConfigHandler

ihd.connection=admin:admin@10.25.190.34:5673

HDConfigHandler.Endpoints=tcp -p 30000:udp -p 30000:ws -p 10002

#

# Warn about connection exceptions

#

Ice.Warn.Connections=0

Ice.ThreadPool.Server.Size=5

接口说明：

module ihd

{

exception InvokeError

{

string reason;

}

sequence<byte> JsonSeq;

interface HDConfigHandler

{

int updateConfig(JsonSeq request, out JsonSeq response) throws InvokeError;

int deleteConfig(JsonSeq request, out JsonSeq response) throws InvokeError;

int queryState(JsonSeq request, out JsonSeq response) throws InvokeError;

int queryServiceState(out JsonSeq response) throws InvokeError;

}

}

使用EiInfo类组织上云配置二进制数据，在调用ConfigUpdate接口前：

调用SerializeEIClassToJSonV2接口将EiInfo转换为json字符串，该json字符串二进制数据作为ConfigUpdate接口的传入参数。

调用EiInfo类提供的Serialize接口将EiInfo对象序列化，作为传入参数传入ConfigUpdate。

成功返回0，失败返回错误码。

上云配置新增 / 更新：

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | type | int | 否 | 0为增量导入，1为全量导入
 | sumNum | int | 否 | 导入点数个数（单次导入点位上限为999）
 | tags | array | 否 | 导入点数信息列表，详见下表
返回值列表 |
 | response | object | 否 |
 | updatedTags | int | 否 | 导入tag个数
 | invalidTags | int | 否 | 未导入tag个数
 | reasons | array | 是 | 未导入原因列表
 | +reason | string | 是 | 未导入原因

序号 | 字段 | 英文名 | 是否必填项 | 定义 | 示例
1 | 机组号 | UNIT_NUMBER | 必填 | 边缘节点所在机组号，由运营中心牵头统一整理并提供规范，并在平台上提供录入和维护，在平台未上线前，线下获取。 | H032
2 | 边缘字段英文名称 | TAG_NAME | 必填 | ihd数据库中的tag点名 | BCU_FLAME-CURRENT_AA_BCM2
3 | 云上英文字段 | TAG_CLOUD_EN_NAME | 必填 | 按照字段规范，以数据元英文名称为基础进行扩展 | RADIA_PIPE_IGN_CON_CUR_AA_BCM2
4 | 云上中文字段 | TAG_CLOUD_CH_NAME | 选填 | 按照字段规范，以数据元英文名称为基础进行扩展 | BCM2辐射管点火控制器电流
5 | 引用数据元英文 | TAG_REFERENCE_EN_NAME | 选填 | 按照字段规范，以数据元中文名称为基础进行扩展 | HF_CHGMCH_ARM_ROUTE_ACT
6 | 引用数据元中文 | TAG_REFERENCE_CH_NAME | 选填（根据D列引用大数据中心数典功能，不需要人工填写） | 按照字段规范，以数据元中文名称为基础进行扩展 | 辐射管点火控制器电流
7 | 引用数据元标识符 | TAG_REFERENCE_SOURCE_IDENTIFIER | 选填（根据D列引用大数据中心数典功能，不需要人工填写） | 必填，数据元标识ID在数据元导出时会一并带上 | DEBG000000081721
8 | 工厂 | FACTORY | 选填 |  | baoshan
9 | 区域 | AREA | 选填 |  | cold-rolling
10 | 设备 | TAG_EQUIPMENT | 选填 | 设备名称 | CHGMCH_ARM
11 | 同步方式 | TAG_SYNC_TYPE | 必填 | 必填，填写0或者1，同步上云方式，0代表注册推送方式，1代表周期发送 | 1
12 | 数据采集间隔 | TAG_COLLECT_INTERVAL | 选填 | 针对PLC/传感器，表示数据分辨率，单位为ms | 1000
13 | 数据采样间隔(同步周期) | TAG_PERIOD | 必填 | 边缘采样的数据间隔，单位为ms，同步方式为1时该字段有效 | 1000
14 | 数据发送频率 | TAG_SEND_FREQUENCY | 必填 | 边缘向大数据中心发送采样数据的间隔，单位为ms，数据发送模式为DM时，该字段有效，其余发送模式，该字段无效 | 20
15 | 数据发送模式 | TAG_SEND_MODE | 必填 | D：单tag点单值 DM：单tag点多值 DMM：多tag点单值（时间不对齐） DMA：多tag点单值（时间对齐） 同步方式设置为周期式同步方式时该字段有效。同步方式为注册式同步方式时，该字段填写"DMM"。 | DMM
16 | 压缩率 | TAG_COMPDEV | 选填 | 默认为0，即不压缩 |
17 | 整数位 | TAG_INTEGER_NUMBER | 选填 | 表示上云数据的总位数(包括整数位数和小数位数)不能超出该值，非零值时该字段才生效，当tagvalue超出设置的整数位数时，会截断后面的数据。 | 整数位设置为3，有效数位为2，系数设置为1，ihd中tag点tagvalue为83.3421， 最终上云数据为83.3
18 | 有效数位 | TAG_EFFECTIVE_NUMBER | 选填 | 表示小数位位数不能超出该值，为非零值时该字段才生效，当tagvalue小数位超出设置的位数时，会截断后面的数据 | 整数位设置为5，有效数位为1，系数设置为1，ihd中tag点tagvalue为8343.3421， 最终上云数据为8343.3
19 | 系数 | TAG_COEFFICIENT | 选填 | 用于单位转换，把iHperDB中存储数据转换成符合云上存储的单位，为非零值时该字段有效。上云服务依次进行系数、有效数位、整数位的处理。 | 整数位设置为5，有效数位为1，系数设置为0.5，ihd中tag点tagvalue为100， 最终上云数据为50

上云配置删除：

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | tags | array | 否 | 待删除tag点名列表
 | +tagName | string | 否 | tag点名
返回值列表 |
 | response | object | 否 |
 | deletedTags | int | 否 | 待删除tag个数
 | invalidTags | int | 否 | 未删除tag个数
 | reasons | array | 是 | 未删除原因列表
 | +tagName | string | 是 | 未删除tag点名
 | +reason | string | 是 | 未删除原因

配置状态查询：

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | startTime | string | 否 | 查询开始时间，形如：2023-07-04T00:00:00
 | sendMode | string | 是 | tag点发送方式，如"DM"，不填时返回所有
返回值列表 |
 | response | object | 否 |
 | syncedTags | int | 否 | 上云发送点数
 | configedTags | int | 否 | 上云配置点数
 | bugTags | array | 是 | 问题点位列表
 | +tagName | string | 是 | 问题tag点名
 | +cloudEnName | string | 是 | 问题tag点云上英文名
 | +lastSyncTime | string | 是 | Unix时间（ms），如1689736706000

上云服务状态查询：

返回值列表 | 名称 | 类型 | 是否可空 | 备注
 | response | object | 否 |
 | result | int | 否 | 服务状态，0表示正在运行，1表示正在启动，2表示已停止
 | startTime | string | 否 | 服务启动时间，形如：2023-07-04T00:00:00
 | stopTime | string | 是 | 服务停止时间，形如：2023-07-04T00:00:00
 | reason | string | 是 | 服务停止原因

json示例：

配置更新：

输入示例：

{

"type": 0,

"sumNum": 2,

"tags": [

{

"UNIT_NUMBER": "0",

"TAG_NAME": "TagName0",

"TAG_CLOUD_EN_NAME": "tag0",

"TAG_CLOUD_CH_NAME": "标签0",

"TAG_REFERENCE_EN_NAME": "tag0",

"TAG_REFERENCE_CH_NAME": "refTag0",

"TAG_REFERENCE_SOURCE_IDENTIFIER": "",

"FACTORY": "factory",

"AREA": "area",

"TAG_EQUIPMENT": "Tag",

"TAG_SYNC_TYPE": 0,

"TAG_COLLECT_INTERVAL": 1,

"TAG_PERIOD": 1,

"TAG_SEND_FREQUENCY": 1,

"TAG_SEND_MODE": "D",

"TAG_COMPDEV": 0,

"TAG_INTEGER_NUMBER": 0,

"TAG_EFFECTIVE_NUMBER": 0,

"TAG_COEFFICIENT": 0

},

{

"UNIT_NUMBER": "1",

"TAG_NAME": "TagName1",

"TAG_CLOUD_EN_NAME": "tag1",

"TAG_CLOUD_CH_NAME": "标签1",

"TAG_REFERENCE_EN_NAME": "tag1",

"TAG_REFERENCE_CH_NAME": "refTag1",

"TAG_REFERENCE_SOURCE_IDENTIFIER": "",

"FACTORY": "factory",

"AREA": "area",

"TAG_EQUIPMENT": "Tag",

"TAG_SYNC_TYPE": 0,

"TAG_COLLECT_INTERVAL": 1,

"TAG_PERIOD": 1,

"TAG_SEND_FREQUENCY": 1,

"TAG_SEND_MODE": "D",

"TAG_COMPDEV": 0,

"TAG_INTEGER_NUMBER": 0,

"TAG_EFFECTIVE_NUMBER": 0,

"TAG_COEFFICIENT": 0

}

]

}

输出示例：

{

"updatedTags": 2,

"invalidTags": 2,

"reasons": [

{

"tagName": "TagName0",

"reason": "Invalid json field: TAG_SEND_MODE"

},

{

"tagName": "TagName1",

"reason": "Invalid json field: TAG_SEND_MODE"

}

]

}

配置删除：

输入示例：

{

"tags": [

{

"tagName": "TagName0"

},

{

"tagName": "TagName1"

}

]

}

输出示例：

{

"deletedTags": 2,

"invalidTags": 2,

"reasons": [

{

"tagName": "TagName0",

"reason": "No such tag."

},

{

"tagName": "TagName1",

"reason": "No such tag."

}

]

}

状态查询：

输入示例：

{

"startTime": "2023-07-05T09:00:00",

"sendMode": "D"

}

输出示例：

{

"syncedTags": 3,

"configedTags":10，

"bugTags": [

{

"tagName": "TagName0",

"cloudEnName": "TagName0"，

"lastSyncTime": "1689736706000"，

},

{

"tagName": "TagName1",

"cloudEnName": "TagName1"，

"lastSyncTime": "1689736706000"，

}

]

}

上云服务状态查询：

输出示例：

{

"result": 2,

"startTime":"2023-07-13T09:00:00",

"stoptime":"2023-07-13T09:00:00"，

"reason": "Disk full."

}


Tag点上云接口

Navigation: 功能明细 > 数据转储 > 数据上云 >

Tag点上云接口

 Return to chapter overview

S_BI_XD_3901 Tag点新增更新上云接口

S_BI_XD_3902 删除云上Tag点接口

S_BI_XD_3903 上云配置状态查询

S_BI_XD_3904 上云服务状态查询


S_BI_XD_3901 Tag点新增更新上云接口

Navigation: 功能明细 > 数据转储 > 数据上云 > Tag点上云接口 >

S_BI_XD_3901 Tag点新增更新上云接口

 Return to chapter overview

接口说明：

接口描述：新增、修改Tag点配置参数，支持单条和批量添加

接口服务ID：S_BI_XD_3901

请求服务名：BIXD3907

请求方法：insert

请求参数示例：

HTTP请求：[POST] /service/S_BI_XD_3901

HTTP请求体如下：

{

"__sys__": {

"msg": "",

"msgKey": "",

"detailMsg": "",

"status": 0

},

"__version__": "2.0",

"__blocks__": {},

"Ip": "10.25.10.34",

"port": "30000",

"type": 0,

"sumNum": 1,

"tags": [

{

"UNIT_NUMBER": "0",

"TAG_NAME": "TagName0",

"TAG_CLOUD_EN_NAME": "tag0",

"TAG_REFERENCE_CH_NAME": "refTag0",

"TAG_REFERENCE_EN_NAME": "tag0",

"TAG_REFERENCE_SOURCE_IDENTIFIER": "",

"TAG_SYNC_TYPE": 0,

"TAG_COLLECT_INTERVAL": 1,

"TAG_PERIOD": 1,

"TAG_SEND_FREQUENCY": 1,

"TAG_SEND_MODE": "D",

"TAG_COMPDEV": 0,

"TAG_INTEGER_NUMBER": 0,

"TAG_EFFECTIVE_NUMBER": 0,

"TAG_COEFFICIENT": 0

}

]

}

tag点详细信息字段对照表：

序号 | 字段 | 英文名 | 是否必填项 | 定义 | 示例
1 | 机组号 | UNIT_NUMBER | 必填 | 边缘节点所在机组号，由运营中心牵头统一整理并提供规范，并在平台上提供录入和维护，在平台未上线前，线下获取。 | H032
2 | 边缘字段英文名称 | TAG_NAME | 必填 | ihd数据库中的tag点名 | BCU_FLAME-CURRENT_AA_BCM2
3 | 云上英文字段 | TAG_CLOUD_EN_NAME | 必填 | 按照字段规范，以数据元英文名称为基础进行扩展 | RADIA_PIPE_IGN_CON_CUR_AA_BCM2
4 | 云上中文字段 | TAG_CLOUD_CH_NAME | 选填 | 按照字段规范，以数据元英文名称为基础进行扩展 | BCM2辐射管点火控制器电流
5 | 引用数据元英文 | TAG_REFERENCE_EN_NAME | 选填 | 按照字段规范，以数据元中文名称为基础进行扩展 | HF_CHGMCH_ARM_ROUTE_ACT
6 | 引用数据元中文 | TAG_REFERENCE_CH_NAME | 选填（根据D列引用大数据中心数典功能，不需要人工填写） | 按照字段规范，以数据元中文名称为基础进行扩展 | 辐射管点火控制器电流
7 | 引用数据元标识符 | TAG_REFERENCE_SOURCE_IDENTIFIER | 选填（根据D列引用大数据中心数典功能，不需要人工填写） | 必填，数据元标识ID在数据元导出时会一并带上 | DEBG000000081721
8 | 工厂 | FACTORY | 选填 |  | baoshan
9 | 区域 | AREA | 选填 |  | cold-rolling
10 | 设备 | TAG_EQUIPMENT | 选填 | 设备名称 | CHGMCH_ARM
11 | 同步方式 | TAG_SYNC_TYPE | 必填 | 必填，填写0或者1，同步上云方式，0代表注册推送方式，1代表周期发送 | 1
12 | 数据采集间隔 | TAG_COLLECT_INTERVAL | 选填 | 针对PLC/传感器，表示数据分辨率，单位为ms | 1000
13 | 数据采样间隔(同步周期) | TAG_PERIOD | 必填 | 边缘采样的数据间隔，单位为ms，同步方式为1时该字段有效 | 1000
14 | 数据发送频率 | TAG_SEND_FREQUENCY | 必填 | 边缘向大数据中心发送采样数据的间隔，单位为ms，数据发送模式为DM时，该字段有效，其余发送模式，该字段无效 | 20
15 | 数据发送模式 | TAG_SEND_MODE | 必填 | D：单tag点单值 DM：单tag点多值 DMM：多tag点单值（时间不对齐） DMA：多tag点单值（时间对齐） 同步方式设置为周期式同步方式时该字段有效。同步方式为注册式同步方式时，该字段填写"DMM"。 | DMM
16 | 压缩率 | TAG_COMPDEV | 选填 | 默认为0，即不压缩 |
17 | 整数位 | TAG_INTEGER_NUMBER | 选填 | 表示上云数据的总位数(包括整数位数和小数位数)不能超出该值，非零值时该字段才生效，当tagvalue超出设置的整数位数时，会截断后面的数据。 | 整数位设置为3，有效数位为2，系数设置为1，ihd中tag点tagvalue为83.3421， 最终上云数据为83.3
18 | 有效数位 | TAG_EFFECTIVE_NUMBER | 选填 | 表示小数位位数不能超出该值，为非零值时该字段才生效，当tagvalue小数位超出设置的位数时，会截断后面的数据 | 整数位设置为5，有效数位为1，系数设置为1，ihd中tag点tagvalue为8343.3421， 最终上云数据为8343.3
19 | 系数 | TAG_COEFFICIENT | 选填 | 用于单位转换，把iHperDB中存储数据转换成符合云上存储的单位，为非零值时该字段有效。上云服务依次进行系数、有效数位、整数位的处理。 | 整数位设置为5，有效数位为1，系数设置为0.5，ihd中tag点tagvalue为100， 最终上云数据为50

请求参数：

名称 | 类型 | 是否必需 | 最大长度 | 描述 | 默认值 | 示例
type | int | 是 |  | 0为增量导入，1为全量导入) | 无 | 0
sumNum | int | 是 | 999 | 导入点个数 | 无 | 999
tags | array | 是 |  | 导入点详细信息 | 无 |
port | string | 是 |  | 端口号 | 无 | "30000"
Ip | string | 是 |  | 数据源Ip地址 | 无 | "10.25.10.34"

返回参数：

 | 参数名 | 类型 | 描述 | 结果
1 | status | int | 错误码 0 成功 错误码 -1 失败 | outInfo.getStatus()
2 | msg | String | 错误信息 | outInfo.getMsg()
3 | resultList | List | 新增/更新上云tag点返回结果 | outInfo.get("resultList")

调用示例：

EiInfo eiInfo = new EiInfo();

// 要添加的tag点rows

List<Map<String, Object>> rows = new ArrayList<>();

Map row = new HashMap();

row.put("UNIT_NUMBER","0");

row.put("TAG_NAME","TagName0");

row.put("TAG_CLOUD_EN_NAME","tag0");

row.put("TAG_REFERENCE_EN_NAME","tag0");

row.put("TAG_REFERENCE_CH_NAME","refTag0");

row.put("AREA","area");

row.put("TAG_EQUIPMENT","Tag");

row.put("TAG_SYNC_TYPE",0);

row.put("TAG_COLLECT_INTERVAL",1);

row.put("TAG_PERIOD",1);

row.put("TAG_SEND_FREQUENCY",1);

row.put("TAG_SEND_MODE","D");

row.put("TAG_COMPDEV",0);

row.put("TAG_INTEGER_NUMBER",0);

row.put("TAG_EFFECTIVE_NUMBER",0);

row.put("TAG_COEFFICIENT",0);

rows.add(row);

eiInfo.set("Ip", "10.25.10.34");

eiInfo.set("port", "30000");

eiInfo.set("type", 0);

eiInfo.set("sumNum", 1);

eiInfo.set("rows", rows);

eiInfo.set(EiConstant.serviceId, "S_BI_XD_3901");

logger.info("request params :{}", JSON.toJSONString(eiInfo));

EiInfo outInfo = XServiceManager.call(eiInfo);

if (outInfo.getStatus() >= 0) {

// 成功

} else {

// 失败

}

返回示例：

{

"__sys__":{

"msg":"",

"traceId":"",

"detailMsg":"",

"msgKey":"",

"status":0

},

"__version__":"2.0",

"resultList":[

{

"updatedTags": 1,//导入tag个数

"invalidTags": 1,//未导入tag个数

"reasons": [//未导入原因列表

{

"tagName": "TagName0",

"reason": "Invalid json field: TAG_SEND_MODE"

}

]

"__blocks__":{

}

}


S_BI_XD_3902 删除云上Tag点接口

Navigation: 功能明细 > 数据转储 > 数据上云 > Tag点上云接口 >

S_BI_XD_3902 删除云上Tag点接口

 Return to chapter overview

接口说明：

接口描述：根据唯一标识符tag点名删除tag点

接口服务ID：S_BI_XD_3902

请求服务名：BIXD3907

请求方法：deleteRows

请求参数示例：

HTTP请求：[POST] /service/S_BI_XD_3902

HTTP请求体如下：

{

"__sys__": {

"msg": "",

"msgKey": "",

"detailMsg": "",

"status": 0

},

"__version__": "2.0",

"__blocks__": {},

"Ip": "10.25.10.34",

"port": "30000",

"tags": [

{

"tagName": "TagName0"

},

{

"tagName": "TagName1"

}

]

}

请求参数：

名称 | 类型 | 是否必需 | 最大长度 | 描述 | 默认值 | 示例
tags | array | 是 |  | 删除点点名列表 | 无 |
port | string | 是 |  | 端口号 | 无 | "30000"
Ip | string | 是 |  | 数据源Ip地址 | 无 | "10.25.10.34"

返回参数：

 | 参数名 | 类型 | 描述 | 结果
1 | status | int | 错误码 0 成功 错误码 -1 失败 | outInfo.getStatus()
2 | msg | String | 错误信息 | outInfo.getMsg()
3 | resultList | List | 返回信息 | outInfo.get("resultList")

调用示例：

EiInfo eiInfo = new EiInfo();

// 要添加的tag点rows

List<Map<String, Object>> rows= new ArrayList<>();

Map row = new HashMap();

row.put("tagName",tagName0);

Map row1 = new HashMap();

row1.put("tagName","tagName1");

rows.add(row);

rows.add(row1);

eiInfo.set("tags", rows);

eiInfo.set("Ip", "10.25.10.34");

eiInfo.set("port", "30000");

eiInfo.set(EiConstant.serviceId, "S_BI_XD_3902");

logger.info("request params :{}", JSON.toJSONString(eiInfo));

EiInfo outInfo = XServiceManager.call(eiInfo);

if (outInfo.getStatus() >= 0) {

// 成功

} else {

// 失败

}

返回示例：

{

"__sys__":{

"msg":"",

"traceId":"",

"detailMsg":"",

"msgKey":"",

"status":0

},

"__version__":"2.0",

"resultList":[

{

"deletedTags": 2,//待删除tag个数

"invalidTags": 2,//未删除tag个数

"reasons": [//未删除原因列表

{

"tagName": "TagName0",

"reason": "No such tag."

},

{

"tagName": "TagName1",

"reason": "No such tag."

}

],

"__blocks__":{

}

}


S_BI_XD_3903 上云配置状态查询

Navigation: 功能明细 > 数据转储 > 数据上云 > Tag点上云接口 >

S_BI_XD_3903 上云配置状态查询

 Return to chapter overview

接口说明：

接口描述：根据开始时间查询到当前时间上云的发送点数和配置点数

接口服务ID：S_BI_XD_3903

请求服务名：BIXD3907

请求方法：queryState

请求参数示例：

HTTP请求：[POST] /service/S_BI_XD_3903

HTTP请求体如下：

{

"__sys__": {

"msg": "",

"msgKey": "",

"detailMsg": "",

"status": 0

},

"__version__": "2.0",

"__blocks__": {},

"Ip": "10.25.10.34",

"port": "30000",

"startTime": "2023-07-04T00:00:00"

}

请求参数：

名称 | 类型 | 是否必需 | 最大长度 | 描述 | 默认值 | 示例
startTime | string | 是 |  | 查询开始时间 | 无 | 2023-07-04T00:00:00
sendMode | string | 否 |  | tag点发送方式，不填时返回所有类型 | 无 | "DM"
port | string | 是 |  | 端口号 | 无 | "30000"
Ip | string | 是 |  | 数据源Ip地址 | 无 | "10.25.10.34"

返回参数：

 | 参数名 | 类型 | 描述 | 结果
1 | status | int | 错误码 0 成功 错误码 -1 失败 | outInfo.getStatus()
2 | msg | String | 错误信息 | outInfo.getMsg()
3 | Ip | String | 数据源地址 | outInfo.get("Ip")

调用示例：

EiInfo eiInfo = new EiInfo();i

eiInfo.set("Ip", "10.25.10.34");

eiInfo.set("port", "30000");

eiInfo.set("startTime", "2023-07-04T00:00:00");

eiInfo.set("sendMode", "DM");

eiInfo.set(EiConstant.serviceId, "S_BI_XD_3903");

logger.info("request params :{}", JSON.toJSONString(eiInfo));

EiInfo outInfo = XServiceManager.call(eiInfo);

if (outInfo.getStatus() >= 0) {

// 成功

} else {

// 失败

}

返回示例：

{

"__sys__":{

"traceId":"",

"detailMsg":"",

"msgKey":"",

"status":0

},

"__version__":"2.0",

"msg":[

{

"syncedTags": 3,//上云发送点数

"configedTags":10，//上云配置点数

"bugTags": [ //问题点位列表

{

"tagName": "TagName0",

"cloudEnName": "TagName0"，

"lastSyncTime": "1689736706000"，

},

{

"tagName": "TagName1",

"cloudEnName": "TagName1"，

"lastSyncTime": "1689736706000"，

}

],

"Ip": "10.25.10.34", //数据源地址

"__blocks__":{

}

}


S_BI_XD_3904 上云服务状态查询

Navigation: 功能明细 > 数据转储 > 数据上云 > Tag点上云接口 >

S_BI_XD_3904 上云服务状态查询

 Return to chapter overview

接口说明：

接口描述：查询上云服务的状态、起停时间及停止原因

接口服务ID：S_BI_XD_3904

请求服务名：BIXD3907

请求方法：queryServiceState

请求参数示例：

HTTP请求：[POST] /service/S_BI_XD_3904

HTTP请求体如下：

{

"__sys__": {

"msg": "",

"msgKey": "",

"detailMsg": "",

"status": 0

},

"Ip": "10.25.10.34",

"port": "30000",

"__version__": "2.0",

"__blocks__": {}

}

请求参数：

名称 | 类型 | 是否必需 | 最大长度 | 描述 | 默认值 | 示例
port | string | 是 |  | 端口号 | 无 | "30000"
IP | string | 是 |  | 数据源Ip地址 | 无 | "10.25.10.34"

返回参数：

 | 参数名 | 类型 | 描述 | 结果
1 | status | int | 错误码 0 成功 错误码 -1 失败 | outInfo.getStatus()
2 | msg | String | 错误信息 | outInfo.getMsg()
3 | resultList | List | 返回结果 | outInfo.get(”resultList“)

返回示例：

{

"__sys__":{

"msg":"",

"traceId":"",

"detailMsg":"",

"msgKey":"",

"status":0

},

"__version__":"2.0",

"resultList":[

{

"result": 2,//服务状态，0表示正在运行，1表示正在启动，2表示已停止

"startTime":"2023-07-13T09:00:00",//服务启动时间

"stoptime":"2023-07-13T09:00:00"，//服务停止时间

"reason": "Disk full."//服务停止原因

}


数据接口

Navigation: 功能明细 >

数据接口

 Return to chapter overview

下面介绍实时数据库对外提供的快捷数据接口，其他C++/Java/C#/python接口请参考SDK帮助手册。

·iHD OPC SERVER

·iHD OPCUA SERVER

·COM接口

·ODBC Driver

·WebAPI

©2015. All Rights Reserved.


iHD OPC SERVER

iHD OPC SERVER 数据发布服务

Navigation: 功能明细 > 数据接口 >

iHD OPC SERVER 数据发布服务

 Return to chapter overview

实时数据库提供OPC Server数据发布功能，供OPC客户端访问iHyperDB。通过OPC 发布点的值、时间戳和数据质量信息。iHyperDB支持对普通点、统计点和计算点进行OPC 发布。

1.安装OPC Server

实时数据库OPC Server安装运行在iHyperDB客户端。

注：默认安装的iHD OPC Server其配置文件中Server IP是本机local IP地址。安装完成后要修改该IP，可在安装路径下的config文件夹中找到OPCServer.xml文件进行修改。

参数说明：

vname：OPC Server名，即OPC客户端可见的信号点名的前缀名；

vmainip：所发布的iHyperDB数据库主服务器IP地址，缺省为本机local ip，安装后请照实修改；

vmainport：所发布的iHyperDB数据库主服务器端口号，默认为“5673”；

vbackip：所发布的iHyperDB数据库备用服务器IP地址，如有可照实填写；

vbackport：所发布的iHyperDB数据库备用服务器端口号，默认为“5673”；

2.实时数据库Tag点修改配置为可OPC Server发布

在系统管理工具→数据源→Tag变量配置中添加、修改Tag点时可以对当前Tag点的OPC发布状态进行修改。

勾选是否OPC发布复选框，即设置该点OPC发布状态为通过OPC发布。保存配置使之生效。

发布限制注意事项：

1.只有普通点、统计点和计算点可以设置为OPC发布，报警点和SPC报警点不可以进行OPC发布；

2.新建Tag点时默认不进行OPC发布，需人工修改设置使之生效。

3.通过Excel插件配置修改Tag点表，批量方式修改OPC发布状态。

实时数据库Excel插件中提供批量设置Tag点OPC发布状态方法， 数值“1”表示发布,“0”为不发布。

4.连接测试

OPC Server安装成功后，可通过第三方OPC Client（比如下图例中的第三方产品Matrikon OPC Explorer）进行连接测试。

在OPC Server本机运行第三方OPC Client，可避免繁琐的DCOM配置。

Matrikon OPC Explorer通讯测试说明：

在已注册的OPC Server List中可以看到OPCServer.HDServer，即为当前安装成功的iHyperDB OPC Server的名称。如果在OPCServer.xml文件修改了name为“XX”，则此处看到的就会是“OPCServer.XX”。

连接server,添加group，添加Item,如下所示：

Avaliable Tags 列表中显示当前连接的iHyperDB服务器中已经发布的Tag点，选中添加Tag点。

OPC Client界面中显示选中点的value、time和Quality信息。


iHD OPCUA SERVER

iHD OPCUA SERVER 数据发布服务

Navigation: 功能明细 > 数据接口 >

iHD OPCUA SERVER 数据发布服务

 Return to chapter overview

实时数据库V3.7.5版本开始提供OPCUA Server数据发布功能，OPCUA数据发布服务hdopcua可将实时数据库中的tag点，以OPCUA方式发布。

1.安装OPCUA Server

实时数据库V3.7.5版本安装完成，自带OPCUA数据发布服务hdopcua。该服务运行在iHyperDB数据库服务端。实时数据库V3.7.5版本安装完成后，需要对配置文件hdopcua.xml部分参数根据项目实际情况进行修改。

ihdopcua数据发布服务的配置文件hdopcua.xml保存在ihyperdb\executable_x64 下，配置文件如下：

<?xml version="1.0" encoding="utf-8"?>

<Cfg>

<TargetHD mainip="10.25.14.231" mainport="5673" backupip="" backupport=""/>

<hdopcua opcuaport = "4430" cyclerate = "10" />

</Cfg>

参数说明：

TargetHD：目的ihd配置；

vmainip：主机IP，安装后请照实修改；

vmainport：主机端口，默认为“5673”；

vbackupip：备机IP，如有可照实填写；

vbackupport：备机端口，默认为“5673”；

hdopcua：opcua服务相关配置；

vopcuaport：opcua服务发布端口号，默认为“4430”，opcua服务发布的ip地址即为本机ip地址；

vcyclerate：从opcua数据发布服务获取数据的周期时间，单位为ms。

2.通过Excel插件配置修改Tag点表，批量方式修改OPCUA发布状态。

实时数据库中tag点是否开启opcua发布，是通过修改tag点表中“保留参数1”项目值来定义。值为“0”表示不通过opcua发布，值为“1”表示可通过opcua发布。

1)通过excel插件，点击下载tag点表到本地；

2)将需要进行opcua发布的tag点属性列中的“保留参数1”，修改值为“1”；

3)完成修改后，重新上传tag点表；

3.启用hdopcua数据发布服务

点击目录下的“数据节点服务管理工具”，如下图：

在数据节点服务管理工具的“进程管理”中可查看实时数据库OPCUA发布服务（hdOpcua）状态，以及启动/停止服务，如下图：

4.通过第三方opc客户端（Softing OPC Client）测试连接

打开Softing OPC Client，点击左侧add session选项，在弹出的对话框中，Endpoint Url输入框中输入连接的opcua服务地址，如下图所示：

Endpoint Url填写我们OPCUA SERVER的地址，如第三方opc客户端安装运行于服务器本地，则该项参数可以写作“opc.tcp://127.0.0.1:4430”；如果运行在异地，则该项参数可以写作“opc.tcp://opcua服务器ip:4430”。

点击ok后，如果连接正常，可以在服务的Objects选项下看到该opcua服务中发布的tag点，如下图：

通过双击上图相应tag点，可以订阅相应tag点的实时记录值，在DataAccess选项下可以查看相应tag点的实时记录值，其中Source Timestamp对应ihd中的时间戳。如下图所示：

5.通过iPlat-BA OPCUA 驱动测试连接

1)添加OPCUA驱动

首先，配置好相应的iPlat-BA SCADA节点。

点击SCADA节点下的“驱动配置”，进入驱动配置页面。鼠标置于页面的左上方，如下图，可以看到“添加驱动”的按钮，点击“添加驱动”，弹出可用驱动的选择对话框，在可用驱动列表中，选择OPCUA驱动所对应的“opcuadrv”，然后点击“确定”。

签出该驱动，点击“保存”按钮。

弹出OPCUA驱动配置的主界面，填写opcua服务器地址，保存并签入已修改配置。

2)服务器配置

添加服务器。在驱动配置界面上，右键点击树控件列表中的驱动名称节点，弹出右键菜单，选择“添加设备”，如下图：

在点击了“添加服务器”之后，会弹出“添加OPCUAServer”的对话框，在这个对话框中，填写opcua服务器的信息：

3)组配置

在驱动配置界面上，右键点击树控件列表中的服务器名称节点，弹出右键菜单：

选择“添加数据块”，弹出组配置对话框：

填写相应参数，参数说明：

v名称： 不能为空，且不能重复。可输入1-31个字符；

v描述： 可输入0-63个字符；

v任务号：

vIO方式：包含异步和同步两个选项；

v轮询周期：只在I/O方式为同步读取时可配，为OPCUA客户端到服务器读数据的周期。在1ms-24H之间，必须是100的正整数倍。默认值：同步时值为1秒；异步时值为50秒。

v异步超时：只在I/O方式为异步读取时可配，在1ms-24H之间，必须是100的正整数倍。值必须大于轮询周期。默认值:1000秒 。

以上，完成配置，点击保存按钮，系统增加该组。

4)节点配置

a)在驱动配置界面，左键点击树控件列表中的组名称节点，弹出设备信息：

b)选择“编辑节点”选项，弹出节点对话框：

c)点击“节点ID”左上方的“增加”按钮，系统会将该节点添加到界面右侧的列表中。可以使用ctrl或者shift键选择多个点进行批量添加。

d)在列表中，选择一条或多条记录，右上方删除按钮可用，点击“删除确定”弹出删除对话框，选择确定从列表中删除。可以使用ctrl或者shift键选择多个点进行批量删除。

e)点击保存按钮，将界面列表中的记录保存，并显示在界面列表中。

注意：节点ID即变量的地址，格式为：NS1|String|***，***表示ihd中的tag点名称。变量类型与数据类型请根据实际类型进行选择。

5)OPCUA变量配置

配置好opcuadrv的驱动后，需要在驱动的设备变量管理中添加相应变量，见下图：

变量也可以通过excel文件批量导入导出，见下图：

注意：变量的名称即为ihd中tag点名称，变量地址格式为NS1|String|***，***表示ihd中的tag点名称。注意变量类型与ihd数据类型的匹配。

6)驱动配置文件 opcuadrv.xml 如下：

<?xml version="1.0" encoding="GB2312" ?>

<driver name="opcuadrv" type="item">

<device name="opcua_test1" conntype="other" connparam="opc.tcp://localhost:4840" recvtimeout="1000" param3="" param2="1000000" param1="0" cyclerate="1000" task="1" desc="">

<datablock address="NS1|String|midvar_1" name="NS1|String|midvar_1" elemcount="1" elembytes="2" param1="Word" param2="AI" param3="0" />

<datablock address="NS1|String|midvar_aifloat" name="NS1|String|midvar_aifloat" elemcount="1" elembytes="4" param1="Float" param2="AI" param3="6" />

<datablock address="NS1|String|midvar_blob" name="NS1|String|midvar_blob" elemcount="1" elembytes="256" param1="String" param2="TXT" param3="-1" />

<datablock address="NS1|String|midvar_di" name="NS1|String|midvar_di" elemcount="1" elembytes="1" param1="Boolean" param2="DI" param3="-1" />

<datablock address="NS1|String|midvar_txt" name="NS1|String|midvar_txt" elemcount="1" elembytes="256" param1="String" param2="TXT" param3="-1" />

<datablock address="NS1|String|midvarai32" name="NS1|String|midvarai32" elemcount="1" elembytes="4" param1="DWord" param2="AI" param3="2" />

</device>

<device name="opcua_test2" conntype="other" connparam="opc.tcp://localhost:4840" recvtimeout="1000" param3="" param2="600000" param1="1" cyclerate="50000" task="2" desc="test">

<datablock address="NS0|Numeric|7650" name="NS0|Numeric|7650" elemcount="1" elembytes="256" param1="String" param2="TXT" param3="-1" />

<datablock address="NS0|Numeric|7656" name="NS0|Numeric|7656" elemcount="1" elembytes="256" param1="String" param2="TXT" param3="-1" />

</device>

</driver>


HDPubServer

Navigation: 功能明细 > 数据接口 >

HDPubServer

 Return to chapter overview

HDPubServer是基于iHD实时数据库扩展的数据传输服务。主要用于将iHD实时数据库中的数据发送到iPlat-dm模块，HDPubServer运行于iHD实时数据库服务端。HDPubServer具备接受注册、推送和查询等功能，配合主备iHD服务器，支持主备服务，供iPlat-dm模块选择调动。同时在主/备iHD服务器上运行的HDPubServer服务，dm可自动进行连接和切换。一个iPlat-dm模块可配置多个HDPubServer连接。

·环境要求

服务端支持操作系统：Windows、Linux；

网络连接：RJ-45以太网传输速率100Mbps以上,推荐1Gbps及以上。服务器需对外开放端口5674。

·HDPubServer端配置

HDPubServer配置文件位于iHyperDB的【config】目录下，配置文件名：HDPubServer.xml，文件内容如下：

<?xml version="1.0" encoding="utf-8" ?>

<HDPubServer version="1.0">

<HostAddr IP="127.0.0.1" port="5673" /> //连接IHD地址和端口

<BackupAddr IP="" port="" />

<ThreadNum thread_number="32" /> //处理线程数

<PublishFreq refresh_time="50"/> //推送频率（单位：毫秒）

<CheckHeartbeatsFreq check_time = "1000"/> //心跳查询间隔（单位：毫秒）

<ClientHeartbeatsInterval heartbeats_interval = "180" /> //客户端断开时间限制（单位：秒）

<UpdateTagInterval update_interval = "60000" /> //线程更新tag频率（单位：毫秒）

<LogMonitor tag_id = "12" /> //推送打印，跟踪tag ID

<PackageSize package_size = "4193304" /> //发送包大小限制（单位：byte）

<ServiceUrl url = "http://10.25.10.32:8080/iplat/service/S_BI_OP_10" /> //追踪调用链日志上传接口

<RequestTimeout request_timeout = "5" /> //IHD请求超时时间

<Login user = "" password = "" /> //连接IHD用户名密码

<Encoding transfer_encoding = "2" /> //pubserver编码配置

<Reregister reregister_time="60000" /> //重新注册检测周期

<FullPush full_push="1" /> //全量推送

<Port port="5674" /> //HDPubServer 端口

</HDPubServer>

配置文件参数说明：

HostAddr：iHD主机参数；

vIP：主机地址，按实填写；

vport：主机端口，按实填写，缺省“5673”；

BackAddr：iHD备机参数；

vIP：备机地址，如有则填；

vport：备机端口，如有则填；

ThreadNum：

vthread_number：程序线程数；

如需多线程查询历史记录，则需修改ThreadNum参数与RequestTimeout参数（单位秒）

ThreadNum推荐配置为CPU核数的两倍，

RequestTimeout推荐等于或略微小于DM配置中的iplat.bi.dx.rdaRequestTimeout参数

PublishFreq：

vrefresh_time：推送频率，单位ms；

CheckHeartbeatsFreq：

vcheck_time：心跳检测频率，单位ms；

ClientHeartbeatsInterval：

vheartbeats_interval：心跳间隔，单位s；

UpdateTagInterval：

vupdate_interval：tag点刷新频率，单位ms；

LogMonitor：

vtag_id：用于帮助查找分析故障用，定位任意一个ihd实时数据库中的非系统点，均可。

编码配置Encoding中1代表ihd中数据编码是gbk，2代表ihd中数据编码是utf-8，默认是utf-8目前PubServer只支持这两种编码。IHD存储所有数据的编码格式需要一致，编码配置和存储格式也要一致，否则iPlat显示时会出现乱码。全量推送配置中0代表值变化推送，1代表全量推送，默认是值变化推送。

·iPlat-dm端配置

正式使用HDPubServer之前，需在iPlat-dm端进行对应配置。配置页面：iplat-dm/web/BIDH01，地址和端口需要与HDPubServer所部署的参数对应。

当一个iPlat-dm模块需要配置多个HDPubServer的节点时，类似上图黄色高亮部分（地址参数项）内可填写多个IP地址。注意填写规范：不同节点地址间用半角分号“;”分隔。

·功能明细

HDPubServer接受iPlat-dm模块的请求，并反馈信息。支持如下功能：

v注册、推送：HDPubServer接受iPlat-dm模块的注册，根据iPlat-dm模块提供的信号点表推送tag数据（逢变则传）；

v历史记录查询：根据iPlat-dm模块提供的查询条件，可以查询过去一段时间的历史记录或插值历史记录；

v批量同步读：支持批量查询tag点；

v条件查询：支持根据iPlat-dm模块提供的查询条件，查询返回tag点及其数值。

vTag点详情信息查询：支持查询点值量程、质量、时间戳等信息，具体支持的域如下：

默认不填 当前值vtq

timestamp 时间戳

quality 质量

A_DESC 描述

F_VALUE_LOW 最小值

F_VALUE_SPAN 量程

F_EGU_LOW 最小值

F_EGU_SPAN 量程

A_EGU_LBL 工程单位

A_CV 当前值vtq 与默认不填一样

F_CV 当前值vtq 与默认不填一样

A_TIMESTAMP 时间戳 与timestamp一样

F_TIMESTAMP 时间戳 与timestamp一样

A_QUALITY 质量 与quality一样

F_QUALITY 质量 返回实际质量数值

相关iPlat-dm模块的使用及配置，请查阅iPlat-dm模块手册。

对于AI和AO点：F_VALUE_LOW 最小值 。不开启量程转换是点的数据类型的最小值，开启量程转换对应工程量程的最小值。

F_VALUE_SPAN 量程范围（最大值-最小值，非负数）。不开启量程转换对应点的数据类型的量程范围，开启量程转换对应工程量程的范围。

对于DI和DO点：F_VALUE_LOW 是0；

F_VALUE_SPAN 值为1

·启动和关闭

启动HDPubServer之前，请确认config目录下有配置文件HDPubServer.xml。

vwindows系统下启动/关闭

使用数据节点服务管理工具，勾选HDPubServer，并点选启动/停止按钮；或直接在文件资源管理器中双击HDPubServer.exe启动，在该进程窗口按“q”键退出。

vlinux系统下启动/关闭

linux系统下，运行启动脚本hdstart启动，运行停止脚本hdstop停止。


COM接口

Navigation: 功能明细 > 数据接口 >

COM接口

 Return to chapter overview

·VB接口

·VC接口

·com在icv中的使用

·com在ifix中的使用

©2015. All Rights Reserved.


VB 接口

Navigation: 功能明细 > 数据接口 > COM接口 >

VB 接口

 Return to chapter overview

·连接服务器com_nt_connect

·断开服务器com_nt_disconnect

·用户登录com_sc_login

·查询实时记录（单点查询）com_sn_query_snapshot

·查询实时记录（多点查询） com_sn_query_snapshots

·插值查询（单点查询）com_ar_query_interp_record_by_mode

·插值查询（单点多记录查询）com_ar_query_interp_records_by_mode

·根据时间段查询单点历史记录com_ar_query_raw_records

·根据时间段查询单点历史记录条数com_ar_query_raw_records_number

·根据点名查询ID号（单点查询）com_pt_query_tagid

·根据点名查询ID号（多点查询）com_pt_query_tagids

·转换数字类型的时间为字符串com_convert_time_2_bstr

·转换字符串类型的时间为数字com_convert_bstr_2_time

·根据时间段查询单点最小值com_ar_query_min_record

·根据时间段查询单点最大值com_ar_query_max_record

·根据时间段查询单点算数平均值com_ar_query_mean_records


连接服务器com_nt_connect

Navigation: 功能明细 > 数据接口 > COM接口 > VB 接口 >

连接服务器com_nt_connect

 Return to chapter overview

函数

STDMETHOD(com_nt_connect)(

BSTR szIP,

LONG nPort,

BSTR szBakIP,

LONG nBakPort,

LONG nTimeOut,

LONG* nRetErr

);

参数

[in] BSTR szIP, 服务器ip

[in] LONG nPort, 服务器端口号

[in] BSTR szBakIP, 备服务器ip

[in] LONG nBakPort, 备服务器端口号

[in] LONG nTimeOut, 连接超时

[out,retval]LONG* nRetErr，返回值

返回值

连接成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

连接服务器函数。连接成功后调用com_nt_disconnect来断开与服务器的连接，com_nt_connect和com_nt_disconnect采用引用计算，需要确保成对使用。

举例

Set objArray= CreateObject("hdCOMInterface.hdCOMClass.1")

Dim ip,port,bakip,bakport,timeout

ip= "127.0.0.1"

port= 5678

bakip = "1.2.3.4"

bakport = 1234

timeout= 3

Dim ret

objArray.com_nt_connect ip,port,bakip,bakport,timeout

Dim usrname,password,result

usrname= "test"

password="test"

result = CLng(objArray.com_sc_login (usrname,password))

objArray.com_nt_disconnect

Msgbox "login result is:" &result

Set objArray= nothing

©2015. All Rights Reserved.


断开服务器com_nt_disconnect

Navigation: 功能明细 > 数据接口 > COM接口 > VB 接口 >

断开服务器com_nt_disconnect

 Return to chapter overview

函数

断开服务器连接

STDMETHOD(com_nt_disconnect)(

LONG* nRetErr

);

参数

[out,retval]LONG* nRetErr，返回值

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

断开服务器函数。com_nt_connect和com_nt_disconnect采用引用计算，需要确保成对使用。

举例

Set objArray= CreateObject("hdCOMInterface.hdCOMClass.1")

Dim ip,port,bakip,bakport,timeout

ip= "127.0.0.1"

port= 5678

bakip = "1.2.3.4"

bakport = 1234

timeout= 3

Dim ret

objArray.com_nt_connect ip,port,bakip,bakport,timeout

Dim usrname,password,result

usrname= "test"

password="test"

result = CLng(objArray.com_sc_login (usrname,password))

objArray.com_nt_disconnect

Msgbox "login result is:" &result

Set objArray= nothing

©2015. All Rights Reserved.


用户登录com_sc_login

Navigation: 功能明细 > 数据接口 > COM接口 > VB 接口 >

用户登录com_sc_login

 Return to chapter overview

函数

STDMETHOD(com_sc_login)(

BSTRszUserName,

BSTRszPassWord,

LONG* nRetErr

);

参数

[in] BSTRszUserName, 用户名称

[in]BSTRszPassWord, 用户密码

[out,retval]LONG* nRetErr);返回值

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

用户登录函数。用于在一台服务器上进行用户登录操作。

举例

Set objArray= CreateObject("hdCOMInterface.hdCOMClass.1")

Dim ip,port,bakip,bakport,timeout

ip= "127.0.0.1"

port= 5678

bakip = "1.2.3.4"

bakport = 1234

timeout= 3

Dim ret

objArray.com_nt_connect ip,port,bakip,bakport,timeout

Dim usrname,password,result

usrname= "test"

password="test"

result = CLng(objArray.com_sc_login (usrname,password))

objArray.com_nt_disconnect

Msgbox "login result is:" &result

Set objArray= nothing

©2015. All Rights Reserved.


查询实时记录（单点查询）com_sn_query_snapshot

Navigation: 功能明细 > 数据接口 > COM接口 > VB 接口 >

查询实时记录（单点查询）com_sn_query_snapshot

 Return to chapter overview

函数

STDMETHOD(com_sn_query_snapshot)(

LONGnTagID,

VARIANT* nSec,

VARIANT* nMsec,

VARIANT* nQuality,

VARIANT* nTagType,

VARIANT* bsValue,

LONG* nRetErr

);

参数

[in]LONGnTagID, TagID

[out]VARIANT* nSec, 实时记录的秒，nSec->vt = VT_I4

[out]VARIANT* nMsec, 实时记录的毫秒，nMsec->vt = VT_I4

[out]VARIANT* nQuality,实时记录的数据质量，nQuality->vt = VT_I4

[out]VARIANT* nTagType, 实时记录的Tag类型，nTagType->vt = VT_I4

[out]VARIANT* bsValue, 实时记录的值，bsValue->vt = VT_BSTR

[out,retval]LONG* nRetErr返回值

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

查询实时记录（单点查询）函数。该函数用来查询一个Tag保存在内存快照中的最新记录。返回的实时记录的值用字符串的形式表示。

举例

Set objArray= CreateObject("hdCOMInterface.hdCOMClass.1")

Dim ip,port,bakip,bakport,timeout

ip= "127.0.0.1"

port= 5678

bakip = "1.2.3.4"

bakport = 1234

timeout= 3

Dim ret

objArray.com_nt_connect ip,port,bakip,bakport,timeout

Dim id,result

id=5

Dim nsec,nmsec,nquality,ntype,nvalue

result = CLng(objArray.com_sn_query_snapshot(id,nsec,nmsec,nquality,ntype,nvalue))

Msgbox "com_sn_query_snapshot错误码是：" &result

if result=0 then

Msgbox "sec is:" &nsec

Msgbox "msec is:" &nmsec

Msgbox "quality is:" &nquality

Msgbox "type is:" &ntype

Msgbox "value is:" &nvalue

end if

objArray.com_nt_disconnect

Set objArray= nothing

©2015. All Rights Reserved.


查询实时记录（多点查询）com_sn_query_snapshots

Navigation: 功能明细 > 数据接口 > COM接口 > VB 接口 >

查询实时记录（多点查询）com_sn_query_snapshots

 Return to chapter overview

函数

STDMETHOD(com_sn_query_snapshots)(

LONGnRecNum,

VARIANT* nTagIDs,

VARIANT* nSec,

VARIANT* nMsec,

VARIANT* nQuality,

VARIANT* nTagType,

VARIANT* bsValue,

VARIANT* nErrCodes,

LONG* nRetErr

);

参数

[in]LONGnRecNum, 查询的实时记录的数量，不能超过65535

[in]VARIANT* nTagIDs, TagID数组,必须是LONG类型的

[out]VARIANT* nSec, 实时记录的秒数组，nSec->vt = VT_ARRAY | VT_VARIANT

[out]VARIANT* nMsec, 实时记录的毫秒数组，nMsec->vt = VT_ARRAY | VT_VARIANT

[out]VARIANT* nQuality,实时记录的数据质量数组，nQuality->vt = VT_ARRAY | VT_VARIANT

[out]VARIANT* nTagType, 实时记录的Tag类型数组，nTagType->vt = VT_ARRAY | VT_VARIANT

[out]VARIANT* bsValue, 实时记录的值数组，bsValue->vt = VT_ARRAY | VT_VARIANT

[out]VARIANT* nErrCodes, 实时记录的错误码数组，nErrCodes->vt = VT_ARRAY | VT_VARIANT

[out,retval]LONG* nRetErr,返回值

返回值

查询成功，返回RD_SUCCESS，不是所有的都成功返回EC_HD_API_QUERY_SNAPSHOTS_FAILED。查询失败返回其它错误码，见error_code.h。

说明

查询实时记录（多点查询）函数。通过TagID数组查询多个Tag的内存快照中的最新记录。

返回RD_SUCCESS，表示所有的内存快照都查询成功；返回EC_HD_API_QUERY_SNAPSHOTS_FAILED，表明不是所有查询都成功；返回其它错误码表明查询失败，具体的错误码保存在nErrorCode数组中。

举例

Set objArray= CreateObject("hdCOMInterface.hdCOMClass.1")

Dim ip,port,bakip,bakport,timeout

ip= "127.0.0.1"

port= 5678

bakip = "1.2.3.4"

bakport = 1234

timeout= 3

Dim ret

objArray.com_nt_connect ip,port,bakip,bakport,timeout

Dim ids

ids=Array(CLng(1),CLng(2),CLng(300))

Dim recnum

recnum=3

Dim nsec,nmsec,nquality,ntype,nvalue,nerrcode,result

result = CLng(objArray.com_sn_query_snapshots (recnum,ids,nsec,nmsec,nquality,ntype,nvalue,nerrcode))

Msgbox "com_sn_query_snapshot错误码是：" &result

if result=0 or result=119610 then

Dim x6,showerrcode

showerrcode = "调用后errcode:"

for x6= LBound(nerrcode) to UBound(nerrcode)

showerrcode = showerrcode & nerrcode(x6) & "; "

next

MsgBox showerrcode

Dim x1,showsec

showsec = "调用后sec:"

for x1= LBound(nsec) to UBound(nsec)

showsec = showsec & nsec(x1) & "; "

next

MsgBox showsec

Dim x2,showmsec

showmsec = "调用后msec:"

for x2= LBound(nmsec) to UBound(nmsec)

showmsec = showmsec & nmsec(x2) & "; "

next

MsgBox showmsec

Dim x3,showquality

showquality = "调用后quality:"

for x3= LBound(nquality) to UBound(nquality)

showquality = showquality & nquality(x3) & "; "

next

MsgBox showquality

Dim x4,showtype

showtype = "调用后type:"

for x4= LBound(ntype) to UBound(ntype)

showtype = showtype & ntype(x4) & "; "

next

MsgBox showtype

Dim x5,showvalue

showvalue = "调用后Value:"

for x5= LBound(nvalue) to UBound(nvalue)

showvalue = showvalue & nvalue(x5) & "; "

next

MsgBox showvalue

end if

objArray.com_nt_disconnect

Set objArray= nothing

©2015. All Rights Reserved.


插值查询（单点查询）com_ar_query_interp_record_by_mode

Navigation: 功能明细 > 数据接口 > COM接口 > VB 接口 >

插值查询（单点查询）com_ar_query_interp_record_by_mode

 Return to chapter overview

函数

STDMETHOD (com_ar_query_interp_record_by_mode)(

LONGnMode,

LONGnTagID,

VARIANT* nSec,

VARIANT* nMsec,

VARIANT* nQuality,

VARIANT* nTagType,

VARIANT* bsValue,

LONG* nRetErr

);

参数

[in]LONGnMode,插值类型，值为1表示前向插值；值为0表示线性插值。

[in]LONGnTagID, TagID。

[in,out]VARIANT* nSec, 插值时间戳的秒，必须是LONG类型，nSec->vt = VT_I4

[in,out]VARIANT* nMsec, 插值时间戳的毫秒，必须是LONG类型，必须是LONG类型，nMsec->vt = VT_I4

[out]VARIANT* nQuality,记录的数据质量，nQuality->vt = VT_I4

[out]VARIANT* nTagType, 记录的Tag类型，nTagType->vt = VT_I4

[out]VARIANT* bsValue, 记录的值，bsValue->vt = VT_BSTR

[out,retval]LONG* nRetErr，返回值

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

iHyperDB的8种数据类型都支持插值查询。

根据数据实际采集及压缩策略，原始历史数据曲线可能存在数据点时间间隔不均，曲线过于抖动或锐化，通过插值方式可以在现有数据逻辑基础上输出增补点令曲线平滑，数据点间隔均匀。本函数用于根据输入TagID及查询时间戳，来查询该点、该时刻的记录。所查询的时间戳未必是实际存储点的时间戳，但可根据插值类型计算获得。

插值计算，插入点前后都需要有质量为好的实际存储点，方可插值。

此外，如果插值时间点正好等于原始记录的时间戳，则此数据的插值查询可以成功返回；

如果插值查询的时间戳后无实际存储点，则无法成功查询返回。

举例

Set objArray= CreateObject("hdCOMInterface.hdCOMClass.1")

Dim ip,port,bakip,bakport,timeout

ip= "127.0.0.1"

port= 5678

bakip = "1.2.3.4"

bakport = 1234

timeout= 3

Dim ret

objArray.com_nt_connect ip,port,bakip,bakport,timeout

Dim id,mode,result

id=13

mode = 1

Dim nsec,nmsec,nquality,ntype,nvalue

nsec = CLng(1379310469)

nmsec = CLng(0)

result = CLng(objArray.com_ar_query_interp_record_by_mode( mode,id,nsec,nmsec,nquality,ntype,nvalue))

Msgbox "com_ar_query_interp_record_by_mode错误码是：" &result

if result=0 then

Msgbox "sec is:" &nsec

Msgbox "msec is:" &nmsec

Msgbox "quality is:" &nquality

Msgbox "type is:" &ntype

Msgbox "value is:" &nvalue

end if

objArray.com_nt_disconnect

Set objArray= nothing

©2015. All Rights Reserved.


插值查询（单点多记录查询）com_ar_query_interp_records_by_mode

Navigation: 功能明细 > 数据接口 > COM接口 > VB 接口 >

插值查询（单点多记录查询）com_ar_query_interp_records_by_mode

 Return to chapter overview

函数

STDMETHOD (com_ar_query_interp_records_by_mode)(

LONGnMode,

LONGnTagID,

LONGnRecNum,

VARIANT* nSec,

VARIANT* nMsec,

VARIANT* nQuality,

VARIANT* nTagType,

VARIANT* bsValue,

VARIANT* nErrCodes,

LONG* nRetErr

);

参数

[in]LONGnMode,插值类型，值为1表示前向插值；值为0表示线性插值。

[in]LONGnTagID, TagID

[in]LONGnRecNum, 记录的条数。

[in,out]VARIANT* nSec, 时间戳的秒数组，必须是LONG类型，nSec->vt = VT_ARRAY | VT_VARIANT

[in,out]VARIANT* nMsec, 时间戳的毫秒数组，必须是LONG类型，必须是LONG类型，nMsec->vt = VT_ARRAY | VT_VARIANT

[out]VARIANT* nQuality,的数据质量数组，nQuality->vt = VT_ARRAY | VT_VARIANT

[out]VARIANT* nTagType, 记录的Tag类型数组，nTagType->vt = VT_ARRAY | VT_VARIANT

[out]VARIANT* bsValue, 记录的值数组，bsValue->vt = VVT_ARRAY | VT_VARIANT

[out]VARIANT* nErrCodes,每条记录的错误码数组

[out,retval]LONG* nRetErr，返回值

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

iHyperDB的8种数据类型都支持插值查询。

根据数据实际采集及压缩策略，原始历史数据曲线可能存在数据点时间间隔不均，曲线过于抖动或锐化，通过插值方式可以在现有数据逻辑基础上输出增补点令曲线平滑，数据点间隔均匀。本函数用于根据输入TagID、查询记录条数及查询时间戳数组，来查询单点的多条记录。所查询的时间戳未必是实际存储点的时间戳，但可根据插值类型计算获得。

注意：输入参数中的时间戳数组长度必须与记录条数一致；

插值计算，插入点前后都需要有质量为好的实际存储点，方可插值。

此外，如果插值时间点正好等于原始记录的时间戳，则此数据的插值查询可以成功返回；

如果插值查询的时间戳后无实际存储点，则无法成功查询返回。

举例

Set objArray= CreateObject("hdCOMInterface.hdCOMClass.1")

Dim ip,port,bakip,bakport,timeout

ip= "127.0.0.1"

port= 5678

bakip = "1.2.3.4"

bakport = 1234

timeout= 3

Dim ret

objArray.com_nt_connect ip,port,bakip,bakport,timeout

Dim id,mode,recnum

id=14

mode = 1

recnum=3

Dim nsec,nmsec,nquality,ntype,nvalue,nerrcode,result

nsec=Array(CLng(1379310469),CLng(1379310569),CLng(1379310669))

nmsec=Array(CLng(0),CLng(0),CLng(0))

result = CLng(objArray.com_ar_query_interp_records_by_mode( mode,id,recnum,nsec,nmsec,nquality,ntype,nvalue,nerrcode))

Msgbox "com_ar_query_interp_records_by_mode错误码是：" &result

if result=0 or result=119611 then

Dim x6,showerrcode

showerrcode = "调用后errcode:"

for x6= LBound(nerrcode) to UBound(nerrcode)

showerrcode = showerrcode & nerrcode(x6) & "; "

next

MsgBox showerrcode

Dim x1,showsec

showsec = "调用后sec:"

for x1= LBound(nsec) to UBound(nsec)

showsec = showsec & nsec(x1) & "; "

next

MsgBox showsec

Dim x2,showmsec

showmsec = "调用后msec:"

for x2= LBound(nmsec) to UBound(nmsec)

showmsec = showmsec & nmsec(x2) & "; "

next

MsgBox showmsec

Dim x3,showquality

showquality = "调用后quality:"

for x3= LBound(nquality) to UBound(nquality)

showquality = showquality & nquality(x3) & "; "

next

MsgBox showquality

Dim x4,showtype

showtype = "调用后type:"

for x4= LBound(ntype) to UBound(ntype)

showtype = showtype & ntype(x4) & "; "

next

MsgBox showtype

Dim x5,showvalue

showvalue = "调用后Value:"

for x5= LBound(nvalue) to UBound(nvalue)

showvalue = showvalue & nvalue(x5) & "; "

next

MsgBox showvalue

end if

objArray.com_nt_disconnect

Set objArray= nothing

©2015. All Rights Reserved.


根据时间段查询单点历史记录com_ar_query_raw_records

Navigation: 功能明细 > 数据接口 > COM接口 > VB 接口 >

根据时间段查询单点历史记录com_ar_query_raw_records

 Return to chapter overview

函数

STDMETHOD(com_ar_query_raw_records)(

LONGnTagID,

LONGnStartSec,

LONGnStartMSec,

LONGnEndSec,

LONGnEndMSec,

VARIANT* pRecNum,

VARIANT* nSec,

VARIANT* nMsec,

VARIANT* nQuality,

VARIANT* nTagType,

VARIANT* bsValue,

LONG* nRetErr

);

参数

[in]LONG nTagID,TagID

[in]LONG nStartSec,查询的起始时间戳，秒。

[in]LONG nStartMSec, 查询的起始时间戳，毫秒。

[in]LONG nEndSec, 查询的结束时间戳，秒。

[in]LONG nEndMSec, 查询的结束时间戳，毫秒。

[in, out]VARIANT* pRecNum, in：待查的记录数量。out：实际返回的记录的数量，若小于要查询的记录数量，则表示该时间段的记录全部查完；若等于要查询的数量，则表示在该时间段内还有记录没有查完，用户可以根据返回的最后一条记录的时间来重新设置结束时间，然后再次调用该接口来查询剩下的记录。记录个数不能超过65535。必须是LONG类型。

[out]VARIANT* nSec, 时间戳的秒数组，nSec->vt = VT_ARRAY | VT_VARIANT

[out]VARIANT* nMsec, 时间戳的毫秒数组，必须是LONG类型，nMsec->vt = VT_ARRAY | VT_VARIANT

[out]VARIANT* nQuality,记录的数据质量数组，nQuality->vt = VT_ARRAY | VT_VARIANT

[out]VARIANT* nTagType, 记录的Tag类型数组，nTagType->vt = VT_ARRAY | VT_VARIANT

[out]VARIANT* bsValue, 记录的值数组，bsValue->vt = VVT_ARRAY | VT_VARIANT

[out,retval]LONG* nRetErr，返回值

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

1.查询一个Tag在一个时间段内的记录，该接口支持所有的数据类型。

2.该接口的时间戳精确到秒。例如：开始时间为“2001-1-1 08:08:08. 111”，结束时间是为“2001-1-2 08:08:08. 222”，查询到的记录是“2001-1-1 08:08:08. 000”到“2001-1-2 08:08:08. 000”范围内的原始记录。

举例

Set objArray= CreateObject("hdCOMInterface.hdCOMClass.1")

Dim ip,port,bakip,bakport,timeout

ip= "127.0.0.1"

port= 5678

bakip = "1.2.3.4"

bakport = 1234

timeout= 3

Dim ret

objArray.com_nt_connect ip,port,bakip,bakport,timeout

Dim id,recnum

id=14

recnum=CLng(3)

Dim nStartSec,nStartMsec,nEndSec,nEndMsec

nStartSec = CLng(1379310469)

nStartMsec = CLng(0)

nEndSec = CLng(1379310969)

nEndMsec = CLng(0)

Dim nsec,nmsec,nquality,ntype,nvalue,result

result = CLng(objArray.com_ar_query_raw_records (id,nStartSec,nStartMsec,nEndSec,nEndMsec,recnum,nsec,nmsec,nquality,ntype,nvalue))

Msgbox "com_ar_query_raw_records错误码是：" &result

if result=0 then

Dim x0,shownum

shownum = "调用后RecNum:" &recnum

MsgBox shownum

Dim x1,showsec

showsec = "调用后sec:"

for x1= LBound(nsec) to UBound(nsec)

showsec = showsec & nsec(x1) & "; "

next

MsgBox showsec

Dim x2,showmsec

showmsec = "调用后msec:"

for x2= LBound(nmsec) to UBound(nmsec)

showmsec = showmsec & nmsec(x2) & "; "

next

MsgBox showmsec

Dim x3,showquality

showquality = "调用后quality:"

for x3= LBound(nquality) to UBound(nquality)

showquality = showquality & nquality(x3) & "; "

next

MsgBox showquality

Dim x4,showtype

showtype = "调用后type:"

for x4= LBound(ntype) to UBound(ntype)

showtype = showtype & ntype(x4) & "; "

next

MsgBox showtype

Dim x5,showvalue

showvalue = "调用后Value:"

for x5= LBound(nvalue) to UBound(nvalue)

showvalue = showvalue & nvalue(x5) & "; "

next

MsgBox showvalue

end if

objArray.com_nt_disconnect

Set objArray= nothing

©2015. All Rights Reserved.


根据时间段查询单点历史记录条数com_ar_query_raw_records_number

Navigation: 功能明细 > 数据接口 > COM接口 > VB 接口 >

根据时间段查询单点历史记录条数com_ar_query_raw_records_number

 Return to chapter overview

函数

STDMETHOD(com_ar_query_raw_records_number)(

LONGnTagID,

LONGnStartSec,

LONGnStartMSec,

LONGnEndSec,

LONGnEndMSec,

VARIANT* pRecNum,

LONG* nRetErr

);

参数

[in]LONG nTagID, TagID

[in]LONG nStartSec,查询的起始时间戳，秒。

[in]LONG nStartMSec, 查询的起始时间戳，毫秒。

[in]LONG nEndSec, 查询的结束时间戳，秒。

[in]LONG nEndMSec, 查询的结束时间戳，毫秒。

[out]VARIANT* pRecNum, 原始记录条数，pRecNum->vt = VT_I4

[out,retval]LONG* nRetErr，返回值

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

该接口用来查询某一Tag指定时间段内的原始记录条数。

举例

Set objArray= CreateObject("hdCOMInterface.hdCOMClass.1")

Dim ip,port,bakip,bakport,timeout

ip= "127.0.0.1"

port= 5678

bakip = "1.2.3.4"

bakport = 1234

timeout= 3

Dim ret

objArray.com_nt_connect ip,port,bakip,bakport,timeout

Dim id,recnum

id=5

recnum=CLng(3)

Dim nStartSec,nStartMsec,nEndSec,nEndMsec,result

nStartSec = CLng(1378876138)

nStartMsec = CLng(0)

nEndSec = CLng(1378879738)

nEndMsec = CLng(0)

result = CLng(objArray.com_ar_query_raw_records_number (id,nStartSec,nStartMsec,nEndSec,nEndMsec,recnum))

Msgbox "com_ar_query_raw_records_number错误码是：" &result

if result=0 then

Dim x0,shownum

shownum = "调用后RecNum:" &recnum

MsgBox shownum

end if

objArray.com_nt_disconnect

Set objArray= nothing

©2015. All Rights Reserved.


根据点名查询ID号（单点查询）com_pt_query_tagid

Navigation: 功能明细 > 数据接口 > COM接口 > VB 接口 >

根据点名查询ID号（单点查询）com_pt_query_tagid

 Return to chapter overview

函数

STDMETHOD(com_pt_query_tagid)(

BSTRszTagName,

VARIANT* pnTagID,

LONG* nRetErr

);

参数

[in] BSTR szTagName, 普通点名

[out] VARIANT* pnTagID, 普通点TagID，pRecNum ->vt = VT_I4

[out,retval]LONG* nRetErr,返回值

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

通过普通点的名字查询ID。

举例

Set objArray= CreateObject("hdCOMInterface.hdCOMClass.1")

Dim ip,port,bakip,bakport,timeout

ip= "127.0.0.1"

port= 5678

bakip = "1.2.3.4"

bakport = 1234

timeout= 3

Dim ret

objArray.com_nt_connect ip,port,bakip,bakport,timeout

Dim name,id,result

name= "hdsys_mem"

result = CLng(objArray.com_pt_query_tagid (name,id))

Msgbox "com_pt_query_tagid错误码是：" &result

if result=0 then

Msgbox name &" TagID is:" &id

end if

objArray.com_nt_disconnect

Set objArray= nothing

©2015. All Rights Reserved.


根据点名查询ID号（多点查询）com_pt_query_tagids

Navigation: 功能明细 > 数据接口 > COM接口 > VB 接口 >

根据点名查询ID号（多点查询）com_pt_query_tagids

 Return to chapter overview

函数

STDMETHOD(com_pt_query_tagids)(

LONGnTagNum,

VARIANT* szTagNames,

VARIANT* tagIDs,

VARIANT* nErrCodes,

LONG* nRetErr

);

参数

[in]LONG nTagNum, 查询的tag个数

[in]VARIANT* szTagNames, 普通点点名数组

[out]VARIANT* tagIDs, 普通点ID数组

[out]VARIANT* nErrCodes, 返回值数组

[out,retval]LONG* nRetErr，返回值

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

根据Tag点名，查询多个普通点的ID。

举例

Set objArray= CreateObject("hdCOMInterface.hdCOMClass.1")

Dim ip,port,bakip,bakport,timeout

ip= "127.0.0.1"

port= 5678

bakip = "1.2.3.4"

bakport = 1234

timeout= 3

Dim ret

objArray.com_nt_connect ip,port,bakip,bakport,timeout

Dim recnum

recnum = 3

Dim tagnames,name1,name2,name3

name1="hdsys_cpu"

name2="hdsys_mem"

name3="h"

tagnames = Array(name1,name2,name3)

Dim x,showname

showname = "调用前Tagnames:"

for x= LBound(tagnames) to UBound(tagnames)

showname = showname & tagnames(x) & "; "

next

MsgBox showname

Dim tagids,nerrcode,result

result = CLng(objArray.com_pt_query_tagids (recnum,tagnames,tagids, nerrcode))

Msgbox "com_pt_query_tagids错误码是：" &result

if result=0 or result=119707 then

Dim x6,showerrcode

showerrcode = "调用后errcode:"

for x6= LBound(nerrcode) to UBound(nerrcode)

showerrcode = showerrcode & nerrcode(x6) & "; "

next

MsgBox showerrcode

Dim x1,showsec

showsec = "调用后TagIDs:"

for x1= LBound(tagids) to UBound(tagids)

showsec = showsec & tagids(x1) & "; "

next

MsgBox showsec

end if

objArray.com_nt_disconnect

Set objArray= nothing

©2015. All Rights Reserved.


转换数字类型的时间为字符串com_convert_time_2_bstr

Navigation: 功能明细 > 数据接口 > COM接口 > VB 接口 >

转换数字类型的时间为字符串com_convert_time_2_bstr

 Return to chapter overview

函数

STDMETHOD (com_convert_time_2_bstr)(

LONGnSec,

LONGnMsec,

VARIANT* bsTime,

LONG* nRetErr

);

参数

[in]LONG nSec, 秒

[in]LONG nMsec,毫秒

[out]VARIANT* bsTime,时间字符串，类型是BSTR

[out,retval]LONG* nRetErr，返回值

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

把数字类型的时间转为字符串

举例

Set objArray= CreateObject("hdCOMInterface.hdCOMClass.1")

Dim nSec,nMsec,bsTime,ret

nSec=1379310469

nMsec=123

ret = objArray.com_convert_time_2_bstr (nSec,nMsec,bsTime)

Msgbox "errcode is:" &ret

Msgbox "nSec is:" &nSec

Msgbox "nMsec is:" &nMsec

Msgbox "bsTime is:" &bsTime

Set objArray= nothing

©2015. All Rights Reserved.


转换字符串类型的时间为数字com_convert_bstr_2_time

Navigation: 功能明细 > 数据接口 > COM接口 > VB 接口 >

转换字符串类型的时间为数字com_convert_bstr_2_time

 Return to chapter overview

函数

STDMETHOD (com_convert_bstr_2_time)(

BSTRbsTime,

VARIANT* nSec,

VARIANT* nMsec,

LONG* nRetErr

);

参数

[in]BSTR bsTime, 时间字符串

[out]VARIANT* nSec, 时间秒，类型是LONG

[in]VARIANT* nMsec, 时间毫秒，类型是LONG

[out,retval]LONG* nRetErr，返回值

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

把字符串类型的时间转为数字

举例

Set objArray= CreateObject("hdCOMInterface.hdCOMClass.1")

Dim nSec,nMsec,bsTime,ret

bsTime="2013-09-16 13:47:49"

ret = objArray.com_convert_bstr_2_time (bsTime,nSec,nMsec)

Msgbox "errcode is:" &ret

Msgbox "bsTime is:" &bsTime

Msgbox "nSec is:" &nSec

Msgbox "nMsec is:" &nMsec

Set objArray= nothing

©2015. All Rights Reserved.


根据时间段查询单点最小值com_ar_query_min_records

根据时间段查询单点最小值com_query_min_records

Navigation: 功能明细 > 数据接口 > COM接口 > VB 接口 >

根据时间段查询单点最小值com_query_min_records

 Return to chapter overview

函数

STDMETHOD (com_ar_query_min_records)(

LONG nTagID,

LONG nStartSec,

LONG nStartMSec,

LONG nEndSec,

LONG nEndMSec,

VARIANT* bsValue,

LONG* nRetErr

);

参数

[in]LONG nTagID,

[in]LONG nStartSec,记录时间

[in]LONG nStartMSec, 记录时间

[in]LONG nEndSec, 记录时间

[in]LONG nEndMSec, 记录时间

[in]VARIANT* bsValue, 返回的记录值

[out,retval]LONG* nRetErr，返回值

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

查询给定时间范围内的最小值。

举例

Set objArray= CreateObject("hdCOMInterface.hdCOMClass.1")

Dim ip,port,bakip,bakport,timeout

ip= "168.2.8.111"

port= 5673

bakip= "127.0.0.3"

bakport= 5678

timeout= 3

Dim ret

ret = objArray.com_nt_connect (ip,port,bakip,bakport,timeout)

Msgbox "com_nt_connect result is:" &ret

Dim id

id=17

Dim nStartSec,nStartMsec,nEndSec,nEndMsec

Dim bsStartTime,bsEndTime

bsStartTime="2015-05-27 00:00:00"

bsEndTime="2015-05-27 18:00:00"

objArray.com_convert_bstr_2_time bsStartTime,nStartSec,nStartMsec

objArray.com_convert_bstr_2_time bsEndTime,nEndSec,nEndMsec

nStartMsec = CLng(0)

nEndMsec = CLng(0)

Dim shownum

Dim dvalueMin,dvalueMax,dvalueMean

result = CLng(objArray.com_ar_query_min_records(id,nStartSec,nStartMsec,nEndSec,nEndMsec, dvalueMin))

Msgbox "com_ar_query_min_records错误码是：" &result

if result=0 then

shownum = "com_ar_query_min_records调用后dValue:" &dvalueMin

MsgBox shownum

end if

result = CLng(objArray.com_ar_query_max_records(id,nStartSec,nStartMsec,nEndSec,nEndMsec, dvalueMax))

Msgbox "com_ar_query_max_records错误码是：" &result

if result=0 then

shownum = "com_ar_query_max_records调用后dValue:" &dvalueMax

MsgBox shownum

end if

result = CLng(objArray.com_ar_query_mean_records(id,nStartSec,nStartMsec,nEndSec,nEndMsec, dvalueMean))

Msgbox "com_ar_query_mean_records错误码是：" &result

if result=0 then

shownum = "com_ar_query_mean_records调用后dValue:" &dvalueMean

MsgBox shownum

end if

objArray.com_nt_disconnect

Set objArray= nothing

©2015. All Rights Reserved.


根据时间段查询单点最大值com_ar_query_max_records

com_query_max_records

Navigation: 功能明细 > 数据接口 > COM接口 > VB 接口 >

com_query_max_records

 Return to chapter overview

函数

STDMETHOD (com_ar_query_max_records)(

LONG nTagID,

LONG nStartSec,

LONG nStartMSec,

LONG nEndSec,

LONG nEndMSec,

VARIANT* bsValue,

LONG* nRetErr

);

参数

[in]LONG nTagID,

[in]LONG nStartSec,记录时间

[in]LONG nStartMSec, 记录时间

[in]LONG nEndSec, 记录时间

[in]LONG nEndMSec, 记录时间

[in]VARIANT* bsValue, 返回的记录值

[out,retval]LONG* nRetErr，返回值

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

查询给定时间范围内的最大值。

举例

Set objArray= CreateObject("hdCOMInterface.hdCOMClass.1")

Dim ip,port,bakip,bakport,timeout

ip= "168.2.8.111"

port= 5673

bakip= "127.0.0.3"

bakport= 5678

timeout= 3

Dim ret

ret = objArray.com_nt_connect (ip,port,bakip,bakport,timeout)

Msgbox "com_nt_connect result is:" &ret

Dim id

id=17

Dim nStartSec,nStartMsec,nEndSec,nEndMsec

Dim bsStartTime,bsEndTime

bsStartTime="2015-05-27 00:00:00"

bsEndTime="2015-05-27 18:00:00"

objArray.com_convert_bstr_2_time bsStartTime,nStartSec,nStartMsec

objArray.com_convert_bstr_2_time bsEndTime,nEndSec,nEndMsec

nStartMsec = CLng(0)

nEndMsec = CLng(0)

Dim shownum

Dim dvalueMin,dvalueMax,dvalueMean

result = CLng(objArray.com_ar_query_min_records(id,nStartSec,nStartMsec,nEndSec,nEndMsec, dvalueMin))

Msgbox "com_ar_query_min_records错误码是：" &result

if result=0 then

shownum = "com_ar_query_min_records调用后dValue:" &dvalueMin

MsgBox shownum

end if

result = CLng(objArray.com_ar_query_max_records(id,nStartSec,nStartMsec,nEndSec,nEndMsec, dvalueMax))

Msgbox "com_ar_query_max_records错误码是：" &result

if result=0 then

shownum = "com_ar_query_max_records调用后dValue:" &dvalueMax

MsgBox shownum

end if

result = CLng(objArray.com_ar_query_mean_records(id,nStartSec,nStartMsec,nEndSec,nEndMsec, dvalueMean))

Msgbox "com_ar_query_mean_records错误码是：" &result

if result=0 then

shownum = "com_ar_query_mean_records调用后dValue:" &dvalueMean

MsgBox shownum

end if

objArray.com_nt_disconnect

Set objArray= nothing

©2015. All Rights Reserved.


根据时间段查询单点算数平均值com_ar_query_mean_records

com_query_mean_records

Navigation: 功能明细 > 数据接口 > COM接口 > VB 接口 >

com_query_mean_records

 Return to chapter overview

函数

STDMETHOD (com_ar_query_mean_records)(

LONG nTagID,

LONG nStartSec,

LONG nStartMSec,

LONG nEndSec,

LONG nEndMSec,

VARIANT* bsValue,

LONG* nRetErr

);

参数

[in]LONG nTagID,

[in]LONG nStartSec,记录时间

[in]LONG nStartMSec, 记录时间

[in]LONG nEndSec, 记录时间

[in]LONG nEndMSec, 记录时间

[in]VARIANT* bsValue, 返回的记录值

[out,retval]LONG* nRetErr，返回值

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

查询给定时间范围内的算术平均值。

举例

Set objArray= CreateObject("hdCOMInterface.hdCOMClass.1")

Dim ip,port,bakip,bakport,timeout

ip= "168.2.8.111"

port= 5673

bakip= "127.0.0.3"

bakport= 5678

timeout= 3

Dim ret

ret = objArray.com_nt_connect (ip,port,bakip,bakport,timeout)

Msgbox "com_nt_connect result is:" &ret

Dim id

id=17

Dim nStartSec,nStartMsec,nEndSec,nEndMsec

Dim bsStartTime,bsEndTime

bsStartTime="2015-05-27 00:00:00"

bsEndTime="2015-05-27 18:00:00"

objArray.com_convert_bstr_2_time bsStartTime,nStartSec,nStartMsec

objArray.com_convert_bstr_2_time bsEndTime,nEndSec,nEndMsec

nStartMsec = CLng(0)

nEndMsec = CLng(0)

Dim shownum

Dim dvalueMin,dvalueMax,dvalueMean

result = CLng(objArray.com_ar_query_min_records(id,nStartSec,nStartMsec,nEndSec,nEndMsec, dvalueMin))

Msgbox "com_ar_query_min_records错误码是：" &result

if result=0 then

shownum = "com_ar_query_min_records调用后dValue:" &dvalueMin

MsgBox shownum

end if

result = CLng(objArray.com_ar_query_max_records(id,nStartSec,nStartMsec,nEndSec,nEndMsec, dvalueMax))

Msgbox "com_ar_query_max_records错误码是：" &result

if result=0 then

shownum = "com_ar_query_max_records调用后dValue:" &dvalueMax

MsgBox shownum

end if

result = CLng(objArray.com_ar_query_mean_records(id,nStartSec,nStartMsec,nEndSec,nEndMsec, dvalueMean))

Msgbox "com_ar_query_mean_records错误码是：" &result

if result=0 then

shownum = "com_ar_query_mean_records调用后dValue:" &dvalueMean

MsgBox shownum

end if

objArray.com_nt_disconnect

Set objArray= nothing

©2015. All Rights Reserved.


VC接口

Navigation: 功能明细 > 数据接口 > COM接口 >

VC接口

 Return to chapter overview

·连接服务器com_nt_connect_c

·断开服务器com_nt_disconnect_c

·用户登录com_sc_login_c

·查询实时记录（单点查询）com_sn_query_snapshot_c

·查询实时记录（多点查询）com_sn_query_snapshots_c

·插值查询（单点查询）com_ar_query_interp_record_by_mode_c

·插值查询（单点多记录查询）com_ar_query_interp_records_by_mode_c

·根据时间段查询单点历史记录com_ar_query_raw_records_c

·根据时间段查询单点历史记录条数com_ar_query_raw_records_number_c

·根据点名查询ID号（单点查询）com_pt_query_tagid_c

·根据点名查询ID号（多点查询）com_pt_query_tagids_c

·根据时间段查询单点最小值com_ar_query_min_records_c

·根据时间段查询单点最大值com_ar_query_max_records_c

·根据时间段查询单点算术平均值com_ar_query_mean_records_c


连接服务器com_nt_connect_c

Navigation: 功能明细 > 数据接口 > COM接口 > VC接口 >

连接服务器com_nt_connect_c

 Return to chapter overview

函数

STDMETHOD(com_nt_connect_c)(

BSTR szIP,

LONG nPort,

BSTR szBakIP,

LONG nBakPort,

LONG nTimeOut,

);

参数

[in] BSTR szIP, 服务器ip

[in] LONG nPort, 服务器端口号

[in] BSTR szBakIP, 备服务器ip

[in] LONG nBakPort, 备服务器端口号

[in] LONG nTimeOut, 连接超时

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

连接成功后，调用com_nt_disconnect_c来断开与服务器的连接；com_nt_connect_c和com_nt_disconnect_c采用引用计算，需要确保成对使用。

举例

!MISSING PHRASE 'COPYCODE'!

HRESULT hr ;

BSTR szIP = ::SysAllocString( L"127.0.0.1" );

BSTR szBalIP = ::SysAllocString( L"1.1.1.1" );

LONG nPort = 5678;

LONG nBakPort = 1234;

LONG nTimeOut = 3;

hr = m_pabc->com_nt_connect_c(szIP, nPort, nBakIP, nBakPort, nTimeOut);

if (hr != S_OK)

{

return;

}

hr = m_pabc->com_nt_disconnect_c();

if (hr != S_OK)

{

return;

}

::SysFreeString( szIP );

::SysFreeString( szBakIP );


断开服务器com_nt_disconnect_c

Navigation: 功能明细 > 数据接口 > COM接口 > VC接口 >

断开服务器com_nt_disconnect_c

 Return to chapter overview

函数

STDMETHOD(com_nt_disconnect_c)(

);

参数

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

断开服务器函数。com_nt_connect_c和com_nt_disconnect_c采用引用计算，需要确保成对使用。

举例

!MISSING PHRASE 'COPYCODE'!

HRESULT hr ;

BSTR szIP = ::SysAllocString( L"127.0.0.1" );

BSTR szBalIP = ::SysAllocString( L"1.1.1.1" );

LONG nPort = 5678;

LONG nBakPort = 1234;

LONG nTimeOut = 3;

hr = m_pabc->com_nt_connect_c(szIP, nPort, nBakIP, nBakPort, nTimeOut);

if (hr != S_OK)

{

return;

}

hr = m_pabc->com_nt_disconnect_c();

if (hr != S_OK)

{

return;

}

::SysFreeString( szIP );

::SysFreeString( szBakIP );


用户登录com_sc_login_c

Navigation: 功能明细 > 数据接口 > COM接口 > VC接口 >

用户登录com_sc_login_c

 Return to chapter overview

函数

STDMETHOD(com_sc_login_c)(

BSTR szUserName,

BSTR szPassWord,

);

参数

[in] BSTRszUserName, 用户名称

[in]BSTRszPassWord, 用户密码

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

用户登录函数。用于在一台服务器上进行用户登录操作。

举例

!MISSING PHRASE 'COPYCODE'!

HRESULT hr ;

BSTR sztagname=::SysAllocString(L”admin”);

BSTR szpassword=::SysAllocString(L”admin”);

BSTR szIP = ::SysAllocString( L"127.0.0.1" );

BSTR szBalIP = ::SysAllocString( L"1.1.1.1" );

LONG nPort = 5678;

LONG nBakPort = 1234;

LONG nTimeOut = 3;

hr = m_pabc->com_nt_connect_c(szIP, nPort, nBakIP, nBakPort, nTimeOut);

if (hr != S_OK)

{

return;

}

;

hr = m_pabc->com_log_in_c( sztagname, szpassword);

if (hr != S_OK)

{

return;

}

hr = m_pabc->com_nt_disconnect_c();

if (hr != S_OK)

{

return;

}

::SysFreeString( szIP );

::SysFreeString( szBakIP );

::SysFreeString( sztagname );

::SysFreeString(szpassword)


查询实时记录（单点查询）com_sn_query_snapshot_c

Navigation: 功能明细 > 数据接口 > COM接口 > VC接口 >

查询实时记录（单点查询）com_sn_query_snapshot_c

 Return to chapter overview

函数

STDMETHOD(com_sn_query_snapshot_c)(

LONG nTagID,

Com_hdRecord* pRecord

);

参数

[in]LONG nTagID, TagID

[out] Com_hdRecord * pRecord,

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

查询实时记录（单点查询）函数。该函数用来查询一个Tag保存在内存快照中的最新记录。返回的实时记录的值用字符串的形式表示。

记录结构体：

typedef /* [uuid] */ DECLSPEC_UUID("0BA40F41-FD38-44cb-B9BC-45E8DE7047D8") struct Com_hdRecord

{

LONG nSec;

LONG nMsec;

LONG nQuality;

LONG nTagType;

BSTR value;

} Com_hdRecord;

举例

!MISSING PHRASE 'COPYCODE'!

HRESULT hr ;

BSTR szIP = ::SysAllocString( L"127.0.0.1" );

BSTR szBalIP = ::SysAllocString( L"1.1.1.1" );

LONG nPort = 5678;

LONG nBakPort = 1234;

LONG nTimeOut = 3;

hr = m_pabc->com_nt_connect_c(szIP, nPort, nBakIP, nBakPort, nTimeOut);

if (hr != S_OK)

{

return;

}

LONG nTagID = 1;

Com_hdRecord hdrecord;

hr = m_pabc->com_sn_query_snapshot_c( nTagID, &hdrecord);

if (hr != S_OK)

{

return;

}

::SysFreeString(hdrecord.value);

hr = m_pabc->com_nt_disconnect_c();

if (hr != S_OK)

{

return;

}

::SysFreeString( szIP );

::SysFreeString( szBalIP );


查询实时记录（多点查询）com_sn_query_snapshots_c

Navigation: 功能明细 > 数据接口 > COM接口 > VC接口 >

查询实时记录（多点查询）com_sn_query_snapshots_c

 Return to chapter overview

函数

STDMETHOD(com_sn_query_snapshots_c)(

LONG nRecNum,

SAFEARRAY* nTagIDs,

SAFEARRAY** records,

SAFEARRAY** nErrCodes

);

参数

[in] LONG nRecNum, 查询的实时记录的数量，不能超过65535

[in]SAFEARRAY(LONG) nTagIDs, TagID数组

[out]SAFEARRAY(Com_hdRecord)*records,，实时数据数组

[out]SAFEARRAY(LONG)* nErrCodes，错误码数组

返回值

查询成功，返回RD_SUCCESS，不是所有的都成功返回EC_HD_API_QUERY_SNAPSHOTS_FAILED。查询失败返回其它错误码，见error_code.h。

说明

查询实时记录（多点查询）函数。通过TagID数组查询多个Tag的内存快照中的最新记录。

返回RD_SUCCESS，表示所有的内存快照都查询成功；返回EC_HD_API_QUERY_SNAPSHOTS_FAILED，表明不是所有查询都成功；返回其它错误码表明查询失败，具体的错误码保存在nErrorCode数组中。

举例

!MISSING PHRASE 'COPYCODE'!

HRESULT hr ;

int nNum = 3;

LONG* plIDBuf = new LONG[nNum];

BSTR szIP = ::SysAllocString( L"127.0.0.1" );

BSTR szBalIP = ::SysAllocString( L"1.1.1.1" );

LONG nPort = 5678;

LONG nBakPort = 1234;

LONG nTimeOut = 3;

hr = m_pabc->com_nt_connect_c(szIP, nPort, nBakIP, nBakPort, nTimeOut);

if (hr != S_OK)

{

return;

}

// 组织传入数据

for(int i = 0; i < nNum; ++i)

{

plIDBuf[i] = i+1;

}

// 将数据通过VARIANT的SAFEARRAY数组传入。其中m_varBuffer为VARIANT类型

SAFEARRAY * pSA;

SAFEARRAYBOUND sabRSarray[1]; // A one-dimensional array.

sabRSarray[0].cElements=nNum; // Two elements.

sabRSarray[0].lLbound=0; //Lower bound of array.

pSA=SafeArrayCreate(VT_I4,1, sabRSarray);

if(pSA==NULL)

{

return;

}

LONG i = 0;

LONG nSum=1;

SafeArrayPutElement(pSA, &i, &nSum);

i++;

nSum=2;

SafeArrayPutElement(pSA, &i, &nSum);

i++;

nSum=1000;

SafeArrayPutElement(pSA, &i, &nSum);

//传出数据的变量

SAFEARRAY* pSaRecords = NULL;

SAFEARRAY* pSaErrCodes = NULL;

hr = m_pabc->com_sn_query_snapshots_c( nNum, pSA, &pSaRecords, &pSaErrCodes);

if (hr != S_OK && hr != 119610)

{

return;

}

//获取传出的record

Com_hdRecord *pcomrecord = NULL;

hr = SafeArrayAccessData(pSaRecords, (void HUGEP **)&pcomrecord);

if(hr != S_OK)

{

return;

}

//释放内部BSTR数据

LONG LBound;

LONG UBound;

SafeArrayGetLBound(pSaRecords, 1, &LBound);

SafeArrayGetUBound(pSaRecords, 1, &UBound);

for(LONG i = LBound; i<= UBound; i++)

{

::SysFreeString( pcomrecord[i-LBound].value );

}

//获取传出的Errorcode

LONG *pErrBuf = NULL;

hr = SafeArrayAccessData(pSaErrCodes, (void**)&pErrBuf);

if(hr != S_OK)

{

return;

}

hr = m_pabc->com_nt_disconnect_c(hServerhandle);

if (hr != S_OK)

{

return;

}

delete[] plIDBuf;

SafeArrayDestroy(pSA);

SafeArrayDestroy(pSaRecords);

SafeArrayDestroy(pSaErrCodes);

::SysFreeString( szIP );

::SysFreeString( szBalIP );


插值查询（单点查询）com_ar_query_interp_record_by_mode_c

Navigation: 功能明细 > 数据接口 > COM接口 > VC接口 >

插值查询（单点查询）com_ar_query_interp_record_by_mode_c

 Return to chapter overview

函数

STDMETHOD (com_ar_query_interp_record_by_mode_c)(

[in] LONG nMode,

[in] LONG nTagID,

[in]Com_hdTime* pTime,

[out]Com_hdRecord* pRecord

);

参数

[in]LONG nMode,插值类型，值为1表示前向插值，即将某一个时刻之前最近的一条原始值作为改时刻的插值；值为0表示线性插值，即根据某一时刻之前的最近一条原始值和该时刻之后最近一条原始值来进行线性计算该时刻的插值。

[in]LONG nTagID, TagID。

[in] Com_hdTime * pTime, 插值时间戳

[out] Com_hdRecord * pRecord, 记录的值，

返回值

查询成功，返回RD_SUCCESS，不是所有的都成功返回EC_HD_API_QUERY_SNAPSHOTS_FAILED。查询失败返回其它错误码，见error_code.h。

说明

iHyperDB的8种数据类型都支持插值查询。

根据数据实际采集及压缩策略，原始历史数据曲线可能存在数据点时间间隔不均，曲线过于抖动或锐化，通过插值方式可以在现有数据逻辑基础上输出增补点令曲线平滑，数据点间隔均匀。本函数用于根据输入TagID及查询时间戳，来查询该点、该时刻的记录。所查询的时间戳未必是实际存储点的时间戳，但可根据插值类型计算获得。

插值计算，插入点前后都需要有质量为好的实际存储点，方可插值。

此外，如果插值时间点正好等于原始记录的时间戳，则此数据的插值查询可以成功返回；

如果插值查询的时间戳后无实际存储点，则无法成功查询返回。

时间结构体：

typedef /* [uuid] *

/ DECLSPEC_UUID("49A4F982-DC5C-456c-8398-386940C6F625") struct Com_hdTime

{

LONG nSec;

LONG nMsec;

} Com_hdTime;

举例

!MISSING PHRASE 'COPYCODE'!

HRESULT hr ;

BSTR szIP = ::SysAllocString( L"127.0.0.1" );

BSTR szBalIP = ::SysAllocString( L"1.1.1.1" );

LONG nPort = 5678;

LONG nBakPort = 1234;

LONG nTimeOut = 3;

hr = m_pabc->com_nt_connect_c(szIP, nPort, nBakIP, nBakPort, nTimeOut);

if (hr != S_OK)

{

return;

}

LONG nTagID = 1;

LONG nMode = 1;

Com_hdRecord hdrecord;

Com_hdTime pTime;

//pTime.nSec = 1378446892;

pTime.nSec = 1;

pTime.nMsec = 0;

hr = m_pabc->com_ar_query_interp_record_by_mode_c(nMode, nTagID, &pTime, &hdrecord);

if (hr != S_OK)

{

//::SysFreeString(hdrecord.value);

//::SysFreeString( szIP );

return;

}

hr = m_pabc->com_nt_disconnect_c();

if (hr != S_OK)

{

::SysFreeString(hdrecord.value);

::SysFreeString( szIP );

return;

}

//::SysFreeString(hdrecord.value);

::SysFreeString( szIP );

::SysFreeString( szBalIP );


插值查询（单点多记录查询）com_ar_query_interp_records_by_mode_c

Navigation: 功能明细 > 数据接口 > COM接口 > VC接口 >

插值查询（单点多记录查询）com_ar_query_interp_records_by_mode_c

 Return to chapter overview

函数

STDMETHOD (com_ar_query_interp_records_by_mode_c)(

LONG nMode,

LONG nTagID,

LONG nRecNum,

SAFEARRAY* pTime,

SAFEARRAY** records,

SAFEARRAY** nErrCodes);

参数

[in]LONGnMode,插值类型，值为1表示前向插值，即将某一个时刻之前最近的一条原始值作为改时刻的插值；值为0表示线性插值，即根据某一时刻之前的最近一条原始值和该时刻之后最近一条原始值来进行线性计算该时刻的插值。

[in]LONGnTagID, TagID

[in]LONGnRecNum, 记录的条数。

[in,out]VARIANT* nSec, 时间戳的秒数组，必须是LONG类型，nSec->vt = VT_ARRAY | VT_VARIANT

[in,out]VARIANT* nMsec, 时间戳的毫秒数组，必须是LONG类型，必须是LONG类型，nMsec->vt = VT_ARRAY | VT_VARIANT

[out]VARIANT* nQuality,的数据质量数组，nQuality->vt = VT_ARRAY | VT_VARIANT

[out]VARIANT* nTagType, 记录的Tag类型数组，nTagType->vt = VT_ARRAY | VT_VARIANT

[out]VARIANT* bsValue, 记录的值数组，bsValue->vt = VVT_ARRAY | VT_VARIANT

[out]VARIANT* nErrCodes,每条记录的错误码数组

[out,retval]LONG* nRetErr，返回值

返回值

查询成功，返回RD_SUCCESS，不是所有的都成功返回EC_HD_API_QUERY_SNAPSHOTS_FAILED。查询失败返回其它错误码，见error_code.h。

说明

iHyperDB的8种数据类型都支持插值查询。

根据数据实际采集及压缩策略，原始历史数据曲线可能存在数据点时间间隔不均，曲线过于抖动或锐化，通过插值方式可以在现有数据逻辑基础上输出增补点令曲线平滑，数据点间隔均匀。本函数用于根据输入TagID、查询记录条数及查询时间戳数组，来查询单点的多条记录。所查询的时间戳未必是实际存储点的时间戳，但可根据插值类型计算获得。

注意：输入参数中的时间戳数组长度必须与记录条数一致；

插值计算，插入点前后都需要有质量为好的实际存储点，方可插值。

此外，如果插值时间点正好等于原始记录的时间戳，则此数据的插值查询可以成功返回；

如果插值查询的时间戳后无实际存储点，则无法成功查询返回。

举例

!MISSING PHRASE 'COPYCODE'!

HRESULT hr ;

BSTR szIP = ::SysAllocString( L"127.0.0.1" );

BSTR szBalIP = ::SysAllocString( L"1.1.1.1" );

LONG nPort = 5678;

LONG nBakPort = 1234;

LONG nTimeOut = 3;

hr = m_pabc->com_nt_connect_c(szIP, nPort, nBakIP, nBakPort, nTimeOut);

if (hr != S_OK)

{

return;

}

LONG nMode = 1;

LONG nRecNum =2;

LONG nTagID = 1;

// 组织传入数据

IRecordInfo* pRecordInfo = NULL;

SAFEARRAY* theArray;

hr = GetRecordInfoFromGuids(

LIBID_hdCOMInterfaceLib,

1,

0,

GetUserDefaultLCID(),

STRUCTID_COM_TIME,

&pRecordInfo);

theArray = SafeArrayCreateVectorEx(VT_RECORD,0,nRecNum,pRecordInfo);

Com_hdTime *pData=NULL;

hr=SafeArrayAccessData(theArray,(void **)&pData);

for(int i=0;i<nRecNum;i++)

{

pData[i].nSec = i+1378446892;

pData[i].nMsec=0;

}

int i=0;

pData[i].nSec = 1378446892;

pData[i].nMsec=0;

i++;

pData[i].nSec =200000;

pData[i].nMsec=0;

SafeArrayUnaccessData(theArray);

pRecordInfo->Release();

//传出数据的变量

SAFEARRAY* pSaRecords = NULL;

SAFEARRAY* pSaErrCodes = NULL;

hr = m_pabc->com_ar_query_interp_records_by_mode_c(nMode, nTagID,nRecNum, theArray, &pSaRecords, &pSaErrCodes);

if (hr != S_OK && hr!= 119611)

{

return;

}

//获取传出的record

Com_hdRecord *pcomrecord = NULL;

hr = SafeArrayAccessData(pSaRecords, (void HUGEP **)&pcomrecord);

if(hr != S_OK)

{

return;

}

//释放内部BSTR数据

LONG LBound;

LONG UBound;

SafeArrayGetLBound(pSaRecords, 1, &LBound);

SafeArrayGetUBound(pSaRecords, 1, &UBound);

for(LONG i = LBound; i<= UBound; i++)

{

::SysFreeString( pcomrecord[i-LBound].value );

}

//获取传出的Errorcode

LONG *pErrBuf = NULL;

hr = SafeArrayAccessData(pSaErrCodes, (void**)&pErrBuf);

if(hr != S_OK)

{

return;

}

hr = m_pabc->com_nt_disconnect_c();

if (hr != S_OK)

{

return;

}

SafeArrayDestroy(theArray);

SafeArrayDestroy(pSaRecords);

SafeArrayDestroy(pSaErrCodes);

::SysFreeString( szIP );

::SysFreeString( szBalIP );


根据时间段查询单点历史记录com_ar_query_raw_records_c

Navigation: 功能明细 > 数据接口 > COM接口 > VC接口 >

根据时间段查询单点历史记录com_ar_query_raw_records_c

 Return to chapter overview

函数

STDMETHOD(com_ar_query_raw_records_c)(

LONG nTagID,

Com_hdTime* pStartTime,

Com_hdTime* pEndTime,

LONG* pRecNum,

SAFEARRAY** records

);

参数

[in]LONG nTagID,TagID

[in]Com_hdTime* pStartTime, 查询的起始时间戳

[in]Com_hdTime* pEndTime, 查询的结束时间戳

[in, out]LONG* pRecNum, in：待查的记录数量。out：实际返回的记录的数量。若小于要查询的记录数量，则表示该时间段的记录全部查完；若等于要查询的数量，则表示在该时间段内还有记录没有查完，用户可以根据返回的最后一条记录的时间来重新设置结束时间，然后再次调用该接口来查询剩下的记录。记录个数不能超过65535。必须是LONG类型。

[out]SAFEARRAY(Com_hdRecord)* records记录的值数组

返回值

查询成功，返回RD_SUCCESS，不是所有的都成功返回EC_HD_API_QUERY_SNAPSHOTS_FAILED。查询失败返回其它错误码，见error_code.h。

说明

1.查询一个Tag在一个时间段内的记录，该接口支持所有的数据类型。

2.该接口的时间戳精确到秒。例如：开始时间为“2001-1-1 08:08:08. 111”，结束时间是为“2001-1-2 08:08:08. 222”，查询到的记录是“2001-1-1 08:08:08. 000”到“2001-1-2 08:08:08. 000”范围内的原始记录。

举例

!MISSING PHRASE 'COPYCODE'!

HRESULT hr ;

BSTR szIP = ::SysAllocString( L"127.0.0.1" );

BSTR szBalIP = ::SysAllocString( L"1.1.1.1" );

LONG nPort = 5678;

LONG nBakPort = 1234;

LONG nTimeOut = 3;

hr = m_pabc->com_nt_connect_c(szIP, nPort, nBakIP, nBakPort, nTimeOut);

if (hr != S_OK)

{

return;

}

LONG nRecNum =200;

LONG nTagID = 1;

// 组织传入数据

Com_hdTime comStartTime,comEndTime;

comStartTime.nSec = 1378706236;

comStartTime.nMsec = 0;

comEndTime.nSec = 1378709836;

comEndTime.nMsec = 0;

//传出数据的变量

SAFEARRAY* pSaRecords = NULL;

hr = m_pabc->com_ar_query_raw_records_c( nTagID, &comStartTime, &comEndTime, &nRecNum ,&pSaRecords);

if (hr != S_OK)

{

return;

}

//获取传出的record

Com_hdRecord *pcomrecord = NULL;

hr = SafeArrayAccessData(pSaRecords, (void HUGEP **)&pcomrecord);

if(hr != S_OK)

{

return;

}

//释放内部BSTR数据

LONG LBound;

LONG UBound;

SafeArrayGetLBound(pSaRecords, 1, &LBound);

SafeArrayGetUBound(pSaRecords, 1, &UBound);

for(LONG i = LBound; i<= UBound; i++)

{

::SysFreeString( pcomrecord[i-LBound].value );

}

hr = m_pabc->com_nt_disconnect_c();

if (hr != S_OK)

{

return;

}

SafeArrayDestroy(pSaRecords);

::SysFreeString( szBalIP );

::SysFreeString( szIP );


根据时间段查询单点历史记录条数com_ar_query_raw_records_number_c

Navigation: 功能明细 > 数据接口 > COM接口 > VC接口 >

根据时间段查询单点历史记录条数com_ar_query_raw_records_number_c

 Return to chapter overview

函数

STDMETHOD(com_ar_query_raw_records_number_c)(

LONG nTagID,

Com_hdTime* pStartTime,

Com_hdTime* pEndTime,

LONG* pRecNum

);

参数

[in] LONG nTagID, TagID

[in]Com_hdTime* pStartTime, 查询的起始时间戳

[in]Com_hdTime* pEndTime, 查询的结束时间戳

[out]LONG* pRecNum,要查询的记录个数

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

该接口用来查询某一Tag指定时间段内的原始记录条数。

举例

!MISSING PHRASE 'COPYCODE'!

HRESULT hr ;

BSTR szIP = ::SysAllocString( L"127.0.0.1" );

BSTR szBalIP = ::SysAllocString( L"1.1.1.1" );

LONG nPort = 5678;

LONG nBakPort = 1234;

LONG nTimeOut = 3;

hr = m_pabc->com_nt_connect_c(szIP, nPort, nBakIP, nBakPort, nTimeOut);

if (hr != S_OK)

{

return;

}

LONG nRecNum;

LONG nTagID = 1;

// 组织传入数据

Com_hdTime comStartTime,comEndTime;

comStartTime.nSec = 1378706236;

comStartTime.nMsec = 0;

comEndTime.nSec = 1378709836;

comEndTime.nMsec = 0;

hr = m_pabc->com_ar_query_raw_records_number_c( nTagID, &comStartTime, &comEndTime, &nRecNum );

if (hr != S_OK)

{

return;

}

hr = m_pabc->com_nt_disconnect_c();

if (hr != S_OK)

{

return;

}

::SysFreeString( szIP );

::SysFreeString( szBalIP );


根据点名查询ID号（单点查询）com_pt_query_tagid_c

Navigation: 功能明细 > 数据接口 > COM接口 > VC接口 >

根据点名查询ID号（单点查询）com_pt_query_tagid_c

 Return to chapter overview

函数

STDMETHOD(com_pt_query_tagid_c)(

BSTR szTagName,

LONG* pnTagID

);

参数

[in] BSTR szTagName, 普通点名

[out] LONG* pnTagID, 普通点TagID

返回值

查询成功，返回RD_SUCCESS，不是所有的都成功返回EC_HD_API_QUERY_SNAPSHOTS_FAILED。查询失败返回其它错误码，见error_code.h。

说明

通过普通点的名字查询ID。

举例

!MISSING PHRASE 'COPYCODE'!

HRESULT hr ;

VARIANT varServerhandle;

BSTR szIP = ::SysAllocString( L"127.0.0.1" );

BSTR szBalIP = ::SysAllocString( L"1.1.1.1" );

LONG nPort = 5678;

LONG nBakPort = 1234;

LONG nTimeOut = 3;

hr = m_pabc->com_nt_connect_c(szIP, nPort, nBakIP, nBakPort, nTimeOut);

if (hr != S_OK)

{

return;

}

//BSTR sztagname = _bstr_t("hdsys_mem");

BSTR sztagname = ::SysAllocString( L"hdsys_mem" );

VARIANT varTagID;

LONG nTagID;

hr = m_pabc->com_pt_query_tagid( sztagname, &varTagID);

if (hr != S_OK)

{

return;

}

nTagID = varTagID.lVal;

hr = m_pabc->com_nt_disconnect();

if (hr != S_OK)

{

return;

}

::SysFreeString( szIP );

::SysFreeString( sztagname );

::SysFreeString( szBalIP );


根据点名查询ID号（多点查询）com_pt_query_tagids_c

Navigation: 功能明细 > 数据接口 > COM接口 > VC接口 >

根据点名查询ID号（多点查询）com_pt_query_tagids_c

 Return to chapter overview

函数

STDMETHOD(com_pt_query_tagids_c)(

LONG nTagNum,

SAFEARRAY* szTagNames,

SAFEARRAY** tagIDs,

SAFEARRAY** nErrCodes);

);

参数

[in] LONG nTagNum, 查询的tag个数

[in]SAFEARRAY(BSTR) szTagNames, 普通点点名数组

[out]SAFEARRAY(LONG)* tagIDs, 普通点ID数组

[out]SAFEARRAY(LONG)* nErrCodes,返回错误码数组

返回值

查询成功，返回RD_SUCCESS，不是所有的都成功返回EC_HD_API_QUERY_SNAPSHOTS_FAILED。查询失败返回其它错误码，见error_code.h。

说明

根据Tag点名，查询多个普通点的ID。

举例

!MISSING PHRASE 'COPYCODE'!

HRESULT hr ;

BSTR szIP = ::SysAllocString( L"127.0.0.1" );

BSTR szBalIP = ::SysAllocString( L"1.1.1.1" );

LONG nPort = 5678;

LONG nBakPort = 1234;

LONG nTimeOut = 3;

hr = m_pabc->com_nt_connect_c(szIP, nPort, nBakIP, nBakPort, nTimeOut);

if (hr != S_OK)

{

return;

}

int nNum = 3;

//传入参数tagnames

SAFEARRAY * pSA;

SAFEARRAYBOUND sabRSarray[1]; // A one-dimensional array.

sabRSarray[0].cElements=nNum; // Two elements.

sabRSarray[0].lLbound=0; //Lower bound of array.

pSA=SafeArrayCreate(VT_BSTR,1, sabRSarray);

if(pSA==NULL)

{

return;

}

_bstr_t bstrTemp1 = _bstr_t("hdsys_cpu");

LONG nTemp1 = 0;

SafeArrayPutElement(pSA, &nTemp1, bstrTemp1.copy());

_bstr_t bstrTemp2 = _bstr_t("hdsys_mem");

LONG nTemp2 = 1;

SafeArrayPutElement(pSA, &nTemp2, bstrTemp2.copy());

_bstr_t bstrTemp3 = _bstr_t("h");

LONG nTemp3 = 2;

SafeArrayPutElement(pSA, &nTemp3, bstrTemp3.copy());

//传出参数

SAFEARRAY* pSaTagIDs = NULL;

SAFEARRAY* pSaErrcodes = NULL;

hr = m_pabc->com_pt_query_tagids_c( nNum, pSA, &pSaTagIDs, &pSaErrcodes);

if (hr != S_OK)

{

return;

}

//获取传出参数

LONG *pIDs = NULL;

hr = SafeArrayAccessData(pSaTagIDs, (void**)&pIDs);

if(hr != S_OK)

{

return;

}

SafeArrayUnaccessData(pSaTagIDs);

LONG *pErrBuf = NULL;

hr = SafeArrayAccessData(pSaErrcodes, (void**)&pErrBuf);

if(hr != S_OK)

{

return;

}

SafeArrayUnaccessData(pSaErrcodes);

hr = m_pabc->com_nt_disconnect_c();

if (hr != S_OK)

{

return;

}

//释放传入参数

BSTR *pBSTR = NULL;

LONG LBound, UBound;

SafeArrayAccessData(pSA, (void HUGEP **) &pBSTR);

SafeArrayGetLBound(pSA, 1, &LBound);

SafeArrayGetUBound(pSA, 1, &UBound);

for(LONG i=LBound;i<=UBound;i++)

{

::SysFreeString(pBSTR[i]);

}

SafeArrayUnaccessData(pSA);

SafeArrayDestroy(pSA);

//释放传出的safearray

SafeArrayDestroy(pSaTagIDs);

SafeArrayDestroy(pSaErrcodes);

::SysFreeString( szBalIP );

::SysFreeString( szIP );


根据时间段查询单点最小值com_ar_query_min_records_c

根据时间段查询单点最小值com_query_min_records_c

Navigation: 功能明细 > 数据接口 > COM接口 > VC接口 >

根据时间段查询单点最小值com_query_min_records_c

 Return to chapter overview

函数

STDMETHOD (com_ar_query_min_records_c)(

LONG nTagID,

Com_hdTime* pStartTime,

Com_hdTime* pEndTime,

DOUBLE* dValue,

LONG* nRetErr

);

参数

[in]LONG nTagID,

[in]Com_hdTime* pStartTime

[in]Com_hdTime* pEndTime,

[in]DOUBLE* dValue, 返回的记录值

[out,retval]LONG* nRetErr，返回值

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

查询给定时间范围内的最小值。

举例

!MISSING PHRASE 'COPYCODE'!

HRESULT hr ;

BSTR szIP = ::SysAllocString( L"127.0.0.1" );

BSTR szBalIP = ::SysAllocString( L"1.1.1.1" );

LONG nPort = 5678;

LONG nBakPort = 1234;

LONG nTimeOut = 3;

hr = m_pabc->com_nt_connect_c(szIP, nPort, nBakIP, nBakPort, nTimeOut);

if (hr != S_OK)

{

return;

}

LONG nTagID = 1;

Com_hdTime pStartTime,pEndTime;

pStartTime.nSec = 1;

pStartTime.nMsec = 0;

pStartTime.nSec = 2;

pStartTime.nMsec = 0;

Double dValue;

hr = m_pabc->com_ar_query_min_records_c(nTagID,pStartTime,pEndTime,&dValue);

if (hr != S_OK)

{

return;

}

hr = m_pabc->com_nt_disconnect();

if (hr != S_OK)

{

return;

}

::SysFreeString( szIP );

::SysFreeString( szBalIP );


根据时间段查询单点最大值com_ar_query_max_records_c

根据时间段查询单点最大值com_query_max_records_c

Navigation: 功能明细 > 数据接口 > COM接口 > VC接口 >

根据时间段查询单点最大值com_query_max_records_c

 Return to chapter overview

函数

STDMETHOD (com_ar_query_max_records_c)(

LONG nTagID,

Com_hdTime* pStartTime,

Com_hdTime* pEndTime,

DOUBLE* dValue,

LONG* nRetErr

);

参数

[in]LONG nTagID,

[in]Com_hdTime* pStartTime

[in]Com_hdTime* pEndTime,

[in]DOUBLE* dValue, 返回的记录值

[out,retval]LONG* nRetErr，返回值

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

查询给定时间范围内的最大值。

举例

!MISSING PHRASE 'COPYCODE'!

HRESULT hr ;

BSTR szIP = ::SysAllocString( L"127.0.0.1" );

BSTR szBalIP = ::SysAllocString( L"1.1.1.1" );

LONG nPort = 5678;

LONG nBakPort = 1234;

LONG nTimeOut = 3;

hr = m_pabc->com_nt_connect_c(szIP, nPort, nBakIP, nBakPort, nTimeOut);

if (hr != S_OK)

{

return;

}

LONG nTagID = 1;

Com_hdTime pStartTime,pEndTime;

pStartTime.nSec = 1;

pStartTime.nMsec = 0;

pStartTime.nSec = 2;

pStartTime.nMsec = 0;

Double dValue;

hr = m_pabc->com_ar_query_max_records_c(nTagID,pStartTime,pEndTime,&dValue);

if (hr != S_OK)

{

return;

}

hr = m_pabc->com_nt_disconnect();

if (hr != S_OK)

{

return;

}

::SysFreeString( szIP );

::SysFreeString( szBalIP );


根据时间段查询单点算术平均值com_ar_query_mean_records_c

根据时间段查询单点算术平均值com_query_mean_records_c

Navigation: 功能明细 > 数据接口 > COM接口 > VC接口 >

根据时间段查询单点算术平均值com_query_mean_records_c

 Return to chapter overview

函数

STDMETHOD (com_ar_query_mean_records_c)(

LONG nTagID,

Com_hdTime* pStartTime,

Com_hdTime* pEndTime,

DOUBLE* dValue,

LONG* nRetErr

);

参数

[in]LONG nTagID,

[in]Com_hdTime* pStartTime

[in]Com_hdTime* pEndTime,

[in]DOUBLE* dValue, 返回的记录值

[out,retval]LONG* nRetErr，返回值

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

查询给定时间范围内的算术平均值。

举例

!MISSING PHRASE 'COPYCODE'!

HRESULT hr ;

BSTR szIP = ::SysAllocString( L"127.0.0.1" );

BSTR szBalIP = ::SysAllocString( L"1.1.1.1" );

LONG nPort = 5678;

LONG nBakPort = 1234;

LONG nTimeOut = 3;

hr = m_pabc->com_nt_connect_c(szIP, nPort, nBakIP, nBakPort, nTimeOut);

if (hr != S_OK)

{

return;

}

LONG nTagID = 1;

Com_hdTime pStartTime,pEndTime;

pStartTime.nSec = 1;

pStartTime.nMsec = 0;

pStartTime.nSec = 2;

pStartTime.nMsec = 0;

Double dValue;

hr = m_pabc->com_ar_query_mean_records_c(nTagID,pStartTime,pEndTime,&dValue);

if (hr != S_OK)

{

return;

}

hr = m_pabc->com_nt_disconnect();

if (hr != S_OK)

{

return;

}

::SysFreeString( szIP );

::SysFreeString( szBalIP );


com在icv中的使用

Navigation: 功能明细 > 数据接口 > COM接口 >

com在icv中的使用

 Return to chapter overview

当COM接口已经成功安装到计算中之后，可以在iCV的组态中通过书写vb脚本调用COM接口。

举例如下：

1. 安装并启动iCV。

2. 打开iCV组态系统。

3. 新建画面“testCOMbyVBA”。

4. 在画面中添加按钮。

5. 在按钮处单击右键，弹出属性修改框，按图修改按钮名和显示名称。

6. 添加vb脚本。

7. 在按钮上右键点击“编辑脚本”，弹出脚本编辑工具。

8. 编辑对象脚本，内容是按钮按下时响应函数：

!MISSING PHRASE 'COPYCODE'!

Set objArray= CreateObject("hdCOMInterface.hdCOMClass.1")

Dim ip,port,bakip,bakport,timeout

ip= "127.0.0.1"

port= 5678

bakip = ""

bakport =

timeout= 3

Dim ret

objArray.com_nt_connect ip,port,bakip,bakport,timeout

Dim usrname,password,result

usrname= "test"

password="test"

result = CLng(objArray.com_sc_login (usrname,password))

objArray.com_nt_disconnect

Msgbox "login result is:" &result

Set objArray= nothing

9. 最后运行画面，单击按钮，就可以调用COM接口了。

10. 其他COM接口的调用方式都是类似的，请参考COM接口详细介绍。


com在ifix中的使用

Navigation: 功能明细 > 数据接口 > COM接口 >

com在ifix中的使用

 Return to chapter overview

当COM接口已经成功安装到计算中之后，可以在ifix中通过书写vb脚本调用COM接口。举例如下：

安装并启动iFix。

打开“Proficy iFix 工作台”。

新建一个画面“testCOMbyVBA”。

在画面中添加按钮。

工具栏——插入——对象/链接——按钮

在按钮处单击右键，弹出属性修改框，按图修改按钮名和显示名称。

添加vb脚本。

单击”首页”——“visualbasic编辑器”，弹出脚本编辑工具。

脚本编辑工具左侧有树形结构列表。

在结构列表的“工作台应用_对象”——“testCOMbyVBA”节点上双击，弹出脚本编辑工具。编辑对象脚本，内容是按钮按下时响应函数：

!MISSING PHRASE 'COPYCODE'!

Private Sub btnTestConnect_Click()

Dim hdCOM As Object

Dim szIP As String

Dim nPort As Long

Dim nTimeOut As Long

Dim hserver As Variant

Dim ret As Long

Set hdCOM = CreateObject("hdCOMInterface.hdCOMClass.1")

szIP = "192.168.128.111"

nPort = 5678

nTimeOut = 3

ret = 0

ret = hdCOM.com_nt_connect(szIP, nPort, nTimeOut, hserver)

MsgBox (ret)

ret = hdCOM.com_nt_disconnect(hserver)

MsgBox (ret)

Set hdCOM = Nothing

End Sub

最后运行画面，单击按钮，就可以调用COM接口了。

其他COM接口的调用方式都是类似的，请参考COM接口详细介绍。


内存快照存储异步接口

Navigation: 功能明细 > 数据接口 >

内存快照存储异步接口

 Return to chapter overview

sn3_save_snapshots_nowait:异步保存多点快照记录：

/**

* @brief 快照数据：保存多点快照记录（批量接口）,不等待服务端返回结果

* @param nRecNum [记录个数]

* @param pTagIDArray [TagID数组]

* @param pRecArray [记录数

* @param pErrCodeArray [错误码数组]

* @return RD_SUCCESS, if all success

* EC_HD3_API_BATCH_REQUEST, if some failed

* hd3 error, otherwise

* @version 09/19/2023 g.l. modified version

*/

HD3_API

int32 sn3_save_snapshots_nowait(

hd3_in int32 nRecNum,

hd3_in const uint32* pTagIDArray,

hd3_in const HD3Record* pRecArray,

hd3_out int32* pErrCodeArray

);

示例程序：

#include "hdKingAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "hd3Struct.h"

#include <stdio.h>

#include <string.h>

#include <Windows.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

HD3Connection conn;

HD3PtTagProp tag;

const char* szTagName_1 = "szTagName_1";

const char* szTagName_2 = "szTagName_2";

int32 nRecNum = 2;

HD3Record snapshotsSaved[2];

uint32 nTagIDs[2];

int32 nErrorCodes[2];

HD3Record snapshotsQueried[2];

int32 i = 0;

//connect

strcpy(conn.szAddress, "127.0.0.1");

conn.nPort = 5673;

conn.nTimeout = 3;

nRet = nt3_connect(&conn);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc3_login("admin", "admin");

if (nRet != RD_SUCCESS)

{

printf("login failed, error code[%d]!\n", nRet);

return -1;

}

printf("login successful!\n");

//save one snapshot

snapshotsSaved[0].nSec = 3600;

snapshotsSaved[0].nMsec = 0;

snapshotsSaved[0].nQuality = 192;

snapshotsSaved[0].nTagType = HD3_TAG_TYPE_INT32;

snapshotsSaved[0].value.nInt32 = 111;

nRet = sn3_save_snapshot_nowait(nTagIDs[0], &(snapshotsSaved[0]));

if (nRet != RD_SUCCESS)

{

printf("save snapshot failed, tag id [%d], error code [%d]!\n", nTagIDs[0], nRet);

nt3_disconnect();

return -1;

}

printf("save snapshot successful, tag id[%d]!\n", nTagIDs[0]);

/

//disconnect

nt3_disconnect();

return 0;

}


数据安全

Navigation: 功能明细 >

数据安全

 Return to chapter overview

数据安全是为数据处理系统的建立、采用的技术和管理的安全保护，保护计算机硬件、软件和数据不因偶然和恶意的原因遭到破坏、更改和泄露。

下面对实时数据库的备份、恢复、冗余进行介绍。


配置和数据备份

Navigation: 功能明细 > 数据安全 >

配置和数据备份

 Return to chapter overview

实时数据库可实现将实时数据库的数据备份到本机，并恢复到指定的另外一个实时数据库中。

u手动备份

u自动备份


手动备份

Navigation: 功能明细 > 数据安全 > 配置和数据备份 >

手动备份

 Return to chapter overview

使用 hdArcfileBackupManual工具，备份配置和数据

u打开备份工具，进行数据备份

①选择需要备份的文件路径，在\iHyperDB\Data\Archive下

②可全选，不会影响实时数据库存储性能，并可直观历史数据的起始时间

③选择备份文件存放位置

最后点击“备份”按钮，既可将数据备份到指定文件夹

v日志记录

如果希望在备份过程中出现失败等意外情况时，能够通过日志进行问题定位排查，此时需要添加日志配置项之后，再进行备份操作

在ihyperdb\config目录下的Log.xml文件中添加如下配置项:

<appender name="hdArcfileBackupManualFile" type="rollingfile" logdir="D:/iHyperDB/Log/" prefix="hdArcfileBackupManual" rollingpolicy="sizerolling" layout="basic" />

<appender name="hdArcfileBackupManualConsole" type="console" layout="basic" />

<category name="iHyperDB.hdArcfileBackupManual">

<output appender="hdArcfileBackupManualFile" priority="debug" />

<output appender="hdArcfileBackupManualConsole" priority="debug" />

</category>

u进行配置备份

将iHyperDB\下的config文件夹整体拷贝到上述数据备份的文件夹下，例如：


自动备份

Navigation: 功能明细 > 数据安全 > 配置和数据备份 >

自动备份

 Return to chapter overview

系统hdArcfilebackup服务可对备份周期、备份目录、备份目标文件夹进行配置，来完成配置和数据的自动备份

u修改配置文件

·归档文件备份的配置文件hdArcfilebackup.xml保存在ihyperdb\config 下:

1.backupperiod_min:备份周期，单位为分钟。

2.backupdir:归档文件备份后的存储地址。用户必须配置该项，否则程序无法正常启动。

3.backupmaxnum: 归档文件备份最大数量，为空则程序默认为ServerCfg.xml文件中配置的归档文件数量。

注意：存储目录需预留足够空间用来备份归档文件。

·在ihyperdb\config目录下的Log.xml文件中添加如下配置项:

<appender name="hdArcfilebackupFile" type="rollingfile" logdir="E:/iHyperDB/Log/" prefix="hdArcfilebackup" rollingpolicy="sizerolling" layout="basic" />

<appender name=hdArcfilebackupConsole" type="console" layout="basic" />

<category name="iHyperDB.hdArcfilebackup">

<output appender="hdArcfilebackupFile" priority="debug" />

<output appender="hdArcfilebackupConsole" priority="debug" />

</category>

修改并保存后，系统既可自动进行备份


配置和数据恢复

Navigation: 功能明细 > 数据安全 >

配置和数据恢复

 Return to chapter overview

“配置和数据备份”中备份好的归档文件，用户可以选择指定的归档文件进行恢复。

注意：进行文件恢复前需进行iHD版本验证，目标iHD版本低于备份时的iHD版本则无法进行恢复。

u打开恢复工具，进行数据恢复

1.选择备份好的归档文件

2.选择目标iHD配置文件的恢复路径\iHyperDB\config

3.选择要恢复的归档文件

4.选择目标iHD数据文件的恢复路径\iHyperDB\Data\Archive

v特别的：iHD配置服务器与数据节点服务器分别部署在不同服务器

该种情况下，无法通过“配置和数据备份”来拿到ConfigCenter.db文件， 需要到另一台服务器上拿到ConfigCenter.db文件并放入目标iHD的config中

u配置文件修改

·ConfigCenter.db

检查t_hdserver表下面mainip字段内容，修改为正确的ip地址

·ServerCfg.xml

检查文件内Kernel 、Alarm、Redundancy 、 CCServer标签内路径以及ip地址等参数并修改

·SysMgrTool*.xml 、 Log*.xml

检查文件内路径参数，如需要，可进行修改


数据节点冗余

Navigation: 功能明细 > 数据安全 >

数据节点冗余

 Return to chapter overview

分布式实时数据库的数据结点的双机冗余功能，保证用户的配置、数据不丢失，系统可持续运行。主备机间的冗余切换在数秒之内完成，配置信息、数据实现自动同步。配置不在数据节点主备机间同步，主备机直接从配置中心同步配置。


冗余配置

Navigation: 功能明细 > 数据安全 > 数据节点冗余 >

冗余配置

 Return to chapter overview

下面介绍在系统管理工具中配置数据节点主备机IP端口等参数。

1.运行系统管理工具，连接上配置中心后，打开“数据结点配置”，弹出数据结点配置对话框：

2.配置数据结点的冗余机IP（注意：不能和主机一致）

3.配置冗余机端口默认是5678

4.点击确定保存好配置。

这样，数据结点的冗余机就配置好了，然后打开数据节点服务端管理工具，

首先启动同步服务，等同步服务运行起来以后，再正常启动别的服务。


冗余查看

Navigation: 功能明细 > 数据安全 > 数据节点冗余 >

冗余查看

 Return to chapter overview

当我们启用冗余服务以后，有两种方式可以查看目前机器的冗余状态。

方式一

打开服务端管理工具->服务管理

可以看到两个参数：一是否启用冗余：二是冗余状态：

第一个参数表明这个数据结点是否开启冗余功能

第二个参数表明本机是冗余功能中的活动结点还是非活动结点

活动结点：是目前正在正常使用的机器，数据都是往这台机器上收发。

非活动结点：表明这台机器是备机，只起到数据备份功能。

方式二

打开系统管理工具->数据结点检测工具->系统信息

这里面有5个参数表明冗余信息

一是是否启用冗余

二是主机IP

三是主机状态

四是备机IP

五是备机状态


iHD运行时间统计

Navigation: 功能明细 > 数据安全 >

iHD运行时间统计

 Return to chapter overview

在:\iHyperDB\config目录下hdRuntimeInfo.xml文件查看iHD正常运行时间信息：

<?xml version="1.0" encoding="utf-8" ?>

<ihd>

<RuntimeInfo StartTime="2023-06-07 13:47:34" ElapsedTime="00:00:02" ExceptionExit="false" />

<RuntimeInfo StartTime="2023-06-07 13:47:34" ElapsedTime="01:24:00" ExceptionExit="false" />

</ihd>


权限管理

Navigation: 功能明细 >

权限管理

 Return to chapter overview

权限模块实现了对实时数据库产品的访问权限控制。权限管理分为三个部分：用户与组管理、信任管理和管理权限。

本章节内容如下：

·用户与组权限管理

·信任管理

·管理权限

·数据源权限管理

·资源组权限管理

目前实时数据库主要对外提供点的增加、删除、修改、查找，对数据的增加、删除、修改、查询以及用户及群组管理等操作，上述操作都要进行授权控制。如下图所示，各个群组可以拥有不同的权限。

整个系统权限以群组为单位进行管理，用户的权限来源于其所属群组的权限设置，而群组的增删改查及用户的增删改查也需要有相应的授权方案。

对于与用户交互的界面程序通过让用户提供用户名密码来进行权限控制，而没有界面的后台数据采集类程序是无法通过输入用户名密码来控制，采用信任模式进行授权。简单来说就是：一个是通过我们的界面访问操作数据库使用权限，一个是通过api访问操作数据库采用信任。因为api无法与用户交互输入用户名密码，所以采用信任就不需要用户输入用户名和密码。

模块中有两种授权方式：

1.资源组授权：

·首先将tag点与相关资源组进行关联，再将资源组与用户组进行关联，从而实现权限控制。

·资源组配置根据权限划分为记录资源组与tag点配置资源组两种。具体类型如下图所示：

1)记录资源组读、写、读/写权限的相关用户可以查看组中点的实时记录与历史记录信息；

2)配置读/写权限的相关用户可以对组中的点进行修改删除等操作

2.tag级的授权方案：

§当一个点还没有被创建时无法授权其删除、修改及查询的权限，因此对整个系统的新增点操作要单独授权；

§一个点被创建后就可以对其删除、修改及查询操作进行授权，而一个点往往包括属性及数据两部分，因此将属性的操作与数据的操作分开来进行授权控制：

1). tag属性权限管理包括删除、修改及查询操作，

2). 数据权限管理包括新增、修改、删除、查询数据操作。

注：群组1相当于管理员，群组2相当于普通用户，群组3相当于数据采集接口。

1、Tag点属性查询和报警点操作暂未设置权限，所有访客都可以操作。对Excel展示中“Tag点下载”没有限制；

2、对权限的设置，不论用户登录或否，都会立刻生效。

3、如果该tag点配置了资源组，以资源组权限为准；如果该tag点未配置资源组，则使用原有tag所属组、操作组权限；

如果资源组权限与原有权限冲突，则以资源组权限优先。


用户与组管理

Navigation: 功能明细 > 权限管理 >

用户与组管理

 Return to chapter overview

《用户与组权限管理》主要介绍对用户和群组进行管理维护。可以对用户和群组进行管理维护。

选择“iHyperDB系统管理平台”->“权限”->“用户与组”进入用户与组管理。

· 用户登录

·创建用户

·修改密码

·重置密码

·删除用户

·创建组

·删除组

·用户及用户组批量创建

·用户属性

·组属性

·创建授权项

·删除授权项

·授权项属性

·刷新

权限与组的关系与windows权限类似，一个用户可以属于多个组，每个组都有自己的权限，属于某个组就有哪个组的权限，系统缺省有一个用户admin，该用户属于admin组，且不可被删除。

·用户登录

首先连接服务器

连接用户名默认为admin，密码为admin。其他用户名（如用户test）需要独立创建，请参考“创建用户”。

注：

A、用户名只对首尾的空格进行过滤，界面可输入的字符长度为1~63字符；

B、密码支持英文字符（包括大小写）和数字，另外还支持“!@#$%^&*()”（即0~9键对应的特殊字符），界面可输入的字符长度为5~63字符。

·创建用户

连接服务器成功后，进入"用户与组"浏览框架，其中列出所连接的服务器上的用户和组信息。

选择"用户"页面，右击鼠标后，在弹出的菜单项中，

点击【创建用户…】菜单会弹出创建用户对话框，

录入希望创建的用户信息后，点击【确定】按钮即可以创建一个新的用户；

如果点击“取消”按钮，则放弃创建用户并退出创建窗口。

A、用户名只对首尾的空格进行过滤，界面可输入的字符长度为1~63字符；

B、密码支持英文字符（包括大小写）和数字，另外还支持“!@#$%^&*()”（即0~9键对应的特殊字符），界面可输入的字符长度为5~63字符。

C、描述信息可输入需要添加的各种注释信息，可输入的长度最大为63个字符。

D、在空白处右击，弹出的【创建用户…】对话框中服务器项为“-----”；如果在某个用户所在行位置右击，弹出的对话框中服务器项就会为该用户所在服务器。

·修改密码

连接服务器成功后，进入"用户与组"浏览框架，其中列出所连接的服务器上的用户和组信息。

选择"用户"面，在需要修改密码的用户所在行右击鼠标，在弹出的菜单项中，点击"修改密码…"

菜单会弹出密码修改对话框，

输入旧密码和新密码后，点击【确定】按钮即可完成用户密码修改操作；如果点击【取消】按钮，则放弃修改并退出修改密码窗口。

注：A、密码支持英文字符（包括大小写）和数字，另外还支持“!@#$%^&*()”（即0~9键对应的特殊字符），界面可输入的字符长度为5~63字符。

·重置密码

连接服务器成功后，进入“用户与组”浏览框架，其中列出所连接的服务器上的用户和组信息。

选择“用户”页面，在需要重置重置密码的用户所在行右击鼠标，在弹出的菜单项中，点击“重置密码…”

菜单会弹出密码重置对话框，输入两遍新密码后，

点击【确定】按钮即可完成用户密码重置操作；如果点击【取消】按钮，则放弃修改并退出重置密码窗口。

注：

A、重置密码是用户所在服务器的管理员admin和具有用户所在组“iHyperDBUsr写”权限的用户才能操作成功的管理项。

B、密码支持英文字符（包括大小写）和数字，另外还支持“!@#$%^&*()”（即0~9键对应的特殊字符），界面可输入的字符长度为5~63字符。

·删除用户

"用户与组"浏览框架中选择"用户"页面，在需要删除的某个用户所在行位置右击鼠标，在弹出的菜单项中，点击"删除用户",

菜单会弹出删除用户"确认"对话框，点击"确定"按钮则删除该用户；如果点击"取消"按钮，则放弃删除用户操作。

·创建组

选择"组"页面，右击鼠标后，在弹出的菜单项中，点击"创建组…"

菜单会弹出创建组对话框，

录入希望创建的组信息后，点击【确定】按钮即可以创建一个新的组；如果点击【取消】按钮，则放弃创建组并退出创建窗口。

注：

A、组名只对首尾的空格进行过滤，界面可输入的字符长度为1~63字符；

B、描述信息可输入需要添加的各种注释信息，可输入的长度最大为63个字符。

C、在空白处右击，弹出的【创建组…】对话框中服务器项为“-----”；如果在某个组所在行位置右击，弹出的对话框中服务器项就会为该组所在服务器。

·删除组

"用户与组"浏览框架中选择"组"页面，在需要删除的某个组所在行位置右击鼠标， 在弹出的菜单项中，点击"删除组"菜单会弹出删除组"确认"对话框，点击"确定"按钮则删除该组；如果点击"取消"按钮，则放弃删除组操作。

·用户及用户组批量创建

若需批量创建用户、用户组，可使用Excel插件上传用户及组相关信息及关联关系，具体如下：

批量上传用户：

登录Excel加载项后，在Excel表格中输入新用户名及密码信息，也可以添加相应描述说明，格式如下；

表格信息配置好之后，点击【实时数据库】下拉框-【用户与组】-【用户上传】，点击"确定”，显示操作结果，点击“确定”，则上传完成；

完成后，可在客户端-权限-用户与组-用户处刷新表格查看；

批量上传用户组及关联关系：

登录Excel加载项后，在Excel表格中输入新用户组与用户关联信息，也可以添加相应描述说明，格式如下；

表格信息配置好之后，点击【实时数据库】下拉框-【用户与组】-【用户组上传】，点击"确定”，显示操作结果，点击“确定”，则上传完成；

完成后，可在客户端-权限-用户与组-用户组处刷新表格查看；

双击该组，可在组属性-成员列表中查看组所关联的用户信息；

注：上传用户组及关联关系时需注意用户组所关联的用户已存在，否则上传失败

·用户属性

在"用户属性"界面中，除了可以修改“概述”，还可以对用户隶属于的组进行配置。

同样有两种方式可以进入用户所属组的配置页面：

§第一种方式，在用户页面的某个用户所在行位置右击鼠标，在弹出的菜单项中，点击“用户属性”菜单弹出属性对话框；

§第二种方式，在某个用户所在行位置鼠标左键双击，也可以弹出属性对话框。

在用户属性对话框的“隶属于组"页，可以依据需要对用户所属于的组进行配置。

添加组：点击"添加…"按钮

可以弹出'添加组"配置界面，从上方选择用户尚不属于的组，这里支持按下键盘“CTRL”和“SHIFT”键情况下鼠标多选，点击中间的"添加组"按钮即可选择到界面下方的列表中，然后点击"确定'按钮则完成用户所属于组的添加；如果点击"取消"按钮，则放弃添加组操作。

删除组：在用户属性对话框的"隶属于组"页中，鼠标单击选择需要删除的组，这里支持按下键盘“CTRL”和“SHIFT”键情况下鼠标多选，然后点击下方"删除"按钮，即可删除选择的组。

·组属性

在"组属性"界面中，除了可以修改“组描述”，还可对组的用户成员进行配置。同样有两种方式可以进入组的用户成员配置页面：

§第一种方式，在"组"页面的某个组所在行位置右击鼠标，在弹出的菜单项中，点击"组属性"菜单弹出属性对话框；

§第二种方式，在某个组所在行位置鼠标左键双击，也可以弹出属性对话框。

在组属性对话框的“成员列表”页，可以依据需要对组的成员用户进行配置：

添加用户：点击“添加…”按钮可以弹出“添加用户”配置界面，

从上方选择组尚不包含的用户，这里支持按下键盘“CTRL”和“SHIFT”键情况下鼠标多选，点击中间“添加用户”按钮即可选择到界面下方的列表中，然后点击“确定”按钮则完成组的用户成员的添加；如果点击“取消”按钮，则放弃添加用户操作。

删除用户：在组属性对话框的“成员列表”页中，鼠标单击选择需要删除的用户，这里支持按下键盘“CTRL”和“SHIFT”键情况下鼠标多选，然后点击下方“删除”按钮，即可删除选择的用户。

组添加授权项的方法同上；或者参考“授权项属性”

·创建授权项

选择"授权项"页面，右击鼠标后，在弹出的菜单项中，点击"创建授权项…"

菜单会弹出创建授权项对话框，

录入希望创建的授权项信息后，点击【确定】按钮即可以创建一个新的授权项；如果点击【取消】按钮，则放弃创建授权项并退出创建窗口。

·删除授权项

"用户与组"浏览框架中选择"授权项''页面，在需要删除的某个授权项所在行位置右击鼠标， 在弹出的菜单项中，点击"删除授权项"菜单会弹出删除授权项"确认"对话框，点击"确定"按钮则删除该授权项；如果点击"取消"按钮，则放弃删除授权项操作。

·授权项属性

两种方法修改授权项属性

1.选择授权项所在行位置右击鼠标，弹出''授权项管理''页面。选择“添加”按钮，在“选择组”页面中，将需要有此授权项的组选中并“添加”。此时，该组具有此授权项所赋予的权限。

2."用户与组"浏览框架中选择"组页面，选择组所在行位置右击鼠标，弹出的“组属性”表中，添加需要赋予此组的授权项。此时，该组具有此授权项所赋予的权限，效果同上。

·刷新

用户与组界面均支持“刷新”功能，通过鼠标右击菜单的“刷新”项即可随时更新信息，与服务器端同步信息。


信任管理

Navigation: 功能明细 > 权限管理 >

信任管理

 Return to chapter overview

信任管理是通过将IP范围段与用户之间进行关联来实现，某一些客户端的访问无须使用用户帐号登录，即可拥有特定的权限。添加信任时，可以设置起始IP和终止IP，并使其对应一位用户。 即某一些客户端的访问无须使用用户帐号登录，即可拥有特定的权限。通过将IP范围段与用户之间进行关联来实现这个功能，添加信任时，可以设置起始IP和终止IP，并使其对应一位用户。

操作如下：

选择“配置管理”->“授权管理”->“信任”进入信任管理。

功能介绍：

·添加信任

·删除信任

·添加信任

在“连接管理器”中勾选需要连接的服务器，登录并连接服务器成功后，进入“信任”项可以看到其中列出所连接的服务器上的信任信息。

右击鼠标并选择“添加”选项，

会弹出创建信任对话框，

录入各项信息后点击“确定”按钮，即可完成信任的创建,在信任界面就可看到新添加的信任

注：

A、信任名只对首尾的空格进行过滤，界面可输入的字符长度为1~63字符；

B、不同信任之间的起始IP和终止IP的构成的区间不可以重叠；

C、“映射用户”，指与所配置的信任相对应的用户；

D、信任的权限由其所映射的用户的权限所决定。

·删除信任

在"信任"界面删除信任，可以通过鼠标选择需要删除的信任右击鼠标并选择"删除"选项，或者结合键盘选择，会弹出删除确认对话框，点击【确定】按钮，即可删除所选的信任。

注：删除支持多选删除。


访问控制

Navigation: 功能明细 > 权限管理 >

访问控制

 Return to chapter overview

访问控制对数据库的安全性、完整性和可用性具有重要意义。通过有效的访问控制策略，组织可以保护敏感数据免受未经授权的访问和恶意攻击，确保数据的可靠性和合规性。

访问控制管理是通过将IP范围段与用户之间进行关联来实现。可以设置信任，使某一些客户端的访问无须使用用户帐号登录，即可拥有特定的权限；也可以设置停用，使一些客户端没有登录及操作的权限。添加访问控制规则时，可以设置控制模式（信任或停用），以及起始IP和终止IP，并使其对应一位用户。

ihd3.9.2以上版本支持访问控制管理功能

操作如下：

选择“配置管理”->“授权管理”->“访问控制”进入访问控制管理。

功能介绍：

u添加规则

u删除规则

u 添加规则

在“连接管理器”中勾选需要连接的服务器，登录并连接服务器成功后，进入“访问控制”项可以看到其中列出所连接的服务器上的访问控制规则信息。

在空白处，右击鼠标并选择“添加”选项

会弹出创建访问控制规则对话框

录入各项信息后点击“确定”按钮，即可完成访问控制规则的创建,在访问控制界面就可看到新添加的访问控制规则。

注：

A、访问控制规则名只对首尾的空格进行过滤，界面可输入的字符长度为1~63字符；

B、不同访问控制之间的起始IP和终止IP的构成的区间不可以重叠；

C、“映射用户”，指与所配置的访问控制相对应的用户；

D、控制模式可选择信任或停用

u 删除规则

在“访问控制”界面删除访问控制，可以通过鼠标选择需要删除的访问控制规则，右击鼠标并选择“删除”选项，或者结合键盘选择，会弹出删除确认对话框，点击【确定】按钮，即可删除所选的访问控制规则。

注：删除支持多选删除。


统一权限管理

权限管理

Navigation: 功能明细 > 权限管理 >

权限管理

 Return to chapter overview

如下面示意图中的“管理权限”，点与组的权限都可以表示为“og:rw ng:r w:r”的形式。权限的授权单位是群组，群组分为两种：Own group与Operate group，其中，Own group一般是创建用户所在的群组，而Operate group表示对拥有特定权限的群组。

选择“权限”->“管理权限”

·组权限设置

·TAG点权限设置

以下操说明均是在拥有操作权限的情境下实现的，如果没有权限，相关操作会失败。

·组权限设置

在“连接管理器”勾选需要连接的服务器，登录并连接服务器成功后，进入“管理权限”项可以看到其中列出所连接的服务器上的安全数据库信息。

双击或右击鼠标某一行“组权限”并选择“属性”选项，

会弹出“组权限设置”对话框，

配置各项信息后点击【确定】按钮，即可完成配置。

注：

A、所属组、操作组、其他组，三者权限依次递减，即前一个大于等于后一个权限；

B、用户只能指定一个所属组，也只能指定一个操作组，其余的组均称为其他组；

C、Admin用户可以对权限值任意配置，其他“iHyperDB-User写”权限的用户只能按A要求配置，且对于某个权限值只能往小改。

·Tag点权限设置

双击或右击鼠标某一行“Tag点权限”并选择"属性"选项，会弹出“Tag点权限设置”对话框，

配置各项信息后点击"确定"按钮，即可完成配置。

注：

A、所属组、操作组、其他组，三者权限依次递减，即前一个大于等于后一个权限；

B、用户只能指定一个所属组，也只能指定一个操作组，其余的组均称为其他组；

C、Admin用户可以对权限值任意配置，其他“iHyperDB-User写”权限的用户只能按A要求配置，且对于某个权限值只能往小改。


数据源权限管理

Navigation: 功能明细 > 权限管理 >

数据源权限管理

 Return to chapter overview

数据源权限管理：对数据源各种权限的管理。

·TAG点权限设置

·Excel中Tag点属性设置权限

在Excel中创建Tag点时可以指定相关的数据源权限，包括：

·记录访问权限

·记录权限组

·记录所有者

·Tag访问权限

·Tag权限组

·Tag所有者

在创建Tag时可以指定一个组，该组对应于权限管理中的组。用户通过指定iHyperDB授权管理中已存在的组和用户，即可初始化Tag点以及其记录的权限信息。


资源组权限管理

Navigation: 功能明细 > 权限管理 >

资源组权限管理

 Return to chapter overview

资源组可以与用户组关联，tag点可以与资源组关联，从而实现权限控制。

如果该tag点配置了资源组，以资源组权限为准，如果该tag点未配置资源组，则使用原有所属组、操作组权限。

资源组配置根据权限划分为记录资源组与tag点配置资源组两种，数据资源组控制点读写权限，配置资源组控制点配置权限；

·用户与用户组配置准备

·资源组配置

·资源组与用户组关联

·tag点与资源组关联

·权限校验

u用户与用户组配置准备 (可参考用户与组管理章节进行配置)

1.首先登录admin账户号创建相应用户信息，如下图在“权限”-“用户与组”界面，右键点击“用户”列表空白处创建test用户，需自行设定账号登录密码：

2.同理，在“用户组”列表空白处创建用户组，如下图：

3.用户与用户组关联：右键点击用户，选择“用户属性”-“隶属于组”，添加相应用户组；

u资源组配置

资源组配置需要使用默认admin用户进行配置，或使用自定义配置的具有“组权限”的用户组下的用户进行配置。

此处直接使用admin用户对资源组进行创建。

资源组创建：点击“用户与组”页面-“资源组”，在空白处点击右键-“创建资源组”，配置相应组名、描述信息并选择权限类型，完成后确定即可；

资源组权限类型说明如下：

u资源组与用户组关联

如上图配置的资源组权限为【配置读权限】，创建完成资源组后，可以双击该资源组，在“所属用户组”配置页面点击“添加”对该资源组与用户组进行关联：

完成资源组与用户组绑定后，可以将tag点与资源组进行关联，从而实现权限控制；

utag点与资源组关联

1.打开“Tag变量配置”页面，点击如图所示查询按钮，选择所要配置的tag点：

2.以点[aa]为例，双击[aa]行，进入"资源组"配置页面，在此页面添加所需资源组，实现tag点与资源组绑定：

资源分为数据资源组与配置资源组，数据资源组控制点读写权限，配置资源组控制点配置权限；

目前用户需根据自己所配置的具体权限选择添加至“数据资源组”或“配置资源组”；

3.已关联的用户组与资源组可以查看相应用户与资源

u权限校验

使用test用户重新登陆iHD客户端：

进入"数据源"下的"Tag变量配置"页面，点击“查询”按钮，只能查询到该用户所能访问的[aa]点的信息：

如需进行Tag删除操作，则提示权限不够，Tag删除失败信息；


升级工具

Navigation: 功能明细 >

升级工具

 Return to chapter overview

Ø3.2.0以前的版本升级：

升级工具负责将实时数据库从版本2.4.5升级到3.2.0版本，升级的范围包括所有服务端Tag点的配置和所有的数据。升级前准备工作：

1）停止原2.4.5的服务，备份服务端安装目录下面的配置【config】文件夹和数据【Data】文件夹；

2）全新安装3.2.0版本配置中心服务端，先不要启动服务。

然后参考配置升级和数据升级，依次升级配置文件及数据文件，即完成版本升级至3.2.0。之后再参考3.2.0以后的版本升级过程继续升级。

Ø3.2.0以后的版本升级：

停止数据库所有服务，可直接运行新版本的安装程序，安装程序会自检发现已安装版本，并进入自动升级安装过程。安装过程可能会出现一些黑窗口，请不要关闭，让其进行，直至出现安装完毕的提示。

注意3.6.0之前版本需先升级到3.5.0，然后再升级到3.6.0，历史版本的升级路线见下图：


配置升级

Navigation: 功能明细 > 升级工具 >

配置升级

 Return to chapter overview

步骤：

1.从V3版本安装目录下的executable文件夹，打开hdUpdateConfig.exe，弹出如下界面：

2.选择一个2.4.5版本的Kernel.db文件，升级工具将把该文件中配置升级到V3版本的配置中心PostgreSQL数据库中。

3.输入PostgreSQL数据库实例名，即V3版本配置中心安装时设置的PostgreSQL数据库中的实例名。

4.输入PostgreSQL数据库的用户名和密码。

5.单击“执行”按钮，开始升级配置。

注意：

1.Kernel.db这个文件在原2.4.5服务端的config目录，如果升级前备份到单独文件夹，注意路径中不可以含有中文。

2.许可证文件License.xml要从原config目录拷贝到新安装的V3版本config目录。

3.客户端本地配置信息不自动升级。建议备份2.4.5版本客户端config目录后安装V3版本的客户端，部分不兼容的客户端配置咨询支持人员修改。

4.不能直接用老版本的Excel导出文件上传到v3服务器，因为excel列格式不同了，请重新下载v3最新格式编辑后再上传。


数据升级

Navigation: 功能明细 > 升级工具 >

数据升级

 Return to chapter overview

步骤：

1.启动V3的全部服务，打开服务管理工具，等待Kernel服务状态从“启动中”变为“正在运行”，并且等安装目录下iHyperDB\config文件夹中的config.db文件更新以后，这期间系统将生成空的数据文件在V3的Data目录下。

2.停止V3的全部服务，拷贝V2的Data文件夹内Alarm、Archive、BlockCache文件到V3的Data目录下。

3.从V3版本安装目录下的executable文件夹，打开 hdUpdateDataTool.exe ，弹出如下界面：

4. 拷贝V2的Data/SeqFile文件夹的内容拷贝到V3所在的本地机器，“待升级的缓存数据目录”填写该文件夹的路径。 例如：C:\update\Data\SeqFile

5.启动V3服务。

6. 点击升级工具的“开始升级”，等待升级完成。

注意事项：

V3版本安装数据节点时配置的参数（序列缓存大小和归档文件大小），要和V2版本一致。


Solaris下的iHyperDB

Navigation: »No topics above this level«

Solaris下的iHyperDB

 Return to chapter overview

iHyperDB提供Oracle sparc架构Solaris系统服务端.

功能与windows服务端差别:

1. 不包含组态服务端；

2. 不包含大数据采集器；

3. 增加转储到关系库服务部署在配置中心服务端，测试支持mysql关系数据库.


Solaris下的iHyperDB完整安装

Navigation: Solaris下的iHyperDB >

Solaris下的iHyperDB完整安装

 Return to chapter overview

预备工作：

1.具备root帐户权限。

2.安装SolarisStudio的C++运行库

因采用Sun C/C++编译器编译生成，需要依赖SolarisStudio的运行时环境。需要安装SolarisStudio的C++运行库。

1)申请Oracle ID获取许可证书

根据Oracle的规则，SolarisStudio的安装需要向Oracle申请免费的许可，申请时需要注册Oracle ID。

申请Oracle ID的网址：https://pkg-register.oracle.com/register/cert_info/11882/

许可证书包含两个文件：Oracle_Solaris_Studio.key.pem 和 Oracle_Solaris_Studio.certificate.pem。

2)安装SolarisStudio的C++库

安装步骤：

mkdir -m 0755 -p /var/pkg/ssl

cd /var/pkg/ssl/

pkg set-publisher -k /var/pkg/ssl/Oracle_Solaris_Studio.key.pem -c /var/pkg/ssl/Oracle_Solaris_Studio.certificate.pem -G '*' -g https://pkg.oracle.com/solarisstudio/release solarisstudio

pkg install solarisstudio-123/library/c++-libs

注意：使用pkg命令，系统管理员需要事先配置好IPS。一般来说，操作系统安装完毕，缺省情况下IPS的发布包指向ORACLE网站的release更新，这种情况需要保证服务器可以联网。

运行库安装步骤：

v解压SolarisStudio12.3-solaris11-sparc-bin.tar

在SolarisStudio12.3-solaris11-sparc-bin.tar解压包同级目录下，将压缩包放在/opt目录下

#tar -zxvf SolarisStudio12.3-solaris11-sparc-bin.tar

v解压出SolarisStudio12.3-solaris-sparc-bin文件夹，需要把下面这两个路径配置到系统环境

/opt/SolarisStudio12.3-solaris-sparc-bin/solarisstudio12.3/bin/sparcv9

/opt/SolarisStudio12.3-solaris-sparc-bin/solarisstudio12.3/lib/stlport4/v9

打开profile文件

#vi ~/.profile

在文件里写入:

export LD_LIBRARY_PATH=/opt/SolarisStudio12.3-solaris-sparc-bin/solarisstudio12.3/bin/sparcv9:/opt/SolarisStudio12.3-solaris-sparc-bin/solarisstudio12.3/lib/stlport4/v9:/usr/mysql/5.5/lib/sparcv9

:wq保存退出后

#source ~/.profile

3.修改执行客户端或代理的每个shell中的文件描述符限制

Solaris 和 Linux 平台，运行客户端或代理的 shell 对进程可以使用的文件描述符数量的限制不是很严格。在 Message Queue 中，客户端创建的每个连接或代理接受的每个连接都使用其中一个文件描述符。每个具有持久性消息的物理目的地也使用文件描述符。因此，文件描述符限制限定了代理或客户端可以具有的连接数。

默认情况下，Solaris 最多可具有 256 个连接，Linux 最多可具有 1024 个连接。（在实践中，由于将文件描述符用于持久性，因此连接限制实际上低于此值。）某些服务需要的连接数高于此值，则必须修改、提高将要执行客户端或代理的每个 shell 中的文件描述符的最大限制数。

修改文件描述符的最大限制数的方法：

v使用ulimit命令：ulimit –n 65535。ulimit只能使当前shell及其子进程生效，一旦shell退出设置即失效；

v在/etc/system文件中增加以下两个参数，然后重启系统。

set rlim_fd_cur=65535

set rlim_fd_max=65535

安装iHyperDB：

iHyperDB v3的服务端包括“配置中心ConfigCenter”和“数据节点DataNode”。

注：配置中心和数据节点可以部署在同一台机器上，但需使用相同安装目录。

1.安装配置中心ConfigCenter

1)登录root账户

若当前为非root用户登录，则需切换：

$su - root

2)上传安装包至服务器

假设路径/opt/soft(路径可自行定义,但不支持/root目录下)

安装包名称形如：ihd3solaris64_ConfigCenter_3.x.tag.gz

3)解压安装包

切换到安装包所在路径

#cd /opt/soft

解压

#tar -zxvf ihd3solaris64_ConfigCenter_3.x.tag.gz

4)修改安装脚本，配置预读文件setup.ini

#cd iHyperDB3

#vi setup.ini

这里使用系统自带的vi编辑器，若使用windows的编辑器可能导致换行符和linux系统不一致！

修改setup.ini里面配置参数（下述参数非常重要，需随实际情况对应修改）:

vCCEnableRedundancy：表示是否使用冗余；使用，赋值1；不使用，赋值0。

vCCIP：为配置中心IP

vCCBKIP：指备机的IP（当启用冗余时需填）

v主备Port：默认填5673

vLocalIP：当前安装机器的IP

所有参数都直接加在=后面，不要加多余字符（包括空格）。

:wq

在vi编辑器按键盘Esc，然后输入上面3个字符后回车，完成setup.ini修改并退出编辑器。

5)运行安装脚本

#./hdCCsetup

如提示没有权限则运行脚本，设置运行权限：

#chmod +x hdCCsetup

如出现：

mv: overwrite `/opt/test/iHyperDB3/config/LogConfigCenter.xml'?

输入“y”,表示yes，覆盖原文件。

……

Success!

……

Relogon and start server by running script..

以上完成配置中心服务端的安装。

6)启动配置中心

上述安装完成后，使用root用户重新登录，在iHyperDB安装目录下运行启动脚本：

#./hdCCstart

另，停止服务脚本为：

#./hdCCstop

查看服务状态脚本为：

#./hdCCproc

2.安装数据中心DataNode

1)登录root账户

若当前为非root用户登录，则需切换：

$su - root

2)上传安装包至服务器

假设路径/opt/soft(路径可自行定义,但不支持/root目录下)

安装包名称形如：ihd3solaris64_DateNode_3.x.tar.gz

3)解压安装包

切换到安装包所在路径

#cd /opt/soft

解压

#tar -zxvf ihd3solaris64_DateNode_3.x.tar.gz

4)修改安装脚本，配置预读文件setup.ini

#cd iHyperDB3

#vi setup.ini

这里使用系统自带的vi编辑器，若使用windows的编辑器可能导致换行符和linux系统不一致！

修改setup.ini里面配置参数（下述参数非常重要，需随实际情况对应修改）:

vCCIP：配置中心IP；

vDNIP：第一个数据节点IP；注意：根据实际机器IP填入；

vCCEnableRedundancy：配置中心是否冗余；冗余，赋值1；不冗余，赋值0。

vDNEnableRedundancy：数据节点是否冗余；冗余，赋值1；不冗余，赋值0。

vCCBKIP：配置中心备机IP；当配置冗余时需填，其中主备Port一般默认取5673端口。

vDNBKIP：第一个数据节点备机IP；当配置冗余时需填，其中主备Port一般默认取5673端口。

vLocalIP：当前安装机器的IP；

vMEMCACHE：hdKernel缓存大小，单位MB；

vDATAFILESIZE：单个归档文件大小，单位MB；

vDATAFILENUM：最大归档文件个数；

注意：上面2项相乘的大小不要超过硬盘容量。

所有参数都直接加在=后面，不要加多余字符（包括空格）。

:wq

在vi编辑器按键盘Esc，然后输入上面3个字符后回车，完成setup.ini修改并退出编辑器。

5)运行安装脚本

运行脚本

#chmod +x hdDNsetup

设置运行权限

#./hdDNsetup

脚本结束

Success!

..

Relogon and start server by running script..

以上完成数据节点服务端的安装。

6)启动数据节点服务

上述安装完成后，使用root用户重新登录，在iHyperDB3安装目录下运行启动脚本：

#./hdDNstart

停止服务脚本

#./hdDNstop

查看服务状态脚本

#./hdDNproc

3.启停服务管理（推荐）

可将配置中心和服务中心均采用此法同时启动

#screen -S ihd1

创建一个窗口，ihd1为窗口名，此时当前窗口已为ihd1

#cd runtime

ihd1为窗口名，

#./../executable/ihdprocessmgr

前面的./../是写你的executable存放路径。在runtime文件夹内运行executable下的ihdprocessmgr，此时ihd服务开始启动并自重启。

#Ctrl a d

同时按Ctrl键+a键+d键,可退出ihd1窗口，回到原窗口

#cd iHyperDB3

回到iHyperDB3文件夹

# ./hdproc

查询ihd运行状态，此时会发现状态是running了

#screen -ls

查询有多少类似ihdb1的窗口，防止之前有人开过类似的窗口，但是不影响操作。

#screen -r ihd1

远程回到ihd1窗口，如有多个ihd1，加上前缀使用全称来区分不通的窗口。

#q

ihdprocessmgr开始退出服务

# Ctrl a d

#cd iHyperDB3

#./hdproc

重复之前的三个操作，可查看此时的ihd的运行状态为stop

# screen -d ihd1

在原窗口远程detach ihd1。当在原窗口发现ihd1处于attach状态，无法用screen -r ihd1进入ihd1时，执行该-d命令

4.MySQL数据库转储配置

实现功能：

将Solaris机器上iHyperDB中的Tag点数据以原始值或插值等格式转存到mysql数据库。

操作：

v需一台Windows机器，运行windows版本的iHyperDB_Client.exe安装客户端；

v使用客户端连接如上安装完成服务端的Solaris机器，接下来进行转储配置,可参考userhelp.chm中,功能明细>>数据保存>>数据转储>>关系数据库连接配置，使用mysql数据库的转储方式，配置完成后确认保存；

v在Windows机器中，于客户端的安装目录找到iHyperDB\config\HDExport.xml和ClientCfg.xml两个文件。HDExport.xml中有转储配置完成后的规则信息等用于转储执行程序hdRDBExporter读取。将2个xml配置文件复制到Solaris机器中对应目录iHyperDB\config\下，然后运行hdCCstop和hdCCstart ，转储功能即启用新的配置。注意修改配置后都更新xml文件。

v可使用MySQL-Front.exe等相关软件查看转储得到的数据库。

注意：

mysql转储运行需要文档最开头环境变量配置libmysql的动态库路径，可在Solaris机器中使用env查看LD_LIBRARY_PATH中是否存在/usr/mysql/5.5/lib/sparcv9，如遗漏请补回。

5.FAQ

1)许可证文件路径为数据节点服务端安装目录的config/license.xml。

部署许可证文件后,重新启动服务才生效！

2)如何卸载服务端？

先停止服务（运行hdDNstop和hdCCstop脚本），然后删除安装目录。

3)数据节点服务端参数配置在安装路径的config/ServerCfg.xml文件中，可能需要修改（注意修改后重新启动服务才生效）：

<ArchiveFile Num="3" 保存的数据归档文件个数

<NetworkPort="5678" />，服务端对外监听端口，如果修改了，那么客户端访问时的参数配置也要相应修改。

<TimeStamp Enable="1" MaxTimeDevSec="1800"/>，服务器时间和采集器时间戳不同会丢弃数据，MaxTimeDevSec参数为时间差,单位秒, Enable="1"的配置改为0则不丢弃。但是可能产生数据查询的时间与服务端不一致,请配置人员一定要确认最终客户应用需求,并告知客户。

4)网络数据量大的局域网可以关闭系统防攻击功能来提高性能

方式一、重启后生效.

set ip:tcp_do_reclaim=0

方式二、在线修改，无需重启，但重启后配置无效.

echo tcp_do_reclaim/W 0 | mdb -kw

5)扩大系统网络缓冲区配置的方法（重启服务器生效）

v扩大TCP buffer

# ipadm show-prop -p max_buf=8388608 tcp

# ipadm set-prop -p recv_buf=4194304 tcp

# ipadm show-prop -p send_buf=4194304 tcp

?max_buf为网络收发总的上限，为二者之和，将之设置为8M。

?recv_buf和send_buf分别为收发缓冲上限，均设置为4M。

另附查询系统当前配置命令：

#  ipadm show-prop -p recv_buf tcp
PROTO PROPERTY              PERM CURRENT      PERSISTENT   DEFAULT      POSSIBLE
tcp   recv_buf              rw   128000       --           128000       2048-1048576

# ipadm show-prop -p send_buf tcp
ROTO PROPERTY              PERM CURRENT      PERSISTENT   DEFAULT      POSSIBLE
tcp   send_buf              rw   49152        --           49152        4096-1048576

# ipadm show-prop -p max_buf tcp
PROTO PROPERTY              PERM CURRENT      PERSISTENT   DEFAULT      POSSIBLE
tcp   max_buf               rw   4194304      --           1048576      131083-1073741824

v扩大tcp_conn_req_max_q和tcp_conn_req_max_q0

修改命令：

# ipadm set-prop -p _conn_req_max_q=16384 tcp
# ipadm set-prop -p _conn_req_max_q0=16384 tcp

此参数设置默认的TCP连接的最大数目，系统默认值为128，现设置为16k。

另外，查询系统当前配置命令为：

# ipadm show-prop -p _conn_req_max_q tcp
PROTO PROPERTY              PERM CURRENT      PERSISTENT   DEFAULT      POSSIBLE
tcp   _conn_req_max_q       rw   128        --           128          1-4294967295

# ipadm show-prop -p _conn_req_max_q0 tcp
PROTO PROPERTY              PERM CURRENT      PERSISTENT   DEFAULT      POSSIBLE
tcp   _conn_req_max_q0      rw   1024        --           1024         0-4294967295

6)网络性能问题重现时现场信息获取

v客户端和服务端抓包；

v客户端和服务端日志备份；

vvmstat 1，获取服务器的状态值，参数1表示1秒采集一次，输出可重定向到文件；

vmpstat 1，获取 CPU 相关统计信息，参数1表示1秒采集一次，输出可重定向到文件；

viostat -cnxz 1，用于监控系统设备的IO负载情况，参数1表示1秒采集一次，输出可重定向到文件；

vprstat 1，系统进程监控，参数1表示1秒采集一次，输出可重定向到文件；

vcat /var/adm/message，查看系统记录的异常信息；

v查询操作系统版本：pkg info entire。


Solaris下的iHyperDB快速安装

Navigation: Solaris下的iHyperDB >

Solaris下的iHyperDB快速安装

 Return to chapter overview

iHyperDB v3的服务端包括配置中心ConfigCenter和数据节点DataNode。

快速安装介绍配置中心和数据节点在一个机器的部署方法。

前提：

1.具备root帐户权限。

2.因采用Sun C/C++编译器编译生成，需要依赖SolarisStudio的运行时环境。这需要安装SolarisStudio的C++运行时库。

安装：

1.用root帐户登陆系统，

非root用户登录，则需切换

$su - root

转到root用户。

2.上传安装包到服务器，

假设路径/opt/soft(路径可自行定义,但不支持/root目录下)，

安装包名称形如：

ihd3solaris64_ConfigCenter_3.x.tar.gz

ihd3solaris64_DateNode_3.x.tar.gz

3.解压安装包

切换到安装包所在路径

#cd /opt/soft

解压

#tar -zxvf ihd3solaris64_ConfigCenter_3.X.tar.gz

#tar -zxvf ihd3solaris64_DateNode_3.X.tar.gz

4.修改安装脚本配置预读文件setup.ini

#cd iHyperDB3

#vi setup.ini

这里使用系统自带的vi编辑器，若使用windows的编辑器可能导致换行符和linux系统不一致！

修改setup.ini里面配置参数，

下述参数较重要需随实际情况注意对应修改:

1>CCEnableRedundancy,DNEnableRedundancy表示是否使用冗余,如果使用取1,不使用取0;

2>CCIP(配置中心IP)，

3>DNIP(第一个数据节点IP)，

CCIP与DNIP注意根据实际机器IP填入；

4>CCBKIP与DNBKIP指备机的IP，当使用冗余时需填入使用，

5>配置中心Port一般默认取5673，数据节点Port一般默认为5678，

6>LocalIP指当前安装机器的IP.

上述参数较重要需随实际情况注意对应修改;

其他可修改项:

>MEMCACHE是hdKernel缓存大小，单位MB；

>DATAFILESIZE是单个归档文件大小，单位MB；

>DATAFILENUM是最大归档文件个数，

注意上面2个相乘(DATAFILESIZE与DATAFILENUM)的大小不要超过硬盘容量。

参数输入格式:

所有参数都直接加在=后面，不要加多余字符（包括空格）。

如:

DNBKPORT=5678 (正确) ,

DNBKPORT= 5678(错误,参数与等号间多了空格).

:wq

在vi编辑器按键盘Esc，然后输入上面3个字符后回车，完成setup.ini修改并退出编辑器。

5.运行安装脚本

#./hdCCsetup

#./hdDNsetup

脚本运行完后,安装结束.在iHyperDB3的根目录下能看到Log_setup.txt的日志，正确安装后有hdCCsetup与hdDnsetup被执行结束的日志。

初次安装请重启机器,使环境变量生效.

6.启动配置中心服务

注意上述安装完成后使用root用户重新登录机器，在iHyperDB3安装目录下运行启动脚本：

#cd $iHyperDB

#./hdCCstart

停止服务脚本

#./hdCCstop

查看服务状态脚本

#./hdCCproc

7.启动数据节点服务

在iHyperDB3安装目录下运行启动脚本：

#./hdDNstart

停止服务脚本

#./hdDNstop

查看服务状态脚本

#./hdDNproc

8.启停服务综合管理

启停服务综合管理方法（此方法启动等同于同时操作上述的 6和7的步骤，将数据节点服务和配置中心服务同时启动）

#screen -S ihd1

创建一个窗口，ihd1为窗口名，此时当前窗口已为ihd1

#cd runtime

ihd1为窗口名，

#./../executable/ihdprocessmgr

前面的./../是写你的executable放在哪个文件夹下面了。在runtime文件夹内运行executable下的ihdprocessmgr，此时ihd服务开始启动并自重启

#Ctrl a d

同时按Ctrl键+a键+d键,可退出ihd1窗口，回到原窗口

#cd iHyperDB3

回到iHyperDB3文件夹

# ./hdproc

查询ihd运行状态，此时会发现状态是running了

#screen -ls

查询有多少类似ihdb1的窗口，防止之前有人开过类似的窗口，但是不影响操作。

#screen -r ihd1

远程回到ihd1窗口，如有多个ihd1，加上前缀使用全称来区分不通的窗口。

#q

ihdprocessmgr开始退出服务

# Ctrl a d

#cd iHyperDB3

#./hdproc

重复之前的三个操作，可查看此时的ihd的运行状态为stop

# screen -d ihd1

在原窗口远程detach ihd1。当在原窗口发现ihd1处于attach状态，无法用screen -r ihd1进入ihd1时，执行该-d命令

9.卸载IHD

首先停止服务,

#./hdCCstop

#./hdDNstop

然后删去iHyperDB目录即可

rm -r iHyperDB


使用hdupdate快速升级操作手册

Navigation: Solaris下的iHyperDB >

使用hdupdate快速升级操作手册

 Return to chapter overview

hdupdate快速支持3.2.x到3.5.x，3.5.x到3.6.x的升级。

1.升级前确认ihd的环境变量$iHyperDB，即ihd的工作路径。注意升级前须关闭当前ihd服务(hdCCstop和hdDNstop脚本停止服务)。

2.将新版本ihd安装包ConfigCenter与DataNode在同级目录解压（注：另找路径，不要与旧ihd安装路径重叠，防止解压过程中覆盖了旧ihd文件）.

先给脚本运行权限chmod +x hdupdate

然后执行该脚本./hdupdate

执行后可在当前工作路径得到cpfile文件夹，内部备份了原config文件夹和executable文件夹，若想还原ihd，将这两个文件复制替换原文件夹即可，

示例：

原ihd装在/opt/iHyperDB下

首先关闭原ihd服务

cd /opt/iHyperDB

./hdCCstop

./hdDNstop

然后把新版本ihd安装包解压，我们在/var下解压:

cd /var

tar xvf ihd3solaris64_ConfigCenter_3.x.tar.gz

tar xvf ihd3solaris64_DateNode_3.x.tar.gz

cd iHyperDB3/

chmod +x hdupdate

./hdupdate

看到finish执行结束，升级完成.

然后可以重新启动服务查看数据是否正常了。

注意需切换到 $iHyperDB 路径启动服务。


FAQ

Navigation: Solaris下的iHyperDB >

FAQ

 Return to chapter overview

Enter topic text here.


重启服务失败

Navigation: Solaris下的iHyperDB > FAQ >

重启服务失败

 Return to chapter overview

当重启ihd服务失败时，执行下./hdClean ，进行对进程间通信的清理，来保证第二次ihd启动时环境干净，但因为脚本对root用户的共享空间进行信号清理，会对其他进程产生影响，比如ihd和icv装在一起时，执行hdClean清理信号会导致icv服务退出，需要对icv也进行重启。


Linux下的iHyperDB

Navigation: »No topics above this level«

Linux下的iHyperDB

 Return to chapter overview

iHyperDB提供x86_64架构Linux系统服务端。

功能相比windows服务端差别： 不包含组态服务端。

linux服务端也不支持转储到关系数据库的功能。


Linux下的iHyperDB完整安装

Navigation: Linux下的iHyperDB >

Linux下的iHyperDB完整安装

 Return to chapter overview

Linux x64安装iHyperDBv3服务端

分布式实时历史数据库iHyperDB v3的服务端包括配置中心ConfigCenter和数据节点DataNode。

注：配置中心和数据节点可以部署在不同机器上，也可部署在同一台机器上，部署在同一台机器时需使用相同安装目录。

配置中心ConfigCenter安装配置

1.用root帐户登陆系统

非root用户登录，则需切换账号：

$su - root

2.上传安装包到服务器

假设路径为：/opt/soft （安装包暂存路径可自行定义,但不支持/root根目录下)

安装包名称形如：ihd3redhat7x64_ConfigCenter_3.xx.tar.gz

3.解压安装包

切换到安装包所在路径命令：

#cd /opt/soft

解压安装包命令：

#tar -zxvf ihd3redhat7x64_ ConfigCenter_3.XX.tar.gz

4.修改安装脚本配置预读文件setup.ini

#cd iHyperDB3

#vi setup.ini

（这里使用系统自带的vi编辑器，若使用windows的编辑器可能导致换行符和linux系统不一致!)

修改setup.ini里面配置参数，下列参数重要需随实际情况注意对应修改：

a.CCEnableRedundancy：表示配置中心是否启用冗余,“1”：冗余，“0”：不冗余；

b.CCIP：配置中心IP；

c.CCBKIP：备用配置中心IP，当启用冗余时需填入；

d.主备Port：一般默认取5673；

e.LocalIP：指当前安装机器的IP。

所有参数都直接加在“=”后面，不要加多余字符（包括空格）。

在vi编辑器中按键盘Esc，然后输入 :wq 回车，即完成setup.ini修改并退出编辑器。

5.运行安装脚本

#./hdCCsetup

如提示没有权限则运行脚本，设置运行权限：

#chmod +x hdCCsetup

如出现覆盖文件请求 “mv: overwrite `/root/.bashrc'?”

需输入y,表示yes覆盖原文件。

系统出现以下提示，说明完成配置中心服务端安装。

..

Success!

..

Relogon and start server by running script..

6.启动配置中心服务

上述安装完成，使用root用户重新登录，在iHyperDB3安装目录下：

启动服务命令：

#./hdCCstart

停止服务命令：

#./hdCCstop

查看服务状态命令：

#./hdCCproc

7.Modbus采集器服务

Linux服务端提供modbus采集器服务，但是需要在windows客户端中进行配置。将客户端config文件夹的CollectorCfg.xml拷贝到服务端config文件夹。配置更新后，需重启配置中心服务（先后执行停止配置中心#./hdCCstop及启动配置中心#./hdCCstart命令）。

数据节点DataNode安装配置

1.用root帐户登陆

非root用户登录，则需切换账号：

$su - root

2.上传安装包到服务器

假设路径为：/opt/soft （安装包暂存路径可自行定义,但不支持/root根目录下)

安装包名称形如：ihd3redhat7x64_DateNode_3.xx.tar.gz

3.解压安装包

切换到安装包所在路径命令：

#cd /opt/soft

解压安装包命令：

#tar -zxvf ihd3redhat7x64_ DateNode_3.XX.tar.gz

4.设置安装脚本预读文件setup.ini

#cd iHyperDB3

#vi setup.ini

（这里使用系统自带的vi编辑器，若使用windows的编辑器可能导致换行符和linux系统不一致!)

修改setup.ini里面配置参数，下列参数重要需随实际情况注意对应修改：

a.CCIP：配置中心IP（根据机器实际IP填写）；

b.DNIP：多个数据节点，填写第一个数据节点IP（根据机器实际IP填写）；

c.CCEnableRedundancy：表示配置中心是否启用冗余,“1”：冗余，“0”：不冗余；

d.DNEnableRedundancy：表示数据节点是否启用冗余,“1”：冗余，“0”：不冗余；

e.CCBKIP：备用配置中心IP，当启用冗余时需填入；

f.DNBKIP：备用数据节点IP，当启用冗余时需填入；

g.主备Port：一般默认取5673；

h.LocalIP：指当前安装机器的IP；

i.MEMCACHE：是hdKernel缓存大小，单位MB；

j.DATAFILESIZE：是单个归档文件大小，单位MB；

k.DATAFILENUM：是最大归档文件个数。

所有参数都直接加在“=”后面，不要加多余字符（包括空格）。

在vi编辑器中按键盘Esc，然后输入 :wq 回车，即完成setup.ini修改并退出编辑器。

5.运行安装脚本

#./hdDNsetup

如提示没有权限则运行脚本，设置运行权限：

#chmod +x hdDNsetup

系统出现以下提示，说明完成数据节点服务端安装。

Success!

..

Relogon and start server by running script..

6.启动数据节点服务

上述安装完成，使用root用户重新登录，在iHyperDB3安装目录下：

启动服务命令：

#./hdDNstart

停止服务命令：

#./hdDNstop

查看服务状态命令：

#./hdDNproc

7.大数据采集转发服务配置

a.config/ServerCfg.xml文件的EnableExportBigData参数值请修改为“1”，表示启用大数据采集转发服务；

b.runtime目录下BigDataConfig.xml文件，修改大uri，token，identifier三个配置项，分别对应大数据平台连接参数，具体参数值请咨询大数据平台支持人员；

c.配置更新后需重启数据节点服务（分别先后执行停止命令#./hdDNstop及启动命令#./hdDNstart）。

启停服务综合管理

以下方法可以令配置中心和数据节点同时启动。（不含modbus采集器的启停）

#screen -S ihd1

创建一个窗口，ihd1为窗口名，此时当前窗口已为ihd1。

#cd runtime

切换至runtime文件夹

#./../executable/ihdprocessmgr

运行ihdprocessmgr，运行后ihd服务开始启动并自重启。（前面的./../是指executable文件夹实际安装路径）

#Ctrl a d

同时按Ctrl键+a键+d键,可退出ihd1窗口，回到原窗口。

#cd iHyperDB3

切换至iHyperDB3文件夹

# ./hdproc

查询ihd运行状态，此时可见当前状态是running。

#screen -ls

查询有多少类似ihdb1的窗口，防止之前有人开过类似的窗口，但是不影响操作。

#screen -r ihd1

远程回到ihd1窗口，如有多个ihd1，加上前缀使用全称来区分不通的窗口。

#q

开始退出ihdprocessmgr服务

# Ctrl a d

#cd iHyperDB3

#./hdproc

执行了退出命令后，可执行此三个命令，用于查看此时的ihd的运行状态，此时应为stop。

# screen -d ihd1

在原窗口远程detach ihd1。当在原窗口发现ihd1处于attach状态，无法用screen -r ihd1进入ihd1时，执行该-d命令

iHDv3.7.5以上版本（含v3.7.5），当配置中心与数据中心安装在同一台机器上，系统提供ihd数据库启动/停止简化命令，而无需上述配置：

#./hdstart

#./hdstop

注意事项

u许可证文件需放在每一台数据节点服务器安装目录的config文件夹中。

u卸载ihd服务端方法：先停止服务（运行hdDNstop和hdCCstop命令），然后删除安装目录。

u数据节点服务端参数配置在安装路径的config/ServerCfg.xml文件中，如发生修改，修改后需重启服务才生效。

配置文件中相关参数说明：

vArchiveFile Num：保存的数据归档文件个数；

vTimeStamp Enable：当服务器时间和采集器时间戳不同时丢弃数据，“1”丢弃，“0”不丢弃；

vMaxTimeDevSec：当TimeStamp Enable配置为“1”，此为时间差判断参数，单位：秒，即当服务器时间和采集器时间戳大于此参数则丢弃；

vNetworkPort=“5678”：服务端对外监听端口，缺省为5678。如果服务端修改，客户端对应参数也要修改。

u如果采集器需要使用buffer缓存功能，需修改配置中心安装目录的config/HD3Buffer.xml文件，注意buffer路径需正确。配置修改后，需重启配置中心服务。

uPostgreSQL服务手工启动：

root用户下，启动PostgreSQL服务命令：

#service postgresql-9.4 start

重启pgsql服务命令：

# service postgresql-9.4 restart

postgresql数据库连接测试方法：

在客户端机器打开pgsgresql的客户端pgAdmin III连接。

主机填写PGSQL机器IP（Linux查询命令#ip addr，即可看到IP），端口号5432，用户名postgres，密码是配置中心安装时setup.ini中设置的。


Linux下的iHyperDB快速安装

Navigation: Linux下的iHyperDB >

Linux下的iHyperDB快速安装

 Return to chapter overview

快速安装适用于配置中心ConfigCenter和数据节点DataNode安装在同一台机器上的情况。

1.用root帐户登陆系统

非root用户登录，则需切换账号：

$su - root

1.上传安装包到服务器

假设路径为：/opt/soft （安装包暂存路径可自行定义,但不支持/root根目录下)

安装包名称形如：

ihd3redhat-x64_ConfigCenter_3.x.tar.gz

ihd3redhat-x64_DateNode_3.x.tar.gz

2.解压安装包

切换到安装包所在路径命令：

#cd /opt/soft

解压安装包命令：

#tar -zxvf ihd3redhat-x64_ConfigCenter_3.x.tar.gz

#tar -zxvf ihd3redhat-x64_DateNode_3.x.tar.gz

3.修改安装脚本配置预读文件setup.ini

#cd iHyperDB3

#vi setup.ini

（这里使用系统自带的vi编辑器，若使用windows的编辑器可能导致换行符和linux系统不一致!)

修改setup.ini里面配置参数，下列参数重要需随实际情况注意对应修改：

a.CCEnableRedundancy：表示配置中心是否启用冗余,“1”：冗余，“0”：不冗余；

b.DNEnableRedundancy：表示数据节点是否启用冗余,“1”：冗余，“0”：不冗余；

c.CCIP：配置中心IP（根据机器实际IP填写）；

d.DNIP：数据节点IP（根据机器实际IP填写）；

e.CCBKIP：备用配置中心IP，当启用冗余时需填入；

f.DNBKIP：备用数据节点IP，当启用冗余时需填入；

g.配置中心Port：一般默认取5673；

h.数据节点Port：一般默认取5678；

i.LocalIP：指当前安装机器的IP；

j.MEMCACHE：是hdKernel缓存大小，单位MB；

k.DATAFILESIZE：是单个归档文件大小，单位MB；

l.DATAFILENUM：是最大归档文件个数。

所有参数都直接加在“=”后面，不要加多余字符（包括空格）。

在vi编辑器中按键盘Esc，然后输入 :wq 回车，即完成setup.ini修改并退出编辑器。

4.运行安装脚本

#./hdsetup 安装iHyperDB

安装结束，在iHyperDB的根目录下能看到文件名为Log_setup.txt的日志，正确安装后有hdCCsetup与hdDnsetup被执行结束的日志。

初次安装后，请退出并重新登陆root帐户,使环境变量生效。

5.启动iHyperDB：

1) reboot重启机器，开机自动启动iHyperDB并自动修改系统设置（建议使用）

2) #./hdstart 启动iHyperDB

6.启动配置中心服务

在iHyperDB3安装目录下运行启动命令：

#./hdCCstart

停止服务命令：

#./hdCCstop

查看服务状态命令：

#./hdCCproc

7.启动数据节点服务

在iHyperDB3安装目录下运行启动命令：

#./hdDNstart

停止服务命令：

#./hdDNstop

查看服务状态命令：

#./hdDNproc

8.停止iHyperDB

#./hdstop 停止iHyperDB

9.Modbus采集器服务

Linux服务端提供modbus采集器服务，但是需要在windows客户端中进行配置。将客户端config文件夹的CollectorCfg.xml拷贝到服务端config文件夹。配置更新后，需重启配置中心服务（执行停止配置中心#./hdCCstop及启动配置中心#./hdCCstart命令）。

8.启停服务综合管理

启停服务综合管理方法（此方法启动等同于同时操作上述的 6和7的步骤，将数据节点服务和配置中心服务同时启动）

#screen -S ihd1

创建一个窗口，ihd1为窗口名，此时当前窗口已为ihd1

#cd runtime

ihd1为窗口名，

#./../executable/ihdprocessmgr

前面的./../是写你的executable放在哪个文件夹下面了。在runtime文件夹内运行executable下的ihdprocessmgr，此时ihd服务开始启动并自重启

#Ctrl a d

同时按Ctrl键+a键+d键,可退出ihd1窗口，回到原窗口

#cd iHyperDB3

回到iHyperDB3文件夹

# ./hdproc

查询ihd运行状态，此时会发现状态是running了

#screen -ls

查询有多少类似ihdb1的窗口，防止之前有人开过类似的窗口，但是不影响操作。

#screen -r ihd1

远程回到ihd1窗口，如有多个ihd1，加上前缀使用全称来区分不通的窗口。

#q

ihdprocessmgr开始退出服务

# Ctrl a d

#cd iHyperDB3

#./hdproc

重复之前的三个操作，可查看此时的ihd的运行状态为stop

# screen -d ihd1

在原窗口远程detach ihd1。当在原窗口发现ihd1处于attach状态，无法用screen -r ihd1进入ihd1时，执行该-d命令

9.卸载IHD

首先停止服务,

#./hdCCstop

#./hdDNstop

然后删去iHyperDB目录即可

rm -r iHyperDB


使用hdupdate快速升级操作手册

Navigation: Linux下的iHyperDB >

使用hdupdate快速升级操作手册

 Return to chapter overview

hdupdate快速支持 3.2.x到3.5.x，3.5.x到3.6.x的升级。

1.升级前确认ihd的环境变量$iHyperDB，即ihd的工作路径。

注意：升级前须关闭当前ihd服务（使用hdCCstop和hdDNstop命令停止服务）。

2.将新版本ihd安装包ConfigCenter与DataNode在同一个目录解压。

注意：该路径不要与旧ihd安装路径$iHyperDB相同，防止解压过程中覆盖了旧ihd文件。

先给脚本添加运行权限 chmod +x hdupdate

然后执行该脚本 ./hdupdate

执行后可在当前工作路径得到cpfile文件夹，内部备份了原config文件夹和executable文件夹，若想还原ihd，将这两个文件复制替换原文件夹即可。

升级示例：假设原ihd装在/opt/iHyperDB下。

1.关闭原ihd服务：

cd /opt/iHyperDB

./hdCCstop

./hdDNstop

2.将新版本ihd安装包解压，在/var下解压：

cd /var

tar xvf ihd3redhat6x64_ConfigCenter_3.x.tar.gz

tar xvf ihd3redhat6x64_DateNode_3.x.tar.gz

cd iHyperDB3/

chmod +x hdupdate

./hdupdate

看到finish执行结束，升级完成.

3.重新启动服务查看数据是否正常。

注意：需切换到 $iHyperDB 路径启动服务。

3.5升级到3.6时，需要注意：ConfigCenter.xml的postgresql的ip端口是否正确？ config/ConfigCenter.xml文件的Database属性的dsn="127.0.0.1需要替换为dsn="localhost:5432。

hdpatch 3.8.0补丁升级方法：

升级步骤：

1.3.8.0之前版本先升级到v3.8.0基础版本（使用安装包中的hdupdate脚本）

2.再使用hdpatch_3.8.0P**脚本执行补丁升级

注意：需要先配置好iHyperDB环境变量。

根据项目需求增减需启动的服务列表config/ServiceMgrTool_linux.xml

hdupdate 3.9.2升级补充操作：

· 使用web客户端，需手工添加RPCServer依赖库, 修改LogConfigCenter.xml和RPCServer.xml

· ServiceMgrTool_linux.xml增加需要的服务

注意：单独数据节点升级，CC的gz也解压缩，里面有个updateConfigDB.sql，拷贝到原来的iHyperDB3/config，然后在这个目录运行 sqlite3 Config.db ".read updateConfigDB.sql" 。


FAQ

Navigation: Linux下的iHyperDB >

FAQ

 Return to chapter overview


重启服务失败

Navigation: Linux下的iHyperDB > FAQ >

重启服务失败

 Return to chapter overview

当重启ihd服务失败时。

执行命令： ./hdClean

进行对进程间通信的清理，来保证第二次ihd启动时环境干净，但因为脚本对root用户的共享空间进行信号清理，会对其他进程产生影响，比如ihd和icv装在一起时，执行hdClean清理信号会导致icv服务退出，需要对icv也进行重启。


hdKernel无法启动，错误码24

Navigation: Linux下的iHyperDB > FAQ >

hdKernel无法启动，错误码24

 Return to chapter overview

linux启动iHyperDB时hdKernel无法启动，查看hdKernel启动日志出现错误如下图：

图中可以看到linux错误码24，错误为（Too many open files 打开过多的文件）,使用 ulimit –n 命令，可查看当前最多可以打开多少个文件。

解决方法：

添加系统资源上限值设置，例：

vi cvprocessmgr 在cvprocessmgr中增加一行代码：

ulimit –n 65535


典型案例

Navigation: »No topics above this level«

典型案例

 Return to chapter overview

典型案例主要介绍了iHyperDB中一些典型的应用案例。

©2016. All Rights Reserved.


典型案例3-关系数据库MYSQL采集到实时数据库

典型案例-关系数据库MYSQL采集到iHyperDB

Navigation: 典型案例 >

典型案例-关系数据库MYSQL采集到iHyperDB

 Return to chapter overview

配置案例：本案例中的关系数据库采用MySQL（版本为5.5及以上），通过在系统管理工具界面中配置转储界面，实现将关系数据库中的点采集到到实时数据库iHyperDB中的功能。

准备工作：服务端运行正常，MySQL中有要采集的数据表。

配置步骤如下：

一．打开关系数据库采集器配置配置界面，地址为“iHyperDB->客户端应用快捷链接->关系数据库采集器配置工具”

如下所示：

首先，要连接到一个实时数据库，请点击左上角的“链接”，进行连接。

二．添加数据库连接

在指定一个实时数据库后，“添加连接”按钮进入可点击状态：

点击“添加连接”，会弹出“添加关系数据库连接”的界面，

界面根据数据库类型显示连接数据所需要的一些参数，支持如界面所示的四种数据库采集。这里暂已SQL server为例进行配置：

测试连接，如成功会弹出如下界面：

点击确定，左侧关系数据库中就会出现添加的数据库连接，点击这个添加好的数据库连接，在右侧会显示连接的具体信息，如下图：

三. 添加表映射

以窄表为例：

点击添加表映射按钮，弹出对话框如下：

选择窄表，选择数据库中要采集的表名，并匹配好属性名和表中存在的字段，匹配正确后，点击确定。弹出下面对话框：

选择启用窄表规则，按照需要填入采集记录时间和规则执行时间，再已导入tag点中设置需要采集的tag点。如下图

配置完点击保存按钮。

重启一下“关系数据库采集服务”

在此界面上停止、启动。

即可在系统管理工具--数据源--历史记录查询中，查询到MySQL采集上来的数据。

需要注意的是：配置窄表和宽表时一定要和数据库中的窄表和宽表相对应。

导入的tag点名必须与数据库中要采集的tag名一致；

该tag点中的数据记录时间戳一定要滞后于数据库中数据的时间戳。


典型案例4-EXCEL展示数据、下载、上传

Navigation: 典型案例 >

典型案例4-EXCEL展示数据、下载、上传

 Return to chapter overview

本案例介绍如何使用EXCEL进行展示数据以及配置下载和上传的相关操作

1.安装了客户端工具后，打开excel就会在菜单栏“加载项”看到实时数据库的插件，实现下载上传的功能

2.Tag下载

3.对应有些tag点增加麻烦，可以用excel批量增加。方便起见可先下载某个类似的点，将其部分属性修改，点击上传。如将上图第19个数据的Tag名称改为“added_scadaname1_4”,上传。上次的时候，要选择创建（备注：如果有的是修改，有的是新增，则要选择创建并修改）

4.在实时记录查看中，可以查看到该Tag点创建成功

©2015. All Rights Reserved.


典型案例5-使用组态图库对象

Navigation: 典型案例 >

典型案例5-使用组态图库对象

 Return to chapter overview

1.安装

安装iHyperDB客户端，注意要勾选“组态配置与展示/HMI”选项。

2.节点管理配置

1)使用系统管理平台连接服务端。

2）在系统管理平台--分发配置--节点管理，添加iHyperDB服务节点和HMI节点。

3）点击右下角的分发

注意：请确认ihdServiceControl服务是运行状态（一般开机自动启动），否则将会分发失败。

3.组态管理配置

1）系统管理工具--分发配置--组态管理--图库管理，新建图库

2）图库设计器中新增图元。

下面假设iHyperDB数据源中已经存在点tag1、tag2、egg1、egg2

3）为图元设置模板名，添加自定义属性。如下模板名称为Tp1，自定义属性有2个(g1、g2),如下图所示，然后将图元中2个TxT文本动画关联@Tp1@g1和@Tp1@g2。

注意：这里的@Tp1@就是后续图元在组态画面实例化后对应的对象名，利用对象名的替换，将对象名与图元自定义属性的名称进行拼接为iHyperDB数据源中的Tag名。

4）新建画面，将上面保存的图库图元添加到组态画面中。

5）这里我们将添加的每个图元，设置图库特殊属性，SCADA名设置为第2步骤中实时数据库节点的名称，(变量)对象名设置为iHyperDB数据源的前缀，如ta和eg。

6）运行组态画面可以看到2个图元分别显示不同变量数据，即对象名为ta的，显示tag1和tag2数据；对象名为eg的显示egg1和egg2数据。

小结：上面利用图库对象名替换类模板名的方法进行面向对象的组态，不过要求iHyperDB中数据源名称需要有一定要求，即对应组态图库的对象名+属性名。


典型案例10-关系数据库postgres采集到实时数据库

典型案例10-关系数据库postgres采集到iHyperDB

Navigation: 典型案例 >

典型案例10-关系数据库postgres采集到iHyperDB

 Return to chapter overview

准备工作：服务端运行正常，postgreSQL中有要采集的数据表。

配置步骤如下：

一．打开关系数据库采集器配置配置界面，地址为“iHyperDB->客户端应用快捷链接->关系数据库采集器配置工具”

如下所示：

首先，要连接到一个实时数据库，请点击左上角的“链接”，进行连接。

二．添加数据库连接

在指定一个实时数据库后，“添加连接”按钮进入可点击状态：

点击“添加连接”，会弹出“添加关系数据库连接”的界面，

界面根据数据库类型显示连接数据所需要的一些参数，支持如界面所示的几种数据库采集。

postgreSQL关系数据库的配置如图所示：

对于postgreSQL，有如下几项填写信息：

ü 连接名称：用户自定义连接名称，不得与已有的连接重名；

ü 数据库名：填写要转到的数据库的名称，此处postgreSQL数据库名称为postgres；

ü 数据库地址：数据库服务器IP地址或者主机名；

ü 数据库端口：数据库服务器端口（如果使用默认端口，填写-1，否则填写实际端口号）；

ü 用户名和密码：分别是postgreSQL数据库自定义的用户名和密码；

测试连接，如成功会弹出如下界面：

三. 添加表映射

以窄表为例：

点击添加表映射按钮，弹出对话框如下：

选择窄表，选择数据库中要采集的表名，并匹配好属性名和表中存在的字段，匹配正确后，点击确定。弹出下面对话框：

选择启用窄表规则，按照需要填入采集记录时间和规则执行时间，再已导入tag点中设置需要采集的tag点。如下图

配置完点击保存按钮。

重启一下“关系数据库采集服务”

在此界面上停止、启动。

即可在系统管理工具--数据源--历史记录查询中，查询到postgreSQL采集上来的数据。

需要注意的是：配置窄表和宽表时一定要和数据库中的窄表和宽表相对应。

导入的tag点名必须与数据库中要采集的tag名一致；

该tag点中的数据记录时间戳一定要滞后于数据库中数据的时间戳。


典型案例11-实时数据库Windows集群配置与安装

Navigation: 典型案例 >

典型案例11-实时数据库Windows集群配置与安装

 Return to chapter overview

准备工作：

Ø操作系统安装及集群环境，请咨询主机网络工程师；

Ø下载好iHyperDB安装程序。

iHyperDB_ServerInstall_x64.exe

iHyperDB_DataNode_x64.exe

iHyperDB_Client_x64.exe

本案例环境为iHyperDB V3.0在集群环境配置安装的过程。iHyperDB的安装过程与最新版本略有差异（V3.6没有Python的安装），但集群配置过程依旧可以参考。

安装过程：

1.用域名登陆node1服务器，打开故障转移群集管理器。

2.点击连接到群集，输入群集名称，点击确定。

3.打开群集，点击存储—》磁盘，查看群集磁盘（共享磁盘）是否在node1上。若所有者节点在node1上，则跳过这一步。

4.若所有者节点在node2上，则选中群集磁盘—》移动可用存储—》选择节点—》选中节点名称，点击确定。

5.安装配置中心，配置中心程序名称为iHyperDB_ServerInstall.exe。

6.iHD有关的所有程序和数据都安装在共享磁盘上。

7.选择“是”。

8.点击安装“安装PostgreSQL关系库”。

9.PostgreSQL安装路径和数据路径应为iHD同一磁盘（共享磁盘）密码为postgres

10.安装完之后，回到实时数据库配置中心安装，点击下一步进行主备冗余配置中心设置（此步骤非常重要，涉及到ihd对外曝光的ip），并且不要勾选网络检测IP。

iHyperDB实时数据库系统由“配置中心”和“数据中心”构成，“配置中心”和“数据中心”均支持主/备方案。一个实时数据库机群，可由一组“配置中心”和N组“数据中心”构成。

11.安装数据节点，数据节点程序名称为iHyperDB_DataNode.exe。点击“是”—》继续安装或升级。

12.数据文件路径为和ihd安装在一个磁盘内（共享磁盘）

13.内存及磁盘空间参数设置（请参考系统安装参数说明）

14.下一步（如系统中没有选用本公司的大数据产品，此页直接点击“下一步”即可。)

15.服务器配置，选择多服务器，分布式节点部署方案，详见分布式系统架构说明。

这步需要选择和填写本机ip和配置中心主备机ip，但因这两个ip还未添加，所以在选择本机ip的时候找不到我们需要设置的ip。

打开网络和共享中心，添加“配置中心主机ip”作为本机ip的选择项。

16.数据节点服务器安装

配置中心主备机ip，同为上面主备冗余配置中心设置的主备机服务器ip一致。

点击下一步进行安装，然后把刚刚的添加的ip在同样的地方删除。

重启之后，群集磁盘会自动移动到node2上，需要手动移动到node1上之后再继续安装。

17.安装iHyperDB客户端

安装程序名称为iHyperDB_Client_x64.exe，选择“安装其他模块/升级更新”，点击“下一步”。

18.安装插件

此步这两个选项，根据项目需求来选择是否安装。

ØExcel插件注册表加载项——

Ø组态配置与展示/HMI

19.安装完毕，启动服务。

安装完毕之后，打开数据节点服务管理工具，点击启动服务，待服务成功启动之后，再点击停止服务。

注意：第一次启动hdKernel的启动状态会一直处于正在启动状态，这是因为添加数据节点还没有完成，完成数据节点添加hdKernel的启动就会完成。

20.添加数据节点服务器配置

系统管理工具-》数据节点配置-》添加

此时，node1上的ihd已经安装结束。然后打开故障转移群集管理器，把群集磁盘移动到node2上。

21.在NODE2上安装iHyperDB

把群集磁盘移动到node2上之后，到node2服务器上进行安装ihd。

首先，进入群集磁盘中，删除已经安装的iHyperDB和Python27文件夹，保证共享磁盘没有ihd相关的文件。

然后再按照node1上安装ihd的步骤在node2上安装一次，ip、路径、配置必须和node1上的安装时一致。

先安装iHyperDB_ServerInstall_x64

再安装iHyperDB_DataNode_x64，重启计算机

然后安装iHyperDB_Client_x64

最后打开数据节点服务管理器，启停ihd里面的各个服务。

注：在node2上安装ihd之后，则不需要删除群集磁盘中的iHyperDB和Python27文件夹。

22.iHyperDB配置集群服务

在node2上安装iHyperDB完成之后，打开故障转移群集管理器

右击角色—》配置角色

选择通用服务

【选择服务】第一次进入此向导时，选择 hdKernel。

【客户端访问点】需要一个独立名称和ip地址，该地址是对外发布的ip地址。这个ip地址供外界的程序来连接集群的数据库，非常重要！

地址为安装ihd时设置的主备机ip。

选择集群磁盘

跳过复制注册表

确认已配置好的服务和IP

添加第一个通用服务完成

按照刚刚的添加服务的方式【为角色添加所有iHyperDB相关服务】

右击这个角色—》添加资源—》通用服务，按照此方法反复添加iHyperDB相关的服务。【包括postgresql-9.4】

v为服务添加依赖关系

首先要了解每个服务的依赖关系，要查看服务的依赖关系。

可以从windows的服务中查看，运行命令：cmd->services.msc，打开window服务，点击某个服务的属性，就可以在window服务中看到某个服务的依赖关系

v点击集群管理器底部右侧的“资源”table页，按照第一步中看到的依存关系，为对应的服务添加依赖关系。如果在windows服务中，服务不依存于任何系统组件，那么，在为集群角色添加依存关系时，选择依赖hdkernel这个服务。

v基础的hdKernel服务需要添加集群ip资源和磁盘资源作为依赖

【验证】动配置的角色，如果配置成功，可以看到节点的状态为：正在运行，资源中配置的服务状态都为：联机。

【数据写入测试】向群集数据库中添加一个点。通过客户端向群集服务ip向该点写入数据，可以正常查询。模拟故障，服务转移到另一个节点，再次向该点写入数据，5分钟后再模拟故障转移，可以在另一个节点上查到第二次写入的数据。

至此安装配置完毕。


典型案例13-iHD2.4.5备份恢复升级

Navigation: 典型案例 >

典型案例13-iHD2.4.5备份恢复升级

 Return to chapter overview

本案例目的：

将A机（原服务器）的iHD 2.4.5中的数据、配置整体迁移至B机（新服务器），从而令B机在环境中替换下A机；B机升级至3.2.0版本。

整个数据及配置的备份恢复过程，由以下几步构成：

uB机安装环境准备；

uB机iHD 2.4.5安装、数据迁移与参数修改；

uB机从iHD 2.4.5升级至3.2.0；

uB机安装环境准备

1.B机操作系统安装；

2.B机网络IP设置；

uB机iHD 2.4.5安装、数据迁移与参数修改

1.B机全新安装iHD 2.4.5。安装时，“内存缓冲区大小”、“硬盘数据文件大小”、“硬盘数据文件个数”需与A机保持一致。调看三个参数的方法，详见Windows系统下的安装。

2.B机安装完成，不要启动iHD服务。停止A机iHD服务，并将A机\iHyperDB目录下的【config】和【Data】文件夹拷贝覆盖至B机对应位置。

3.编辑B机\iHyperDB\config\HDExport.xml文件，修改server ip为B机IP。如下图：

4.运行B机iHD服务端，启动B机“系统管理平台”，在服务器连接管理器中先点击“删除服务器”删除旧的服务器链接，再“添加服务器”添加新的服务器链接（IP地址为B机IP)；关闭并重运行“系统管理平台”，连接刚刚配置好的服务器链接。

5.此时，可在B机的“系统管理平台->任务面板->数据源”中，查看到原A机中相关TAG点数据。在“系统管理平台->任务面板->数据转储”中，查看到原A机中关系数据库的转储配置。至此，B机已经可以替代A机在系统中运行。其他应用需要访问B机的，需要修改连接服务器的IP，修改为B机IP。如果希望新安装的B机IP地址配置也完全复制A机，避免其他相关系统发生联锁修改，请在B机环境准备时，就将IP地址设置成为与A机一致。

uB机从iHD 2.4.5升级至3.2.0；

1.停止B机iHD 2.4.5的服务，备份【config】和【Data】文件夹，路径中不可有中文字符。备份license.xml授权文件。

2.卸载B机iHD 2.4.5，选择保留数据方式。

3.安装iHD 3.2.0，安装程序包会自动发现原有安装目录及数据文件，选择升级安装，安装完成后先不要启动iHD服务。

4.升级配置文件

v运行\iHyperDB\executable\hdUpdateConfig.exe文件，填写配置信息，选择2.4.5版本备份文件中的\config\Kernel.db文件，升级工具将把该文件的配置升级到V3版本的配置中心PostgreSQL数据库中；输入PostgreSQL数据库实例名，即V3版本配置中心安装时设置的PostgreSQL数据库中的实例名；输入PostgreSQL数据库的用户名和密码;如下图：

v单击“执行”按钮，开始数据文件的升级。

v升级成功

v将原V2.4.5备份的【config】文件夹下的HDExport.xml和HDExport.db拷贝至3.2.0版本config目录下。

v打开\iHyperDB\config\HDExport.xml文件，在<HD2RDB version="1.2">下添加一行：<iHyperDB check_connection_cycle="30" />，保存。

5.升级数据文件

v启动V3.2.0的全部服务，打开服务管理工具，等待Kernel服务状态从“启动中”变为“正在运行”，并且等安装目录下iHyperDB\config文件夹中的config.db文件更新以后，这期间系统将生成空的数据文件在V3.2.0的Data目录下。

v停止V3.2.0的全部服务，拷贝V2.4.5的【Data】文件夹内的Alarm、Archive、BlockCache文件到V3.2.0的Data目录下。

v运行V3.2.0版本\iHyperDB\executable\hdUpdateDataTool.exe文件；参数“待升级的缓存数据目录”填写备份的V2.4.5的\Data\SeqFile目录；参数“升级后的配置服务IP”填写B机IP；服务端口请不要修改；用户名、口令同为：admin。

v启动V3.2.0的全部服务，然后点击上图“开始升级”，等待升级完成。

后续版本升级说明：

viHDB3.2.0升级到3.5.0，直接覆盖安装即可。

viHDB3.5.0升级到3.6.0，直接覆盖安装即可。


典型案例14-资源组权限配置

Navigation: 典型案例 >

典型案例14-资源组权限配置

 Return to chapter overview

本案例介绍如何配置数据的读写权限

权限对应关系为：

1.创建用户

连接服务器成功后，进入"用户与组"浏览框架，其中列出所连接的服务器上的用户和组信息。

选择"用户"页面，右击鼠标后，在弹出的菜单项中，

点击【创建用户…】菜单会弹出创建用户对话框，录入希望创建的用户信息后，点击【确定】按钮即可以创建一个新的用户；

如图：分别创建test1、test2、test三个用户：

2.创建用户组

选择"用户组"页面，右击鼠标后，在弹出的菜单项中，点击"创建组…"

菜单会弹出创建组对话框，录入希望创建的组信息后，点击【确定】按钮即可以创建一个新的组；

3.用户组绑定用户

双击相应组，在组属性-成员列表中添加用户

4.创建资源组

在“资源组”空白处点击右键，点击“创建资源组”，分别配置tag点读/写/读写权限，点击确认，完成资源组创建：

5.资源组与用户组关联

创建完成资源组后，双击该资源组，在所属用户组配置页面对该资源组与用户组进行关联：

6.tag点与资源组关联

双击资源组，打开“Tag点配置”tab页，添加相应点：

或者点击“数据源”-“Tag点变量配置”页面，点击放大镜查找按钮查询到所要进行配置权限的点：

双击tag点，进入Tag属性-资源组配置页面，点击添加资源组，实现tag点与资源组绑定：

目前用户需根据自己所配置的具体权限选择添加至“数据资源组”或“配置资源组”

7.tag点权限验证

使用test1（权限为只读）用户重新登陆iHD客户端：

可以看到该用户绑定的相应点可以查看到点值；

使用test1（权限为只读）用户登陆excel：

修改点值后上传，则报错提示无权限修改点值；

使用test2（权限为只写）用户重新登陆iHD客户端：

进入数据源下的实时记录查询页面，点击刷新按钮，可以看到相应点的实时记录已不可见：

进入数据源下的历史记录查询页面，点击开始查询按钮，会提示无权限：

tag点写值时，未在此资源组下的tag点也无法进行正常写值操作，提示权限不够信息；

写值上传后，可在历史记录中查看点值信息；

使用test（权限为读和写）用户重新登陆iHD客户端：

在实时记录查询界面可以查看相应资源组所绑点的记录值信息

tag点写值时，此资源组下的tag点可以正常写值上传，无报错信息；

并可以在历史记录查询界面查询相应修改点值信息；


典型案例15-Excel函数示例

Navigation: 典型案例 >

典型案例15-Excel函数示例

 Return to chapter overview

本案例主要目标是通过hdExcel实现查询、计算并生成Excel表格所需项：

u 计算平稳率业务表

可以通过hdExcel制作一张业务表格，如下表所示：

本表格通过配置多个数据点、控制上下限的值、最优值、允许波动的值，最终通过hdExcel获取到平均值、波动幅度、超范围的时间和点数等信息；

其中红色框内为配置的原始数据，蓝色框内为通过hdExcel计算后输出的值；

u 隐藏业务表

可以通过hdExcel制作一张隐藏信息的业务表格，如下表所示：用来保存VBA运行过程中用于计算的公式和临时变量。

表格中，红色数据是由VBA生成的公式计算出来的。这些公式被VBA生成后，如果不删除掉，在下一次计算中将会直接用不需要再生成。

§计算平均值（hd_AdvCaclVal）

§计算波动幅度(hd_AdvCalcDat)

§计算超出控制上限的时间和点数(TimeGT , hd_ExpDat)

单元格内(3786.00)显示的是TimeGT返回超出上限的时间， 可以根据hd_ExpDat公式的多值返回统计超出上限点的个数，可以在VBA代码中自定义显示的单元格Range，计算结果为1。

{=hd_ExpDat(B9,B1,B2,"1h",1)}

§计算低于控制下限的时间和点数（TimeLT, hd_ExpDat）

单元格内(188)显示的是TimeLT返回低于下限的时间， 可以根据hd_ExpDat公式的多值返回统计低于下限点的个数，可以在VBA代码中自定义显示的单元格Range，计算结果为0

{ =hd_ExpDat(B11,B1,B2,"1h",1)}

§计算低于最优值的点时间和点数(Time LT, hd_ExpDat)

单元格内(18000.0)显示的是TimeLT返回低于最优值的时间， 可以根据hd_ExpDat公式的多值返回统计低于最优值的点的个数，可以在VBA代码中自定义显示的单元格Range，计算结果为3

{=hd_ExpDat(B15,B1,B2,"1h",1)}

§计算高于最优值波动上限的时间和点数(TimeGT, hd_ExpDat)

单元格内(8747.00)显示的是TimeGT返回高于最优值波动上限的时间， 可以根据hd_ExpDat公式的多值返回统计高于最优值波动上限的点的个数，可以在VBA代码中自定义显示的单元格Range，计算结果为2。

{=hd_ExpDat(B25,B1,B2,"1h",1)}

§计算低于最优值波动下限的时间和点数(TimeLT, hd_ExpDat)

单元格内(8472.00)显示的是TimeLT返回低于最优值波动下限的时间， 可以根据hd_ExpDat公式的多值返回统计低于最优值波动下限的点的个数，可以在VBA代码中自定义显示的单元格Range，计算结果为4

u“cpu/mem信息统计”按钮

按钮“cpu/mem 信息统计”可以显示cpu/mem的波动信息

u“网络速率统计图”按钮


典型案例16-磁盘对数据读写性能影响

Navigation: 典型案例 >

典型案例16-磁盘对数据读写性能影响

 Return to chapter overview

根据现场项目经验及性能测试结果，建议iHD的磁盘配置为固态硬盘，可大幅提升数据的读写性能；

以下为原磁盘与固态硬盘数据读写性能比对详情：

u 实时数据库原磁盘性能

u 升级后的固态磁盘扩容后性能

u iHD数据归档性能比较

1. 实时数据库原磁盘性能：

·随机写性能低下，为2406KB/S 性能测试如下图所示：

·随机读性能低下，为117KB/S 性能测试如下图所示：

2. 升级后的固态磁盘扩容后性能

·随机写性能大幅提升，达到1343MB/S 性能测试如下图所示：

·随机读性能大幅提升，达到39MB/S 性能测试如下图所示

以下为华虹项目现场磁盘迁移替换前后性能的对比表格：

随机读写性能：

3. iHD数据归档性能比较

·iHD数据归档时间，iHD原磁盘，8G缓存文件归档时间需要20min左右；

·替换为固态硬盘后，8G缓存文件需要的归档时间只需要不到1min；


术语

Navigation: »No topics above this level«

术语

 Return to chapter overview

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

A

B

C

D

E

F

G

H

I

J

记录：实时数据库存储的工业数据，一般包含三要素：时间、数据质量、数据值。

记录属性：

1.时间：对于来自设备的记录必须是时序的，即记录按照时间值不断增大的顺序进入系统，否则记录将被当做非法记录丢弃。

2.数据质量：该属性为可选属性，一般OPC设备关心此属性，可以用来标记一条记录是否可用，该属性类型为int16。

3.数据值：根据数据源的类型不同对应不同的取值范围，其中int8、int16、int32、float32、float64均为常见的整数或浮点数，digital类型与int8相同，string与blob类型值的最大长度为1000，string类型的结束符也包括在内。

K

L

连接监测周期：检查与DB服务器端连接的周期。当该周期到来时，OPC采集端向DB服务器请求配置时间戳，如果成功，表明连接正常，如果失败，则测试连接，当连接中断时，进行重连。

历史存储记录（时间区间模式）：一个Tag在起始时间和终止时间区间之内的历史存储记录

历史存储记录（记录条数模式）：一个Tag从某一时刻起指定条数的历史存储记录

历史插值记录（等间隔模式）：一个Tag点在一段区间之内指定时间间隔上的历史插值记录

历史插值记录（时间点模式）：一个Tag在指定的一个或多个时间点上的历史插值记录

M

N

O

OPC(OLE for Process Control)：是以Microsoft公司的OLE/COM技术为基础，采用客户/服务器模型制定的一种工业控制领域的开放式标准，主要解决不同自动化软件及硬件平台之间数据交互的问题。

OPC Quality：OPC质量是OPC服务器告诉OPC客户端，关于它们提供数据的价值的一种方式。OPC质量通过编码方式表现。

两种最常见的OPC质量编码为：

·“192（十进制）”表示“质量良好” ；

·“0（十进制）”表示“质量不佳”。

其他常见编码用来表示质量差的原因。

十六进制值 | 十进制值 | OPC规范定义
C0 | 192 | 好
D8 | 216 | 好-本地覆盖，值强制
0 | 0 | 坏
4 | 4 | 错误-服务器中的配置错误
8 | 8 | 坏-没有连接
C | 12 | 坏-设备故障
10 | 16 | 坏-传感器故障
14 | 20 | 糟糕-最后知道价值通过
18 | 24 | 坏-Comm失败
1C | 28 | 坏-项目设置InActive
40 | 64 | 不确定
44 | 68 | 不确定-最后可用值-某种超时
50 | 80 | 不确定-传感器不准确-超出限制
54 | 84 | 不确定-超出工程单位
58 | 88 | 不确定-来自多个来源的价值-少于所需的良好价值

有关OPC质量更多信息，请参阅OPC规范。（注意：OPC通讯数据产生源头服务器所打的质量标签，iHD实时数据库据实抄报，不做更改，除“192”以外的质量标签含义还需查找数据源头厂商的定义说明。）

P

Q

前向插值：

假设我们已知坐标(x0,y0)与(x1,y1),要得到[x0,x1]区间内某一位置x在直线上的y值。

则取x0的y值y0作为x的y值.

R

S

数据源：是提供某种所需要数据的器件或原始媒体。系统中每个数据源（简称点或tag点）包含若干属性，如名称、描述、数据类型、点源类别等，这些属性共同描述了一个数据源的基本信息、权限相关信息、采集器相关信息、压缩相关信息以及修改与创建等信息。

数据采集：从传感器和其他设备等模拟和数字被测单元中自动采集非电量或者电量信号，送到上位机中进行分析、处理。被采集的数据是已被转换为电讯号的各种物理量，如温度、水位、风速、压力等，可以是模拟量，也可以是数字量。

数据网络地址： 数据库服务器端的ip地址

数据网络端口：数据库服务器端的端口号

扫描组；Tag点所属的扫描组。扫描组包含OPC服务器编号、扫描周期、扫描相位、扫描类型等信息。

扫描状态：表示该Tag点是否扫描

设备点名：与OPC服务器中的项编号相对应，指定该Tag点对应OPC服务器中的哪个项

数据库转储：将iHyperDB中存储的记录数据转储到关系数据库中（Ralation Database，RDB）

实时记录：一个或多个Tag点实时的记录

T

Tag点： 对于实时数据库系统而言，数据源（即tag点）是其最基本的存储单元，每个数据源对应实际设备中的一项观测点，观测点在不同时刻的数据值则形成若干条记录。

Tag类型：Tag对应的数据类型，需要与OPC服务器端项的数据类型一致，当类型不一致时，可以发生读取错误，或数据精度损失。

TagID:Tag的内部编号

同步周期：与DB服务器同步配置的周期。当该周期到来时，OPC采集端向DB服务器请求配置时间戳，当发现本地时间戳与请求的时间戳不同时，更新OPC采集端的配置，并将本地时间戳设置为服务器的时间戳。

Tag下载：从服务器下载普通点或者报警点到Excel表格中

Tag上传：用户把点的各种属性在Excel中配好后，上传到实时数据库服务器

Tag查询：在Excel中按照Tag点的各种属性条件从服务器中查询并下载选定的Tag

U

V

W

X

线性插值：

线性插值是数学、计算机图形学等领域广泛使用的一种简单插值方法

假设我们已知坐标(x0,y0)与(x1,y1),要得到[x0,x1]区间内某一位置x在直线上的y值。

根据图中所示，假设AB上有一点（x,y），可作出两个相似三角形，我们得到（y-y0）(x1-x0)=(y1-y0)(x-x0)

假设方程两边的值为α，那么这个值就是插值系数—从x0到x的距离与从x0到x1距离的比值。由于x值已知，所以可以从公式得到α的值

α=(x-x0)/(x1-x0)

同样，α=(y-y0)/(y1-y0)

这样，在代数上就可以表示成为：y = (1- α)y0 + αy1

或者，y = y0 + α(y1 - y0)

这样通过α就可以直接得到 y

Y

异步超时：OPC采集器配置用异步读取方式，当异步读取请求已经发送后，经过该项设置的时间后，检测数据是否已经获取成功，如果获取失败记录日志。值为零时表示不启用。（目前该项功能暂不支持）

Z

©2015. All Rights Reserved.


常见问题

Navigation: »No topics above this level«

常见问题

 Return to chapter overview

我们收集了在使用 iHyperDB中常见的一些问题，若您在使用中遇到了自己不能解决的问题，可以先查看这儿，看看有没有您需要的答案。

·安装常见问题

·客户端常见问题

·转储常见问题

·计算点常见问题

·许可证常见问题

·组态常见问题

·采集器常见问题

·国际化常见问题

·冗余常见问题

·日志常见问题

·IP地址发生变化时如何修改

·超时问题

·其他问题


安装常见问题

Navigation: 常见问题分析 >

安装常见问题

 Return to chapter overview

Q1: windows 64位版本程序安装提示setup.ini格式错误。

请先安装微软vc9运行库VC_x86Runtime。

Q2: 安装运行卡住，等很久都没有继续下去。

是否有ihd服务或进程在运行，是则需先退出；

是否有iCentroView的服务或进程在运行，是则需先退出；

是否有其他二次开发调用ihd接口的程序在运行，是则需先退出。

Q3：3.5.0之前的版本升级到3.6.0版本，之后运行3.6.0的卸载功能，3.5.0之前的版本所安装的postgresql将不会自动卸载。

需手工运行postgresql卸载程序uninstall。

Q4：启动服务失败，Windows报错“1068”。

该错误多半是因为无法启动从属服务导致。需要手动删除服务的依赖关系，操作方法如下：

当出现上图情况，通过 win+r 键打开计算机的运行窗口，输入cmd ,使用管理员权限运行windows的控制台，如下图：

windows的控制台中输入如下命令：sc config hd3ConfigCenter depend= /

显示修改成功后，重启ihd的服务。

Q5：已安装系统，当前磁盘满，希望将数据文件移动至其他磁盘。

1.停止iHD服务；

2.将[data]目录整体拷贝至其他磁盘；

3.修改配置文件“\config\servercfg.xml”中[data]目录的路径；

4.重启iHD服务；

Q6：系统安装时，报错“不合法的内存缓冲区大小”，无法验证所填内存缓冲区大小参数，导致无法进入安装的下一步。

正常安装时，要求内存缓冲区大小应小于计算机剩余内存的1/3，硬盘数据文件大小为内存缓冲区大小的整数倍（至少2倍以上）。

个别版本的windows操作系统，安装检测时计算机内存缓冲区系统变量读取故障，将导致该项参数合法验证无法通过。遇到该情况，请按以下步骤解决：

1.安装时参数“内存缓冲区大小”先填写“512”，进入下一步安装；

2.安装完成后手动修改服务端配置文件（安装路径/config/ServerCfg.xml）；

ServerCfg.xml常用配置项说明：

iHyperDBSrv->Kernel->SeqFile->Size, 序列缓存文件大小, 单位M，一般50~512。

iHyperDBSrv->Kernel->ArchiveFile->Size, 单个归档文件大小, 单位M，一般1024~4096。

iHyperDBSrv->Kernel->ArchiveFile->Num, 归档文件的最大个数, 范围3~500, 调整需考虑归档文件存放的硬盘分区大小。

iHyperDBSrv->NetMgr->Network->Port, 网络服务监听端口,默认5678, 注意需防火墙允许该端口。

参数修改需注意参考windows版本的服务端安装手册提示的约束条件。详见章节：数据库服务端的安装步骤

3.配置文件保存修改后，重启iHD数据库，令新配置文件生效；

重启iHD，请参考：系统启动和关闭


客户端常见问题

Navigation: 常见问题分析 >

客户端常见问题

 Return to chapter overview

Q1: 安装好iHyperDB客户端后，打开Excel，Excel插件无法使用？

√. 第一种情况可能是Office的“Visual Baisc for Application(VBA)”功能并未安装。请关闭Excel，重新运行Office安装程序安装VBA；

√. 第二种情况可能是由于Excel的宏被禁用。

§如果是Excel 2007，点击左上角Office按钮，继续点击Excel选项，选择信任中心，点击信任中心设置按钮，继续选择宏设置，在宏设置中选择‘启用所有宏’选项；

§如果是Excel 2003，选择工具->宏->安全性，在‘安全级’选项卡中将安全级调至中或低，并在‘可靠发行商’选项卡中，勾选‘信任所有安装的加载项和模板’;

§如果是Excel 2010，选择文件->选项->信任中心->信任中心设置，在‘信任中心’配置页面上，点击'受信任位置'->'添加新位置'，将iHyperDB.xla 的路径添加；32位的安装路径是安装目录executable下，64位是安装目录executable_x64（如图示）。

√. 第三种情况可能是宏iHyperDB和hdExcel XLL Add-In没有加载成功。

如果是Excel 2007，点击左上角Office按钮，继续点击Excel选项，选择加载项，继续选择加载宏，在弹出的加载宏对话框中将宏iHyperDB和hdExcel XLL Add-In都勾选；

如果是Excel 2003，选择工具->加载宏->安全性，在弹出的加载宏对话框中将宏iHyperDB和hdExcel XLL Add-In都勾选；

如果没有显示,先浏览添加excel插件2个文件, 对应executable目录下 iHyperDB.xla 和 ExcelXLL.xll.

Q2: 添加采集器失败，错误码110350。

可能原因：在安装目录下config/ServerCfg.xml中有一项:<SeqFile Size="20" FlushPeriod="600"/>,其中size项在32位的程序最大只能是512。当配置超过512时，超过操作系统的最大限额，会导致内核kernel无法启动。

解决方法：将size改为512以内。

Q3: 增加较多点数时报错：[WARN]110025 [Loc]start_data_handle_thread:516 [Note]Exception No.1 occur [type]0xC0000005 [module]D:\iHyperDB\executable\hdKernel.exe [address]0x7373EE9C [desc]try read address 0x

原因：kernel.db配置的tag点数量超过许可证限制（如手工拷贝老配置），导致blockcache文件大小不正常。

解决方法：申请有效许可证。

Q4: 安装iHyperDB客户端时，安装程序长时间卡在：INFO[installed_pkg_info.pyo:162]: Execute postinstall script in package: RelationalDB.RDBExporter successfully 的提示信息上

原因：安装目录或者系统临时文件夹被其他程序占用，可能原来安装过iHyperDB又卸载未完成。

解决方法：先卸载程序，重启后再安装。

Q5: 打开excel时，报运行时错误'53',报错窗体如下：

A：首先确认系统安装的OFFICE版本是否为32位。

如果是32位的，那么出现报警的原因为环境变量中未设置该目录，可能为安装时用户权限不够，未能自动增加目录。

解决办法：在环境变量中手工增加文件所在目录。

打开“资源管理器”(EXPLORER.EXE)。鼠标右键单击“计算机”，如下图所示：

选择“属性”，出现系统管理窗体，选择“高级系统设置”：

出现系统属性窗体，鼠标单击“环境变量”按钮：

出现环境变量窗体，在下方列表中选中“PATH”项，单击“编辑”按钮：

出现编辑系统变量窗体，如下图所示：

在变量值中加入“hdSDKSpreadsheet.dll”所在的目录字符串，和原有字符串内的目录以分号“;”（半角）分隔。然后单击“确定”按钮，后续窗体全部点击“确定”按钮。“hdSDKSpreadsheet.dll”文件一般可在安装后的应用软件目录下的“executable”找到，如“D:\iHyperDB\executable”目录。

Q6: 浏览OPCServer时出错，报：112269 创建COM实例失败.

原因： 客户端机器曾经安装和卸载过iHyperDB的OPCServer，在卸载时删除了系统中的opc库会导致浏览OPCServer时出错，注意弹出是否删除系统opc库的时候选择No.

Q7：打开excel时，报运行时错误'53',报错窗体如下：

原因：可能是64位Excel安装了32位客户端插件，或者32位Excel安装了64位客户端插件。

Q8. 在【创建SPC报警点】界面，SPC报警点名称输入为字符上限为127个字符，点击【下一步】提示失败

原因：如果SPC报警点名称过长（如127个字符）,并且使用生成Tag点,会导致扩展点名超长而加点不成功。请合理设置tag点名称。

Q9. iHD客户端数计算方法

iHD授权中客户端数这一关键数据项如何计算？

关于可并发连接的ihd客户端数总量由以下三种需求构成：

?ihd windows客户端访问；

?iHD采集器;

?SDK调用；

?icv转储ihd；

这四种并发连接都占用客户端数。其他如：iplat-DM连接ihd，即iPlat系列产品访问iHD数据库不占iHD客户端数，连接iPlatBA BB BC服务器的客户端与iHD产品客户端数无关，iHD产品访问各类opc server等通讯连接，与客户端数无关。

1>.ihd windows客户端的访问；如下图，iHD的系统管理界面可以运行在多个iHD客户端机器上，每开一个，占一个客户端数；

2>.iHD采集器，一个IP算一个客户端连接数；iHD采集器可以放在iHD服务器上，也可以放在异地，每个IP连接算一个并发连接。例如：每个iCG连接iHD都占一个客户端数；

3>.SDK调用，通常用来与第三方数据库通讯，每open-DB一个，未曾close-DB时，占用一个客户端连接数；

4>.icv转储ihd，每个iCV服务器连接至iHD服务器，被连接的iHD服务器，占用一个客户端连接数；

所以通常，SDK连接是各项目中客户端数主要差异点，对于接口多的项目，客户端数需要的多一些。


转储常见问题

Navigation: 常见问题分析 >

转储常见问题

 Return to chapter overview

Q1. 转储服务运行错误ImportError：No Module name sited

原因：无法找到可用的python环境. 1)请检查PythonHome环境变量，是否安装过iCentroView，卸载后重新安装Python环境。2)参考功能明细的说明配置。

Q2. mysql没有成功转储string类型的tag点,出现的错误界面如图：

原因：存储的string数据不是有效的utf-8字符串，应该使用blob数据类型，而string类型存储正常中英文字符串是可以转储的。

Q3. 配置转储间隔1小时,但是超过3个小时才看到关系库有记录?

原因：配置了关系库oracle和SQLserver,其中SQLserver连接不正常,日志有错误,删除该数据库转储后oracle转储就正常了。

Q4. 一张宽表中，部分点空值.

原因：配置了不同采集周期的点或者不同采集器的点，数据刷新不同步导致慢的点没有值插出来是空的。

Q5：【RDB】-在iHD中新建postgresql数据表，添加一个不合法的字段名，保存，报错。然后在postgresql中仍然能查到这张数据表

原因：添加字段时就提交指令给postgresql，如果错误需要手工在postgresql中删除不需要内容.

Q6：【RDB】-在postgresql中新建数据表，如果列名写成大写，会导致SQL语句执行失败，导致转储失败。

解决：手动新建数据表的时候，需将列名写成小写。


计算点常见问题

Navigation: 常见问题分析 >

计算点常见问题

 Return to chapter overview

Q1. 通过excel上传计算点的时候，如果某一行数据上传失败且只有该行的第一列被红色标记出来（即不能定位到具体哪一列出错），那么请检查计算点的计算表达式的配置是否正确 。

Q2. 在许可证到期后，通过框架查询计算点可能报错提示116204（Google Protobuf Parse失败）。

Q3.正负号要用（）标明运算顺序，例如：'int8'*（-1），如没有（），则认为是'int8'*0-1.

Q4.有些表达式不会计算？答：配置不正确的表达式有些没有提示，比如表达式中含有同名计算点、表达式中含有报警点等等。

Q5.表达式括号内无算式也能配置？答：表达式输入界面没有严格限制，配置不正确的表达式有些没有提示，如果计算结果不符合预期，请先检查表达式配置是否正确。

Q6.历史计算结束时间不生效？答：计算点的历史计算起始和结束时间，过滤的是创建计算点的时候关联源点已经存储在服务器上的历史数据时间。配完之后关联源点才存的数据会当作新的实时数据，所以都会参与计算。


许可证常见问题

Navigation: 常见问题分析 >

许可证常见问题

 Return to chapter overview

Q1.使用硬件许可证时，不能使用远程桌面启动服务端程序。

原因：硬件许可证限制远程用户。

Q2.许可证信息：SPC支持显示：不支持，但还是会触发SPC报警。

原因：许可证支持SPC的意思是web客户端可以展示spc图表，并不是限制报警服务的spc报警。


组态常见问题

Navigation: 常见问题分析 >

组态常见问题

 Return to chapter overview

Q1.趋势图不是实时画出来？

原因：请检查对应点的配置，如果属性配置压缩，那么最新数据可能被压缩掉，所以趋势图不能显示实时值。如果需要趋势图显示实时值，那么需要配置不压缩。

Q2.一台机器上，如果已安装iHyperDB或iCV的组态，不建议再安装iWebview。

原因：组态里趋势图的CS和BS模式，不能装同一台机器上，否则用IE访问iWebView组态（BS模式），可能影响CS模式的组态客户端。

Q3.客户端节点IP正确是正确的，但是组态节点分发报错117507怎么解决？

原因：客户端服务ihdServiceControl未安装或者未启动。

解决方法：客户端运行services.msc命令，检查windows服务中ihdServiceControl是否启动。

Q4.客户端组态选择ihd点提示服务器连接失败？

原因：1）服务端连接错误，可查看kingapi日志错误码；2）服务端没有组态模块许可。


采集器常见问题

Navigation: 常见问题分析 >

采集器常见问题

 Return to chapter overview

Q1:开启hdOPC_Int后报错：[ERROR]112213 [Loc]COPCCollectPlat::AddTag:987 [Note]can not find related OPC server for tag(3033), they may all be full.

原因：目前每个采集器中每个扫描组下面有3000个Tag点的限制，扫描组下配置的Tag点数超过3000点会导致出错；

解决方法：在采集器配置中将每个扫描组下的Tag点数限制在3000点以内（不含3000点）。

Q2: OpcInt配置正确，但实时数据库采集不到数据

原因1：实时数据库的Tag配置中压缩误差和过滤误差都默认为2，这时如果采集的数据变化很小，或者本身值就很小，数据就会被过滤掉。

解决方法：注意tag属性中这两个参数的取值。

原因2：hdOpcInt.exe采集器所在的机器的IP必须是实时数据库信任的IP，否则在上传数据时会报存储数据失败。

解决方法：在权限中“信任”的配置中为hdOpcInt.exe采集器所在的机器的IP配置信任的IP

Q3:开启buffer后，采集器进程不能启动

原因：可能是由于在开启buffer之前没有启动buffer进程

解决方法：采集器本地配置文件中，buffer的默认选项是0，即不启用buffer功能，如果要启用buffer，则要在采集器程序运行之前先运行客户端hdBuffer.exe程序。

Q4:如果出现同一个设备下采集的点，有些可以采集到，有些采集不到。

原因：设备响应比较慢或者本身网络环境比较差。

解决方法：请尝试将设备的重连周期调大，此外，扫描组中的轮询周期也对应调大。

Q5:如果报的错误码是111162。

A:可能是由于服务端、客户端、采集器系统有时间差导致。

一种解决方法：用户可将三者时间修改一致，并设置采集器用服务端的时间

第二种解决方法：打开安装目录下config\ServerCfg.xml文件，找到<TimeStamp Enable="1" MaxTimeDevSec="1800">。其中1800代表服务端和客户端两者时间差在1800秒内，服务端认为正确并存储，否则即抱错。如果用户想延长此时间，可自行修改。

Q6:修改服务端端口后,重启采集器，发现数据仍无法上传。

解决方法:修改服务端端口后，采集器与buffer需手工重启，才能使用。

Q7:当启动OPCInt服务时，出现如图中的情况。

解决方法:请检查安装过服务之后是否重启计算机。

Q8:服务端时间曾跳变并手工改正后，重启采集器时间戳不正确。

解决方法：服务器时间跳到未来时间会导致新数据存储是乱序数据被丢弃，时间戳根据过滤超时更新，所以看起来时间戳在更新但是仍是未来时间。

因为，实时数据库无法存储未来时间，所以服务端时间跳变成未来时间与现实时间之间的数据无法存储，只有等现实时间到了未来时间，才可正常存储。

切记，不可随意变更服务端时间，服务端时间与客户端时间尽量保持一致!

Q9: opc采集器配置工具浏览OPCServer时报错：112257 服务名不能为空。

解决方法: 2.3及之前版本升级到2.4后需要重新配置OPC采集的设备，才能够正常采集新的点。在“采集器配置工具”页面上，先点击设备项里的编辑按钮，在点击“浏览”按钮，就可以选择需要采集的设备名称，后面的信息一栏会自动更新原先配置的设备地址。（如果不采集新点或者不浏览OPCServer则无需此步骤）

Q10：在【采集器配置工具】中，配置设备为远程Baosight.CV5OPCServer后，浏览该OPC Server的点，弹出提示：连接OPC失败。错误码：112259 注册键值失败。使用第三方软件，可以读取到点，并读取到值。

解决方法：第三方工具使用的时候一般使用ip. ihd默认使用机器名浏览远程机器，某些情况下不行。将机器名配成实际的IP就可以了。

Q11：有采集源发生超时时，有没有系统位号进行提醒？这个实时数据库采集器有状态点可以进行处理

值为65529是连接上的；65528是连接超时。

状态点组成为“节点名.hdsys_采集器名_设备名_status.A_Quality"

Q12：opc采集组态王，进程方式运行可以，服务方式不行。 服务方式运行时日志有-2146959355错误，

[ERROR]-2146959355 [Loc]COPCServer::ConnectToOPCServer:457 [Note]KingView.View.1 CoInterfaces failed

原因是组态王以界面方式启动opcserver，

带界面的 OPCServer 软件已经通过当前登录账户运行起来，而 OPCClient 以 Windows 服务方式运行在 SYSTEM 账户的空间，那么

OPCClient 就未能检测到 OPCServer 已经运行，于是 OPCClient 就让 COM 协调器在本空间中运行 OPCServer，但 OPCServer

运行时，又检测到自己在当前登录账户的空间已经启动了，因此就拒绝再次运行。所以就发生了 Windows 服务方式的

OPCClient 和带界面的 OPCServer 无法通讯的问题。

解决方式：opc采集器通过进程方式运行，如果需要开机启动，可以添加到windows的开机启动项解决。


国际化常见问题

Navigation: 常见问题分析 >

国际化常见问题

 Return to chapter overview

Q1：用户切换成中文后，中文显示为乱码.

解决方法：当用户使用IHD的语言切换功能时,首先要切换操作系统的显示语言,以英文win7操作系统为例 在control panel ->change display language->选择tab页 administrative ->change system local 在里面切换语言为chinese(prc)就可以了，如果切换回英文，用户需要将系统的该属性切换回英文english（united states）

Q2：组态配置分发的消息错误显示为乱码。

解决方法：英文系统下错误内容可能显示不了,可以根据错误码查询具体错误内容。


冗余常见问题

Navigation: 常见问题分析 >

冗余常见问题

 Return to chapter overview

Q1：当主备机配置因为一些原因不同步时，系统无法自动恢复，需要手动恢复。

A1：一般是配置中心备机操作pgsql成功，但是和主备通讯失败时会导致主机没有成功操作pgsql，这时主备配置不一致。需要手工把备机pgsql数据库备份一个backup文件，然后在主机恢复一个数据库。备份恢复操作参考 "功能明细-数据安全" 下面的"配置备份"和"配置和数据恢复"说明。


日志常见问题

Navigation: 常见问题分析 >

日志常见问题

 Return to chapter overview

Q1：修改日志配置文件

iHyperDB每个服务进程，后台都有日志文件对应进行记录。日志文件位于“ 系统实际安装位置:\iHyperDB\Log ”目录下。日志文件以“进程名_流水号.txt”命名。可以通过查阅日志，查看系统日志信息，方便定位故障。

日志配置文件位于“ 系统实际安装位置:\iHyperDB\config ”目录下。

viHyperDB服务端日志配置文件：Log.xml

viHyperDB客户端日志配置文件：LogClient.xml

.xml的日志配置文件，鼠标右键“编辑”可打开，如下图所示：

配置文件参数说明：

name

即可看到如下两个图中的代码。其中name=**,代表修改的对象。

其中Log.xml文件中常修改“Kernel=内核；NerMgr=网络；AlarmSvc=报警；StatsSche=统计点；ExpCalc=计算点；”

LogClient.xml文件中常修改“Buffer=缓存；OPC=OPC采集器；”

priority=**,代表对象的日志级别，根据需要会修改成(注意大小写)”error,info,debug,trace"等。编辑后保存并关闭文件。

注意：如果级别是error，日志信息会比较少；如果级别是trace，则对象的行为痕迹都会记录下来，可能数量较多；


IP地址变化时如何修改

Navigation: 常见问题分析 >

IP地址变化时如何修改

 Return to chapter overview

一、单机版

单机版指的是服务器只有一台机器，配置中心和数据节点都安装在该机器。如果该机器IP地址发生变化（例如从168.2.237.54变为192.168.198.1）时按照下面的步骤修改：

1、启动服务端的所有服务。

2、打开系统管理工具，连接到服务器的新地址192.168.198.1。

3、点击系统管理工具 - 数据节点配置-修改。将老的IP地址修改为新的IP地址。

4、重启所有的ihd的程序，包括服务端和客户端，配置生效。

二、非单机版IP地址发生改变时如何修改

服务器操作系统是windows按如下步骤修改：

1、在安装数据节点的服务器上打开“数据节点服务管理工具”

2、 在数据节点服务管理工具的系统参数界面按照实际的环境修改配置中心主机IP、配置中心备机IP、本机IP，保存，保存完成后重启服务。

3、在其它数据节点所在的服务器上重复第1步和第2步，修改实际IP地址并重启服务。

4、按照单机版的前3步依次操作在系统管理工具界面上修改数据节点地址。

5、重启所有的ihd的程序，包括服务端和客户端，配置生效。

三、服务器为非window系统时按照如下步骤操作：

1、在安装配置中心的机器上打开安装目录下的config/ ConfigCenter.xml文件，按照实际情况进行修改。

HostAddr为主机地址。

BackUpAddr为备机地址，没有备机就为空。

ArbiterAddr为网络检测IP地址，如果没有配置主备或者不启用该功能则为空。

2、在安装数据节点的机器上打开安装目录下的config/ SeverCfg.xml文件，按照实际情况进行修改。

bakeip 为配置中心备机地址，按实际情况修改，如果没有备机则为空。

bakeport 为配置中心备机端口，不用修改。

identity 修改为-1。

localhostIP 为本机IP，按实际情况修改。

mainip 为配置中心主机IP，按实际情况修改。

mainport 为配置中心主机端口，不用修改。

3、启动所有的服务。

4、按照单机版的前3步依次操作，在系统管理工具界面上修改数据节点地址。

5、重启所有的ihd的程序，包括服务端和客户端，配置生效。


超时问题

Navigation: 常见问题分析 >

超时问题

 Return to chapter overview

ihd的数据存储服务会定期将内存缓存中的数据保存到硬盘中，在这个过程中如果有乱序数据插入或者历史数据查询可能导致数据存储服务响应客户端性能下降，

严重时会导致客户端响应超时，以下措施会改善这种情况下客户端响应的性能：

打开数据节点上的iHyperDB/config目录的ServerCfg.xml,修改iHyperDBSrv-Kernel-ArchiveFile节点下的元素ArchiveWindowSize的值，将这个值改小可以提升

内存缓存写硬盘时响应客户端的速度，该值最小为1，默认值为2000，最大值建议不要超过2000.


其他问题

Navigation: 常见问题分析 >

其他问题

 Return to chapter overview

Q1：当装的iHyperDB是单机版时，配置好数据节点，由于IP的变化，导致系统运行不正常.

解决方法

1.在系统管理工具里的节点配置里，修改成当前的IP；

2.数据节点安装目录的config文件夹中ServerCfg.xml配置文件也需要修改为新的配置中心IP，具体字段参考下列

<CCServer bakeip="" bakeport="0" identity="0" localhostIP="168.2.9.114" mainip="168.2.9.114" mainport="5673"

v3.3.0以上版本参见->IP地址发生变化时如何修改。


实时数据库Excel / WPS插件常见问题处理

Navigation: 常见问题分析 >

实时数据库Excel / WPS插件常见问题处理

 Return to chapter overview

·安装卸载问题

·Office问题

·WPS问题

·环境变量问题

安装卸载问题：

Q1：提示不能打开要写入的文件，如下图所示：

A1: 安装前未退出excel或wps，中止后关闭excel或wps，重新安装即可

Q2：提示操作系统环境变量PATH过长，如下图所示：

A2: 安装版本过旧，请联系相关管理人员获取最新版

Q3：卸载插件

A3：如因冲突更新等原因，希望卸载插件，请至安装目录，点击Uninstall.exe进行卸载；

Q4：如因冲突等原因需临时禁用插件

A4：依照如下图所示位置去除勾选即可

如没有开发工具菜单，需手动启用，方法如下：

菜单栏空白处右键，选择自定义功能区，勾选开发工具并确定。

WPS禁用插件方式:

Office问题：

Q1：安装完后无功能菜单

A1：首次启动需点击安装

如仍未显示，可能缺少.net4.0环境，安装后可显示

下载地址：https://www.microsoft.com/en-us/download/details.aspx?id=17718

WPS问题：

Q1：WPS菜单界面显示不全，有时缺少实时数据库标签，有时缺少功能菜单

A1：wps加载失败或异常退出一次后，会将插件自动禁用，需要手动去开发工具中启用，启用步骤如下：

1、缺少实时数据库标签，需手动勾选启用如图所示两个加载项，如未出现这两个选项，需浏览安装目录，并选中iHyperDB.xla和iHyperDB_wps.xla两个文件进行加载

2、缺少功能菜单时，需手动勾选启用如图所示COM加载项

3、重启后可生效

启动后弹出如下界面时，如需继续使用，请点击否。

Q2：出现不合法的时间戳提示

选中时间格式的单元格时，运算后出现不合法的时间戳

A1：WPS会自动将符合条件的时间字符串转换为double变量，造成函数内部识别错误，将单元格格式设置为字符串可以解决

Q3：点击tag点下载等选项无法使用

A3：如果安装了wps后，可以连接上服务器，但是点击tag点下载等选项无法使用功能，可重新安装wps后重启机器再使用

环境变量问题：

Q1：无法加载dll、RegisterXLL failed、文件未找到等错误

A1：均为环境变量设置错误问题，安装新版插件可以解决


常见错误码

日志系统对系统中的每种错误都定义了错误码，在日志查看或界面错误提示框中可以看到系统的错误码，其对应的解释可以通过Excel中的错误码查询界面来获取，请参考错误码查询。

《常见错误码》列出了用户在使用过程中较常见到的错误码。详细内容如下：

119632 网络连接失败

错误原因：通常是安装时，数据节点服务器IP地址使用了缺省的IP，没有填写实际IP。

请在“系统管理平台”中，点击菜单“工具”-“数据节点配置”，进行修改。

119613 API从服务端接收到的数据包长度不正确。

错误原因：一般是由于客户端和服务端版本不一致导致，检查hdAPI和服务器hdKernel版本是否匹配。

111157 存储数据失败。

常见错误：一般是采集器程序日志里报出

错误原因：① Tag点采集数据的时间戳比Tag点的实时记录的时间戳早；

② 未配置信任权限，采集器所在的IP必须是实时数据库信任的IP.

110350 网络接收超时

错误原因： 一般是由于客户端和服务端网络不通导致，或者是服务器繁忙来不及相应客户端需求。

112013 Excel驱动获取当前工作簿失败

错误原因：使用Excel插件时尽量打开一个工作簿，否则Excel插件在向sheet中写入数据时会报错。

115105 插入信任失败，IP地址或有交集

错误原因：信任设置中同一IP映射到不同的用户。iHyperDB不允许IP段相互之间有交集。

115125 权限不够

解决问题：改用权限更高级的用户登录，admin账户是超级用户，拥有所有权限

116102 进程通信创建共享内存失败

错误原因：某些程序运行时需要创建共享内存，如果创建失败，一般是由于配置的共享内存太大，而系统内存资料员不足导致。

116106 进程通信没有空闲内存空间

错误原因： 程序创建的共享内存已经使用完毕。

此错误码若出现在服务器端，是由于服务任务繁忙导致，或者服务已经出现退出等严重情况，出现该错误码请及时联系支持人员。

如果出现在客户端是由于使用了客户端缓存功能，此时缓存已经用完，影响不会很大。

116201 消息的长度不正确

错误原因：

1)数据节点服务端许可证无效或过期。

2)客户端连接端口错误,v3连接端口应为5673。

116204 Google Protobuf Parse失败

错误原因：通过框架查询点的报错提示，原因在于许可证到期。


产品支持

Navigation: »No topics above this level«

产品支持

 Return to chapter overview

若您遇到问题后，在我们的帮助文档中没有找到理想的答案，请联系技术支持工程师，我们会为您提供技术支持与服务：

地址：上海市浦东新区郭守敬路515号

邮编：201203

技术支持QQ群号：236310467

支持电话：021-20378707

支持中心：https://product.baosight.com/ihddownload/


配置修改--单机版配置修改为单机双网冗余

Navigation: »No topics above this level«

配置修改--单机版配置修改为单机双网冗余

 Return to chapter overview

单机版指系统环境中只有一台实时数据库服务器，配置中心和数据节点都安装在该机器。如果想从单机ihd168.2.6.210，添加一台备机，备机服务端ip为168.2.8.90时，按照下面的步骤修改：

1、实时数据库服务运行之后点击系统管理工具>打开服务器连接管理器，点击修改勾选备机IP,填写上备机所在的IP，备机端口号默认"5673"，点击保存。

2、服务器连接管理配置好之后，点击数据节点配置，选择修改，在备机IP填写实时数据库备机所在的IP地址，端口默认填写"5678"，之后点击确认保存。

3、打开数据节点服务管理工具>打开系统参数>点击其他 如下图所示：

4、在配置中心备机IP一栏添加你所需要添加的备机的IP地址，点击保存。

5、保存之后需要关系客户端配置工具，以及关闭实时数据库的所有服务，退出服务管理工具并重启。

6、在ihd的主机上完成上述操作之后。如果备机还未安装ihd，可以参考用户手册来安装备机，安装完成之后，可以启动主机的服务管理工具进行运行。

7、在ihd的主机上完成上述操作之后。如果备机已经安装ihd，并且是按照主机方式安装的，请参考上述步骤1-5，切记主IP和备机IP要区分开，不能弄混淆。配置完成后可启动主备的服务管理工具。

8、可以看到主机服务管理工具，在是否启用冗余显示为“是”，冗余状态显示为“活动”。


配置修改--单机版本机IP地址修改

Navigation: »No topics above this level«

配置修改--单机版本机IP地址修改

 Return to chapter overview

单机版指系统环境中只有一台实时数据库服务器，配置中心和数据节点都安装在该机器。如果该机器IP地址发生变化（例如从168.2.8.90变为168.2.6.210）时按照下面的步骤修改：

1、启动服务端的所有服务。

2、 打开系统管理工具，点击连接之后，点击修改，ip地址填写服务器的新地址168.2.6.210，点击保存。

3、点击系统管理工具 - 数据节点配置-修改。选中该行，点击修改，将老的IP地址修改为新的IP地址，确认保存。

4、重启所有的ihd的程序，包括服务端和客户端，配置生效。重启之后，ihd运行正常，客户端用新的ip可以正常连接，就说明ip修改成功。


a

Navigation: »No topics above this level«

a

 Return to chapter overview

函数

参数

返回值

说明

举例

demo

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statsTag;

SPCAlarmTagProp spcAlarmTagSave;

SPCAlarmTagProp spcAlarmTagQuery;

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

int32 nErrCode = 0;

char (*szTagNames)[HD_LEN_TAG_NAME] = NULL;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag as stats tag source tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add statistics tag

strcpy(statsTag.szTagName, "szStatsTag");

strcpy(statsTag.szSourceTagName, normalTag.szTagName);

statsTag.nScanPeriod = 60;

statsTag.nStatsType = HD_STATS_TYPE_MAX;

statsTag.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statsTag.nSampleInerval = 3600;

statsTag.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statsTag, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_NAME

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statsTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statsTag.szTagName);

//add one normal tag as spc tag ucl tag

strcpy(normalTag.szTagName, "szUCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add one normal tag as spc tag cl tag

strcpy(normalTag.szTagName, "szCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add one normal tag as spc tag lcl tag

strcpy(normalTag.szTagName, "szLCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add spc alarm tag

memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

strcpy(spcAlarmTagSave.szTagName, "szSPCAlarmTag_1");

strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

spcAlarmTagSave.dUCLDefaultValue = 200;

spcAlarmTagSave.dCLDefaultVaule = 100;

spcAlarmTagSave.dLCLDefaultValue = 50;

nRet = spc_add_tag(hServer, &spcAlarmTagSave,

 TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

 | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

if (nRet != RD_SUCCESS)

{

 printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

strcpy(spcAlarmTagSave.szTagName, "szSPCAlarmTag_2");

strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

spcAlarmTagSave.dUCLDefaultValue = 200;

spcAlarmTagSave.dCLDefaultVaule = 100;

spcAlarmTagSave.dLCLDefaultValue = 50;

nRet = spc_add_tag(hServer, &spcAlarmTagSave,

 TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

 | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

if (nRet != RD_SUCCESS)

{

 printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

//query spc tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_DIGITAL);

nRet = spc_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME| TAG_PROP_TIME_DEADBAND | TAG_PROP_VALUE_DEADBAND, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query spc tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query spc tag successful, tag name is %s!\n", spcAlarmTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query spc tag complete!\n");

  break;

 }

 else

 {

  printf("query spc tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you have queried %d spc alarm tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = spc_query_tagid(hServer, spcAlarmTagSave.szTagName, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query spc alarm tag id failed,  alarm spc name[%s], error code[%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("spc alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  spcAlarmTagSave.szTagName, nTagID);

//modify tag desc

strcpy(spcAlarmTagSave.szDescriptor, "spc tag descriptor is modified");

spcAlarmTagSave.bRule1 = true;

spcAlarmTagSave.nRule1M = 10;

nRet = spc_modify_tag_prop(hServer, nTagID, &spcAlarmTagSave, TAG_PROP_DESCRIPTOR|TAG_PROP_SPC_RULE);

if (nRet != RD_SUCCESS)

{

 printf("modify spc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify spc tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = spc_query_tag_prop(hServer, nTagID, &spcAlarmTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query spc tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query spc tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 spcAlarmTagQuery.nTagID, spcAlarmTagQuery.szTagName, spcAlarmTagQuery.szDescriptor);

//query tag names

szTagNames = new char[1][HD_LEN_TAG_NAME];

nRet = spc_query_tag_names(hServer, 1, &nTagID, szTagNames, &nErrCode);

if (RD_SUCCESS == nRet)

{

 printf("query spc alarm tag[id:%d] name[%s] successful!\n", nTagID, szTagNames[0]);

}

else if (EC_HD_API_AM_QUERY_TAG_NAMES_FAILED == nRet)

{

 printf("query spc tag names failed, tag id[%d], error code[%d]!\n", nTagID, nErrCode);

}

if (nRet != RD_SUCCESS)

{

 printf("query spc tag names failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 delete[] szTagNames;

 nt_disconnect(hServer);

 return -1;

}

delete[] szTagNames;

//delete spc tag

nRet = spc_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete spc alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete spc alarm tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

?参见：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


关于

Navigation: »No topics above this level«

关于

 Return to chapter overview

从iHyperDB菜单中选择“关于..."，弹出对话框，显示版本信息。


添加关系数据库

Navigation: »No topics above this level«

添加关系数据库

 Return to chapter overview

本节介绍“添加关系数据库”的转储配置以及注意事项。

目前支持的转储的关系数据库类型有SQLServer，mySQL和Oracle,其中Oracle数据库只支持转储到关系数据库。

?转储方向选择为转到关系数据库后，在数据库类型下拉菜单中有SQLServer，mySQL和Oracle选项，如下图所示：

?当转储方向选为“转到iHyperDB”时，进行关系数据库采集器配置，数据库类型下拉菜单SQLServer和MySQL两个选项，如下图：

添加SQLServer和MySQL数据库

1. 输入转储方向，数据库类型，数据库名，地址，端口；

?数据库转储方向，包含了转到RDB和转到iHyperDB两种；

?数据库类型选择SQLServer和MySQL；

?数据库名是指关系数据库中DataBase名，长度不能超过64字节；

?地址可以为数据库服务器IP地址或者主机名，若为空，默认为localhost，长度不能超过64字节；

?端口为数据库服务器端口，若为空，则为数据库默认端口。

2. 输入用户名，密码，且长度都不能超过64字节；

3. 点击确定 添加关系数据库

?点击取消，取消添加数据库；

?输入的数据库参数校验错误，提示错误信息。

添加Oracle数据库

如图所示：

1.输入转储方向、数据库类型和数据源名称；

?数据库转储方向只能选择转到关系数据库；

?数据库类型选择Oracle，页面变成如上图所示；

?输入数据源名称，长度不能超过64字节；

2.输入用户名和密码，长度均不能超过64字节；

3.点击确定，添加关系数据库；

?点击取消，取消添加数据库；

添加成功后，界面如图所示：


配置服务器

Navigation: »No topics above this level«

配置服务器

 Return to chapter overview

《添加服务器》主要介绍如何添加一个服务器信息，供以后访问。

操作步骤如下：

点击系统管理平台中的“连接”按钮，弹出“服务器连接管理器”对话框，如下图：

如果是第一次登陆，可以修改服务器IP, 点击“修改”按钮，界面变更为：

修改IP地址168.2.237.40，点击“保存”服务器更新。勾选“状态” ，弹出登陆界面，输入“用户名”，“密码”，例如“admin”,"admin"

点击“确定”。

服务器连接上（后台服务都已经开始运行）。

注意：

IP地址、端口号和服务器名均为必填项。端口号为默认端口号5673。IP地址和端口号也不能和当前服务器中已经存在的服务器重复。

1.连接超时和数据访问超时只能填写不超过32767的正整数（默认为3秒）

2.连接超时：连接服务端的超时时间

3.数据访问超时：和服务端的数据交互的超时时间

©2015. All Rights Reserved.


添加转储表

Navigation: »No topics above this level«

添加转储表

 Return to chapter overview

本节介绍转储配置中“添加转储表”的操作以及注意事项。

1. iHyperDB转储将关系数据库中的表分为两种类型，窄表或宽表；

?窄表指该表的一行数据只包含一个Tag点的记录；

?宽表指该表的一行数据可以包含多个相关Tag点的记录。

2. 如果转储报警记录到关系数据库中，则只能转储为窄表。我们将报警记录属性分为两个部分，基本属性为表必须有的字段；可选属性为用户自行决定是否存在的字段。具体限制如下表：

 | 属性名 | 属性类型 | 表字段类型
基本属性 | 报警点名 | char[128] | 兼容63中文的字符串,建议不小于varchar(384)
 | 开始时间 | HDTime(nSec,nMsec) | 长度不小于20的字符串 || 关系数据库支持DataTime类型
可选属性 | 结束时间 | HDTime(nSec,nMsec) | 长度不小于20的字符串 || 关系数据库支持DataTime类型
 | 报警优先级 | uint8 | 数值型(兼容1字节无符号整型) || 长度不小于4的字符串
 | 源值 | char[1000] | 兼容报警点源点值的字符串,建议不小于varchar[1000]
 | 报警条件 | char[128] | 建议大于varchar[128]
 | 是否确认 | uint8 | 数值型(兼容1字节无符号整型) || 长度不小于4的字符串
 | 确认时间 | HDTime(nSec,nMsec) | 长度不小于20的字符串 || 关系数据库支持DataTime类型
 | 确认类型 | uint8 | 数值型(兼容1字节无符号整型) || 长度不小于4的字符串
 | 确认者 | char[32] | 兼容15中文的字符串,建议不小于varchar(96)
 | 是否恢复 | uint8 | 数值型(兼容1字节无符号整型) || 长度不小于4的字符串
 | 源点名 | char[128] | 兼容63中文的字符串,建议不小于varchar(384)
 | 注释 | char[256] | 兼容127中文的字符串,建议不小于varchar(768)
 | 注释者 | char[32] | 兼容15中文的字符串,建议不小于varchar(96)
 | 注释时间 | HDTime(nSec,nMsec) | 长度不小于20的字符串 || 关系数据库支持DataTime类型
 | 报警类型 | uint8 | 数值型(兼容1字节无符号整型) || 长度不小于4的字符串

3. 如果转储其他数据(非报警数据)到关系数据库中为窄表,我们将数据属性分为两个部分,基本属性为表必须有的字段;可选属性为用户自行决定是否存在的字段.具体限制如下:

 | 属性名 | 属性类型 | 表字段类型
基本属性 | Tag点名 | char[128] | 兼容63中文的字符串,建议不小于varchar(384)
 | 时间戳 | HDTime(nSec,nMsec) | 长度不小于20的字符串 || 关系数据库支持DataTime类型
 | 数据值 | int8 | 数值型(兼容1字节无符号整型) || 长度不小于5的字符串
 |  | int16 | 数值型(兼容2字节无符号整型) || 长度不小于7的字符串
 |  | int32 | 数值型(兼容4字节无符号整型) || 长度不小于12的字符串
 |  | fioat32 | 浮点型(兼容4字节浮点型) || 建议不小于varchar(40)
 |  | float64 | 浮点型(兼容8字节浮点型) || 建议不小于varchar(40)
 |  | int8(digital) | 同int8
 |  | string | 建议不小于varchar(1000)
 | 数据质量 | uint16 | 数据值(兼容2字节无符号整型) || 建议不小于varchar(8)

4.如果转储其他数据(非报警数据)到关系数据库中为宽表,则表中应当有字段和时间戳属性匹配.允许用户配置时选择特定Tag点的数据质量和数据值,宽表对数据质量、时间戳、数据值属性的限制与窄表对着三个属性的限制相同。


报警组

Navigation: »No topics above this level«

报警组

 Return to chapter overview

《报警组》的接口主要包括：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_name

?am_modify_group_parentid

?am_query_group_child_groups

?am_query_group_child_tags

?am_query_group_props

?am_query_groupid

报警组的基本属性包括以下四项：

/** iHyperDB 报警组 */

typedef struct _HDAlarmGroup

{

char szName[HD_LEN_ALARM_GROUP_NAME]; /**< 报警组的名称 */

char szDesc[HD_LEN_ALARM_GROUP_DESC]; /**< 报警组的描述 */

uint32 nGroupID; /**< 报警组的ID */

uint32 nParentID; /**< 报警组的父组ID*/

}HDAlarmGroup;

报警组是一种树状结构

注意:

1.报警组的的名称、描述和父组ID由用户添加，报警组的ID由报警服务自动生成。

2.添加报警组成功后报警组ID可以唯一标识这个报警组，该属性不能修改，名称、描述和报警组的父组ID都是可以修改的。

3.报警组的名称不能为空字符串，报警点的描述可以为空字符串。

4.不同父组下的子组名称可以相同，但是同一个父组下的子组名称不能重复，比如“温度报警组”下面也可以再添加一个“压力报警组”，但是不能再添加一个炉温报警组了。

5.报警组的名称不能为空字符串，报警点的描述可以为空字符串。

6.服务器下的第一层报警组的父组ID为0，如温度报警组的父组ID为0。

7.如果报警组包含子报警组或者报警点，则该报警组不能被删除。

8.每个服务器有一个名称为“orphan”的默认组，添加报警点时如果没有指定报警组，就会将它放在这个默认的组下。“orphan”报警组不能添加子报警组，也不能修改和删除。


报警点

Navigation: »No topics above this level«

报警点

 Return to chapter overview

《报警点》主要接口包括：

?am_add_tag

?am_delete_tag

?am_modify_tag_prop

?am_query_tag_names

?am_query_tag_prop

?am_query_tagid

?am_query_tags_cond

©2015. All Rights Reserved.


am_acknowledge_alarm

Navigation: »No topics above this level«

am_acknowledge_alarm

 Return to chapter overview

函数

在一台服务器中确认某一时刻的一条报警记录

int32 am_acknowledge_alarm(

HDHANDLE hServer,

uint32 TagIDs[],

HDTime alarmTimes[],

int32 nAckNum

);

参数

hServer

[in] 服务器句柄

nTagIDs[]

[in] 报警点ID数组

alarmTimes[],

[in] 报警产生的时间数组

nAckNum

[in] 报警个数

返回值

查询成功，返回RD_SUCCESS，查询失败返回其它错误码，见error_code.h。

说明

调用该方法成功后，该报警点在某一时刻产生的报警记录的确认状态被修改为确认。

举例

am_acknowledge_alarm

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

#include <windows.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

AlarmTagProp alarmTag;

int32 nRecNum = 3;

const int32 ALARM_TAG_NUM = 3;

uint32 nAlarmTagIDs[ALARM_TAG_NUM];

HDAlarmQuery queryCond;

HDRecord snapshot;

HDHANDLE hIter = NULL;

HDAlarmRecord alarmRecord;

HDAlarmRecord snAlarms[ALARM_TAG_NUM];

int32 nErrorCodes[ALARM_TAG_NUM];

HDTime alarmTimes[ALARM_TAG_NUM];

int32 i = 0;

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 return -1;

}

// add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

//add alarm tag

strcpy(alarmTag.szSourceTagName, normalTag.szTagName);

strcpy(alarmTag.szTest1, "GT(34)");

strcpy(alarmTag.szAction1, "1_hihi_ack");

strcpy(alarmTag.szTest2, "LT(34)");

strcpy(alarmTag.szAction2, "2_lolo_unack");

alarmTag.nAutoAck = ALARM_AUTO_ACK_NO;

for (i = 0; i < ALARM_TAG_NUM; i ++)

{

 sprintf(alarmTag.szTagName, "alarmTag_%d", i);

 nRet = am_add_tag(hServer, &alarmTag,  TAG_PROP_TAG_NAME|TAG_PROP_SOURCE_TAG

  |TAG_PROP_TEST1|TAG_PROP_ACTION1|TAG_PROP_TEST2|TAG_PROP_ACTION2

  | TAG_PROP_AUTOACK);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTag.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm tag[%s] successful!\n", normalTag.szTagName);

 nRet = am_query_tagid(hServer, alarmTag.szTagName, nAlarmTagIDs + i );

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm tag[%s] id failed, error code [%d]!\n", alarmTag.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm tag[%s] id successful!\n", normalTag.szTagName);

}

//save snapshots generate alarms

for (i = 0; i < nRecNum; i++)

{

 snapshot.nSec =  i + 1;

 snapshot.nMsec = 0;

 snapshot.nQuality = 192;

 if (0 == i % 2)

 {

  snapshot.value.nInt32 = 0;

 }

 else

 {

  snapshot.value.nInt32 = 66;

 }

 nRet = sn_save_snapshot(hServer, normalTag.nTagID, &snapshot);

 if (nRet != RD_SUCCESS)

 {

  printf("save snapshot failed, error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("save snapshot successful!\n");

}

Sleep(3000);

//query alarm snapshot

nRet = am_query_snapshots(hServer, ALARM_TAG_NUM, nAlarmTagIDs,

 ALARM_REC_PROP_ALL, snAlarms, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query alarm snapshots successful!\n");

}

else if (EC_HD_API_AM_QUERY_SNAPSHOTS_FAILED == nRet)

{

 for (i = 0; i < ALARM_TAG_NUM; i ++)

 {

  if (nErrorCodes[i] != RD_SUCCESS)

  {

   printf("query alarm tag[%d] snapshot failed, error code [%d]!\n", nAlarmTagIDs[i], nErrorCodes[i]);

  }

 }

}

else

{

 printf("query alarm snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//ack alarms

for (i = 0; i < nRecNum; i++)

{

 alarmTimes[i].nSec = snAlarms[i].tvStartTime.nSec;

 alarmTimes[i].nMsec = snAlarms[i].tvStartTime.nMsec;

}

nRet = am_acknowledge_alarms(hServer, nAlarmTagIDs, alarmTimes,  ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("acknowledge alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("acknowledge alarms successful!\n");

//comment alarms

nRet = am_comment_alarms(hServer, nAlarmTagIDs, alarmTimes, "this is a comment", ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("comment alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("comment alarms successful!\n");

//query tag alarm records

queryCond.tvStart.nSec = 1;

queryCond.tvStart.nMsec = 0;

queryCond.tvEnd.nMsec =0;

queryCond.tvEnd.nSec =100;

queryCond.nAckMask = (int8)MASK_ALARM_ALL;

queryCond.nPriorMask = (int8)MASK_ALARM_ALL;

queryCond.nTypeMask = (int8)MASK_ALARM_ALL;

queryCond.nCommentMask = (int8)MASK_ALARM_ALL;

queryCond.nRestoreMask = (int8)MASK_ALARM_ALL;

nRet = am_query_tag_records(hServer, nAlarmTagIDs[0], &queryCond, ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &alarmRecord);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

   alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags all records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query tags all alarm records include am snapshots

nRet = am_query_tags_all_records(hServer, nAlarmTagIDs, ALARM_TAG_NUM, &queryCond,

 ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &alarmRecord);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

   alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags all records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query group alarm records

nRet = am_query_group_records(hServer, 0, &queryCond, ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &alarmRecord);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

   alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query group records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

am_query_snapshots

am_register_alarm_record_info

am_query_tag_records

am_query_tags_all_records

am_query_group_records

am_comment_alarms


am_add_group

Navigation: »No topics above this level«

am_add_group

 Return to chapter overview

函数

int32 am_add_group(

HDHANDLE hServer,

const char* szName,

const char* szDesc,

uint32 nParentID

);

参数

hServer

[in] 服务器句柄。

szName

[in] 报警组名称。

szDesc

[in] 报警组描述。

nParentID

[in] 报警组父组ID。

返回值

添加成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

举例

am_add_group

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

uint32 nOrphenGroupID = 0;

const int32 ALARM_GROUP_COUNT = 2;

uint32 nGroupIDs[ALARM_GROUP_COUNT] = {0};

HDAlarmGroup alarmGroups[ALARM_GROUP_COUNT];

memset(alarmGroups, 0, sizeof(alarmGroups));

int32 nErrCodes[ALARM_GROUP_COUNT];

TagProp normalTag;

HDHANDLE hIter = NULL;

uint32 nChildGroupID = 0;

uint32 nChildAlarmTagID = 0;

AlarmTagProp alarmTag;

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 sprintf(alarmGroups[i].szName, "alarm_group_name_%d", i);

 sprintf(alarmGroups[i].szDesc, "alarm_group_desc_%d", i);

 alarmGroups[i].nParentID = nOrphenGroupID;

 nRet = am_add_group(hServer, alarmGroups[i].szName, alarmGroups[i].szDesc, nOrphenGroupID);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm group[%s] failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm group[%s] successful!\n",alarmGroups[i].szName);

}

//query alarm group id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_groupid(hServer, alarmGroups[i].szName, nOrphenGroupID, &(nGroupIDs[i]));

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [%s] id failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%s] id successful!\n",alarmGroups[i].szName);

}

//query alarm group props

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 HDAlarmGroup queryAlarmGroups[ALARM_GROUP_COUNT];

 nRet = am_query_group_props(hServer, ALARM_GROUP_COUNT, nGroupIDs, queryAlarmGroups, nErrCodes);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] prop failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%d] prop successful!\n",nGroupIDs[i]);

}

//modify alarm group name

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szName, "_modify");

 nRet = am_modify_group_name(hServer,nGroupIDs[i], alarmGroups[i].szName);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] name failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] name successful!\n",nGroupIDs[i]);

}

//modify alarm group desc

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szDesc, "_modify");

 nRet = am_modify_group_desc(hServer, nGroupIDs[i], alarmGroups[i].szDesc);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] desc failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] desc successful!\n",nGroupIDs[i]);

}

//modify alarm group parent id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 if (i >= 1)

 {

  nRet = am_modify_group_parentid(hServer, nGroupIDs[i], nGroupIDs[i - 1]);

  if (nRet != RD_SUCCESS)

  {

   printf("modify alarm group [id:%d] parent id[%d] failed, error code [%d]!\n", nGroupIDs[i],  nGroupIDs[i - 1], nRet);

   nt_disconnect(hServer);

   return -1;

  }

  printf("modify alarm group[id:%d] parent id [%d] successful!\n",nGroupIDs[i], nGroupIDs[i - 1]);

 }

}

//query child alarm group

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_groups(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child group failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildGroupID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child group successful, child group id %d!\n", nGroupIDs[i], nChildGroupID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child group complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child group, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

// add alarm tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 sprintf(alarmTag.szTagName, "alarmTag_%d", i);

 strcpy(alarmTag.szSourceTagName, normalTag.szTagName);

 strcpy(alarmTag.szTest1, "GT(100)");

 strcpy(alarmTag.szAction1, "1_hihi_unack");

 alarmTag.nAlarmGroupID = nGroupIDs[i];

 nRet = am_add_tag(hServer, &alarmTag, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

  | TAG_PROP_TEST1 | TAG_PROP_ACTION1 | TAG_PROP_ALARM_GROUP_ID);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTag.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm tag[%s] successful!\n", alarmTag.szTagName);

}

//query alarm group tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_tags(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child tags failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildAlarmTagID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child tag successful, child tag id %d!\n", nGroupIDs[i], nChildAlarmTagID);

   nRet = am_delete_tag(hServer, nChildAlarmTagID);

   if (nRet != RD_SUCCESS)

   {

    printf("delete alarm tag [id:%d] failed, error code [%d]!\n", nChildAlarmTagID, nRet);

    ut_free_iterator(hIter);

    nt_disconnect(hServer);

    return -1;

   }

   printf("delete alarm tag [id:%d] successful!\n", nChildAlarmTagID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child tag complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child tag, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//delete alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_delete_group(hServer, nGroupIDs[ALARM_GROUP_COUNT - i - 1]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete alarm group [id:%d] failed, error code [%d]!\n", nGroupIDs[ALARM_GROUP_COUNT - i - 1], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete alarm group [id:%d] successful!\n", nChildAlarmTagID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参考：

?am_delete_group

?am_modify_group_name

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


am_add_tag

Navigation: »No topics above this level«

am_add_tag

 Return to chapter overview

函数

在一台服务器中添加一个报警点

int32 am_add_tag(

HDHANDLE hServer,

const AlarmTagProp* pAlarmTag,

int64 nPropMask

);

参数

hServer

[in] 服务器句柄。

pAlarmTag

[in] 报警点属性。

nPropMask

[in] 报警点属性掩码，表明要存储报警点的哪些属性。

返回值

添加成功，返回RD_SUCCESS。添加失败返回其它错误码，见error_code.h。

说明

添加报警点时，报警点名称必须添加，其它属性可以选择性的添加，添加哪些属性有属性掩码决定。

举例

am_add_tag

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

AlarmTagProp alarmTagSave;

AlarmTagProp alarmTagQuery;

const char* szTagName_1 = "szAlarmTagName_1";

const char* szTagName_2 = "szAlarmTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  normalTag.szTagName, normalTag.nTagID);

//add two alarm tag

strcpy(alarmTagSave.szTagName, szTagName_1);

strcpy(alarmTagSave.szSourceTagName, normalTag.szTagName);

strcpy(alarmTagSave.szTest1, "GT(100)");

strcpy(alarmTagSave.szAction1, "1_hihi_unack");

nRet = am_add_tag(hServer, &alarmTagSave, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

 | TAG_PROP_TEST1 | TAG_PROP_ACTION1);

if (nRet != RD_SUCCESS)

{

 printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add alarm tag[%s] successful!\n", alarmTagSave.szTagName);

strcpy(alarmTagSave.szTagName, szTagName_2);

strcpy(alarmTagSave.szSourceTagName, normalTag.szTagName);

strcpy(alarmTagSave.szTest1, "LT(10)");

strcpy(alarmTagSave.szAction1, "2_lolo_unack");

nRet = am_add_tag(hServer, &alarmTagSave, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

 | TAG_PROP_TEST1 | TAG_PROP_ACTION1);

if (nRet != RD_SUCCESS)

{

 printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add alarm tag[%s] successful!\n", alarmTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_DIGITAL);

nRet = am_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query alarm tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &alarmTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query alarm tag successful, tag name is %s!\n", alarmTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query alarm tag complete!\n");

  break;

 }

 else

 {

  printf("query alarm tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you queried %d alarm tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = am_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query alarm tag id failed,  alarm tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  szTagName_1, nTagID);

//modify tag desc

strcpy(alarmTagSave.szDescriptor, "alarm tag descriptor is modified");

nRet = am_modify_tag_prop(hServer, nTagID, &alarmTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify alarm tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = am_query_tag_prop(hServer, nTagID, &alarmTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query alarm tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query alarm tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 alarmTagQuery.nTagID, alarmTagQuery.szTagName, alarmTagQuery.szDescriptor);

//delete tag

nRet = am_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete alarm tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参见：

?am_delete_tag

?am_modify_tag_prop

?am_query_tag_names

?am_query_tag_prop

?am_query_tagid

?am_query_tags_cond

?am_query_group_child_tags

©2015. All Rights Reserved.


am_comment_alarms

Navigation: »No topics above this level«

am_comment_alarms

 Return to chapter overview

函数

int32 am_comment_alarms(

HDHANDLE hServer,

uint32 tagIDs[],

HDTime alarmTimes[],

const char* szComment,

int32 nCommentNum

);

参数

hServer

[in] 服务器句柄

tagIDs[]

[in] 报警点ID数组

alarmTimes[]

[in] 报警产生的时间数组

szComment

[in]注释内容

nCommentNum

[in]需要注释的报警个数

返回值

查询成功，返回RD_SUCCESS，查询失败返回其它错误码，见error_code.h。

说明

举例

am_comment_alarms

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

#include <windows.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

AlarmTagProp alarmTag;

int32 nRecNum = 3;

const int32 ALARM_TAG_NUM = 3;

uint32 nAlarmTagIDs[ALARM_TAG_NUM];

HDAlarmQuery queryCond;

HDRecord snapshot;

HDHANDLE hIter = NULL;

HDAlarmRecord alarmRecord;

HDAlarmRecord snAlarms[ALARM_TAG_NUM];

int32 nErrorCodes[ALARM_TAG_NUM];

HDTime alarmTimes[ALARM_TAG_NUM];

int32 i = 0;

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

return -1;

}

// add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

//add alarm tag

strcpy(alarmTag.szSourceTagName, normalTag.szTagName);

strcpy(alarmTag.szTest1, "GT(34)");

strcpy(alarmTag.szAction1, "1_hihi_ack");

strcpy(alarmTag.szTest2, "LT(34)");

strcpy(alarmTag.szAction2, "2_lolo_unack");

alarmTag.nAutoAck = ALARM_AUTO_ACK_NO;

for (i = 0; i < ALARM_TAG_NUM; i ++)

{

sprintf(alarmTag.szTagName, "alarmTag_%d", i);

nRet = am_add_tag(hServer, &alarmTag, TAG_PROP_TAG_NAME|TAG_PROP_SOURCE_TAG

|TAG_PROP_TEST1|TAG_PROP_ACTION1|TAG_PROP_TEST2|TAG_PROP_ACTION2

| TAG_PROP_AUTOACK);

if (nRet != RD_SUCCESS)

{

printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add alarm tag[%s] successful!\n", normalTag.szTagName);

nRet = am_query_tagid(hServer, alarmTag.szTagName, nAlarmTagIDs + i );

if (nRet != RD_SUCCESS)

{

printf("query alarm tag[%s] id failed, error code [%d]!\n", alarmTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("query alarm tag[%s] id successful!\n", normalTag.szTagName);

}

//save snapshots generate alarms

for (i = 0; i < nRecNum; i++)

{

snapshot.nSec = i + 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

if (0 == i % 2)

{

snapshot.value.nInt32 = 0;

}

else

{

snapshot.value.nInt32 = 66;

}

nRet = sn_save_snapshot(hServer, normalTag.nTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

printf("save snapshot failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("save snapshot successful!\n");

}

Sleep(3000);

//query alarm snapshot

nRet = am_query_snapshots(hServer, ALARM_TAG_NUM, nAlarmTagIDs,

ALARM_REC_PROP_ALL, snAlarms, nErrorCodes);

if (RD_SUCCESS == nRet)

{

printf("query alarm snapshots successful!\n");

}

else if (EC_HD_API_AM_QUERY_SNAPSHOTS_FAILED == nRet)

{

for (i = 0; i < ALARM_TAG_NUM; i ++)

{

if (nErrorCodes[i] != RD_SUCCESS)

{

printf("query alarm tag[%d] snapshot failed, error code [%d]!\n", nAlarmTagIDs[i], nErrorCodes[i]);

}

}

}

else

{

printf("query alarm snapshots failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

//ack alarms

for (i = 0; i < nRecNum; i++)

{

alarmTimes[i].nSec = snAlarms[i].tvStartTime.nSec;

alarmTimes[i].nMsec = snAlarms[i].tvStartTime.nMsec;

}

nRet = am_acknowledge_alarms(hServer, nAlarmTagIDs, alarmTimes, ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

printf("acknowledge alarms failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("acknowledge alarms successful!\n");

//comment alarms

nRet = am_comment_alarms(hServer, nAlarmTagIDs, alarmTimes, "this is a comment", ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

printf("comment alarms failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("comment alarms successful!\n");

//query tag alarm records

queryCond.tvStart.nSec = 1;

queryCond.tvStart.nMsec = 0;

queryCond.tvEnd.nMsec =0;

queryCond.tvEnd.nSec =100;

queryCond.nAckMask = (int8)MASK_ALARM_ALL;

queryCond.nPriorMask = (int8)MASK_ALARM_ALL;

queryCond.nTypeMask = (int8)MASK_ALARM_ALL;

queryCond.nCommentMask = (int8)MASK_ALARM_ALL;

queryCond.nRestoreMask = (int8)MASK_ALARM_ALL;

nRet = am_query_tag_records(hServer, nAlarmTagIDs[0], &queryCond, ALARM_REC_PROP_ALL, &hIter);

while (true)

{

nRet = ut_get_item_step(hIter, &alarmRecord);

if (RD_SUCCESS == nRet)

{

printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query tags records complete\n");

nRet = RD_SUCCESS;

break;

}

else

{

printf("query tags all records failed, error code [%d]\n", nRet);

}

}

ut_free_iterator(hIter);

//query tags all alarm records include am snapshots

nRet = am_query_tags_all_records(hServer, nAlarmTagIDs, ALARM_TAG_NUM, &queryCond,

ALARM_REC_PROP_ALL, &hIter);

while (true)

{

nRet = ut_get_item_step(hIter, &alarmRecord);

if (RD_SUCCESS == nRet)

{

printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query tags all records complete\n");

nRet = RD_SUCCESS;

break;

}

else

{

printf("query tags all records failed, error code [%d]\n", nRet);

}

}

ut_free_iterator(hIter);

//query group alarm records

nRet = am_query_group_records(hServer, 0, &queryCond, ALARM_REC_PROP_ALL, &hIter);

while (true)

{

nRet = ut_get_item_step(hIter, &alarmRecord);

if (RD_SUCCESS == nRet)

{

printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group all records complete\n");

nRet = RD_SUCCESS;

break;

}

else

{

printf("query group records failed, error code [%d]\n", nRet);

}

}

ut_free_iterator(hIter);

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

am_acknowledge_alarm

am_query_snapshots

am_register_alarm_record_info

am_query_tag_records

am_query_tags_all_records

am_query_group_records

am_comment_alarms


am_delete_group

Navigation: »No topics above this level«

am_delete_group

 Return to chapter overview

函数

在一台服务器中删除一个指定报警组

int32 am_delete_group(

HDHANDLE hServer,

uint32 nGroupID

);

参数

hServer

[in] 服务器句柄。

nGroupID

[in] 报警组ID。

返回值

删除成功，返回RD_SUCCESS。删除失败返回其它错误码，见error_code.h。

说明

当报警组下面有子报警组或者报警点时，该报警组不能被删除。

举例

am_delete_group

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

uint32 nOrphenGroupID = 0;

const int32 ALARM_GROUP_COUNT = 2;

uint32 nGroupIDs[ALARM_GROUP_COUNT] = {0};

HDAlarmGroup alarmGroups[ALARM_GROUP_COUNT];

memset(alarmGroups, 0, sizeof(alarmGroups));

int32 nErrCodes[ALARM_GROUP_COUNT];

TagProp normalTag;

HDHANDLE hIter = NULL;

uint32 nChildGroupID = 0;

uint32 nChildAlarmTagID = 0;

AlarmTagProp alarmTag;

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 sprintf(alarmGroups[i].szName, "alarm_group_name_%d", i);

 sprintf(alarmGroups[i].szDesc, "alarm_group_desc_%d", i);

 alarmGroups[i].nParentID = nOrphenGroupID;

 nRet = am_add_group(hServer, alarmGroups[i].szName, alarmGroups[i].szDesc, nOrphenGroupID);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm group[%s] failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm group[%s] successful!\n",alarmGroups[i].szName);

}

//query alarm group id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_groupid(hServer, alarmGroups[i].szName, nOrphenGroupID, &(nGroupIDs[i]));

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [%s] id failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%s] id successful!\n",alarmGroups[i].szName);

}

//query alarm group props

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 HDAlarmGroup queryAlarmGroups[ALARM_GROUP_COUNT];

 nRet = am_query_group_props(hServer, ALARM_GROUP_COUNT, nGroupIDs, queryAlarmGroups, nErrCodes);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] prop failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%d] prop successful!\n",nGroupIDs[i]);

}

//modify alarm group name

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szName, "_modify");

 nRet = am_modify_group_name(hServer,nGroupIDs[i], alarmGroups[i].szName);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] name failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] name successful!\n",nGroupIDs[i]);

}

//modify alarm group desc

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szDesc, "_modify");

 nRet = am_modify_group_desc(hServer, nGroupIDs[i], alarmGroups[i].szDesc);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] desc failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] desc successful!\n",nGroupIDs[i]);

}

//modify alarm group parent id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 if (i >= 1)

 {

  nRet = am_modify_group_parentid(hServer, nGroupIDs[i], nGroupIDs[i - 1]);

  if (nRet != RD_SUCCESS)

  {

   printf("modify alarm group [id:%d] parent id[%d] failed, error code [%d]!\n", nGroupIDs[i],  nGroupIDs[i - 1], nRet);

   nt_disconnect(hServer);

   return -1;

  }

  printf("modify alarm group[id:%d] parent id [%d] successful!\n",nGroupIDs[i], nGroupIDs[i - 1]);

 }

}

//query child alarm group

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_groups(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child group failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildGroupID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child group successful, child group id %d!\n", nGroupIDs[i], nChildGroupID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child group complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child group, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

// add alarm tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 sprintf(alarmTag.szTagName, "alarmTag_%d", i);

 strcpy(alarmTag.szSourceTagName, normalTag.szTagName);

 strcpy(alarmTag.szTest1, "GT(100)");

 strcpy(alarmTag.szAction1, "1_hihi_unack");

 alarmTag.nAlarmGroupID = nGroupIDs[i];

 nRet = am_add_tag(hServer, &alarmTag, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

  | TAG_PROP_TEST1 | TAG_PROP_ACTION1 | TAG_PROP_ALARM_GROUP_ID);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTag.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm tag[%s] successful!\n", alarmTag.szTagName);

}

//query alarm group tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_tags(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child tags failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildAlarmTagID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child tag successful, child tag id %d!\n", nGroupIDs[i], nChildAlarmTagID);

   nRet = am_delete_tag(hServer, nChildAlarmTagID);

   if (nRet != RD_SUCCESS)

   {

    printf("delete alarm tag [id:%d] failed, error code [%d]!\n", nChildAlarmTagID, nRet);

    ut_free_iterator(hIter);

    nt_disconnect(hServer);

    return -1;

   }

   printf("delete alarm tag [id:%d] successful!\n", nChildAlarmTagID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child tag complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child tag, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//delete alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_delete_group(hServer, nGroupIDs[ALARM_GROUP_COUNT - i - 1]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete alarm group [id:%d] failed, error code [%d]!\n", nGroupIDs[ALARM_GROUP_COUNT - i - 1], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete alarm group [id:%d] successful!\n", nChildAlarmTagID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见:

?am_add_group

?am_modify_group_name

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


am_delete_tag

Navigation: »No topics above this level«

am_delete_tag

 Return to chapter overview

函数

在一台服务器中删除一个报警点

int32 am_delete_tag(

HDHANDLE hServer,

uint32 nTagID

);

参数

hServer

[in] 服务器句柄。

nTagID

[in] 报警点ID。

返回值

删除成功，返回RD_SUCCESS。删除失败返回其它错误码，见error_code.h。

举例

am_delete_tag

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

AlarmTagProp alarmTagSave;

AlarmTagProp alarmTagQuery;

const char* szTagName_1 = "szAlarmTagName_1";

const char* szTagName_2 = "szAlarmTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  normalTag.szTagName, normalTag.nTagID);

//add two alarm tag

strcpy(alarmTagSave.szTagName, szTagName_1);

strcpy(alarmTagSave.szSourceTagName, normalTag.szTagName);

strcpy(alarmTagSave.szTest1, "GT(100)");

strcpy(alarmTagSave.szAction1, "1_hihi_unack");

nRet = am_add_tag(hServer, &alarmTagSave, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

 | TAG_PROP_TEST1 | TAG_PROP_ACTION1);

if (nRet != RD_SUCCESS)

{

 printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add alarm tag[%s] successful!\n", alarmTagSave.szTagName);

strcpy(alarmTagSave.szTagName, szTagName_2);

strcpy(alarmTagSave.szSourceTagName, normalTag.szTagName);

strcpy(alarmTagSave.szTest1, "LT(10)");

strcpy(alarmTagSave.szAction1, "2_lolo_unack");

nRet = am_add_tag(hServer, &alarmTagSave, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

 | TAG_PROP_TEST1 | TAG_PROP_ACTION1);

if (nRet != RD_SUCCESS)

{

 printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add alarm tag[%s] successful!\n", alarmTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_DIGITAL);

nRet = am_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query calc tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &alarmTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query alarm tag successful, tag name is %s!\n", alarmTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query alarm tag complete!\n");

  break;

 }

 else

 {

  printf("query alarm tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you queried %d alarm tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = am_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query alarm tag id failed,  alarm tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  szTagName_1, nTagID);

//modify tag desc

strcpy(alarmTagSave.szDescriptor, "alarm tag descriptor is modified");

nRet = am_modify_tag_prop(hServer, nTagID, &alarmTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify alarm tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = am_query_tag_prop(hServer, nTagID, &alarmTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query alarm tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query alarm tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 alarmTagQuery.nTagID, alarmTagQuery.szTagName, alarmTagQuery.szDescriptor);

//delete tag

nRet = am_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete alarm tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参见:

am_add_tag

am_delete_tag

am_modify_tag_prop

am_query_tag_names

am_query_tag_prop

am_query_tagid

am_query_tags_cond


报警记录

Navigation: »No topics above this level«

报警记录

 Return to chapter overview

《报警记录》的主要接口包括：

?am_acknowledge_alarm

?am_query_snapshots

?am_register_alarm_record_info

?am_query_tag_records

?am_query_tags_all_records

?am_query_group_records

?am_comment_alarms

©2015. All Rights Reserved.


报警管理接口

Navigation: »No topics above this level«

报警管理接口

 Return to chapter overview

《报警管理接口》主要内容包括：

报警组

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_name

?am_modify_group_parentid

?am_query_group_child_groups

?am_query_group_child_tags

?am_query_group_props

?am_query_groupid

报警点

?am_add_tag

?am_delete_tag

?am_modify_tag_prop

?am_query_tag_names

?am_query_tag_prop

?am_query_tagid

?am_query_tags_cond

报警记录

?am_acknowledge_alarm

?am_query_snapshots

?am_register_alarm_record_info

?am_query_tag_records

?am_query_tags_all_records

?am_query_group_records

?am_comment_alarms

©2015. All Rights Reserved.


am_modify_group_desc

Navigation: »No topics above this level«

am_modify_group_desc

 Return to chapter overview

am_modify_group_desc

Glossary Item Box

函数

在一台服务器中修改指定报警组的描述

int32 am_modify_group_desc(

HDHANDLE hServer,

uint32 nGroupID,

const char* szDesc

);

参数

hServer

[in] 服务器句柄。

nGroupID

[in] 报警组ID。

szDesc

[in] 报警组描述。

返回值

修改成功，返回RD_SUCCESS。修改失败返回其它错误码，见error_code.h。

举例

am_modify_group_desc

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

uint32 nOrphenGroupID = 0;

const int32 ALARM_GROUP_COUNT = 2;

uint32 nGroupIDs[ALARM_GROUP_COUNT] = {0};

HDAlarmGroup alarmGroups[ALARM_GROUP_COUNT];

memset(alarmGroups, 0, sizeof(alarmGroups));

int32 nErrCodes[ALARM_GROUP_COUNT];

TagProp normalTag;

HDHANDLE hIter = NULL;

uint32 nChildGroupID = 0;

uint32 nChildAlarmTagID = 0;

AlarmTagProp alarmTag;

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 sprintf(alarmGroups[i].szName, "alarm_group_name_%d", i);

 sprintf(alarmGroups[i].szDesc, "alarm_group_desc_%d", i);

 alarmGroups[i].nParentID = nOrphenGroupID;

 nRet = am_add_group(hServer, alarmGroups[i].szName, alarmGroups[i].szDesc, nOrphenGroupID);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm group[%s] failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm group[%s] successful!\n",alarmGroups[i].szName);

}

//query alarm group id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_groupid(hServer, alarmGroups[i].szName, nOrphenGroupID, &(nGroupIDs[i]));

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [%s] id failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%s] id successful!\n",alarmGroups[i].szName);

}

//query alarm group props

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 HDAlarmGroup queryAlarmGroups[ALARM_GROUP_COUNT];

 nRet = am_query_group_props(hServer, ALARM_GROUP_COUNT, nGroupIDs, queryAlarmGroups, nErrCodes);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] prop failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%d] prop successful!\n",nGroupIDs[i]);

}

//modify alarm group name

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szName, "_modify");

 nRet = am_modify_group_name(hServer,nGroupIDs[i], alarmGroups[i].szName);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] name failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] name successful!\n",nGroupIDs[i]);

}

//modify alarm group desc

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szDesc, "_modify");

 nRet = am_modify_group_desc(hServer, nGroupIDs[i], alarmGroups[i].szDesc);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] desc failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] desc successful!\n",nGroupIDs[i]);

}

//modify alarm group parent id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 if (i >= 1)

 {

  nRet = am_modify_group_parentid(hServer, nGroupIDs[i], nGroupIDs[i - 1]);

  if (nRet != RD_SUCCESS)

  {

   printf("modify alarm group [id:%d] parent id[%d] failed, error code [%d]!\n", nGroupIDs[i],  nGroupIDs[i - 1], nRet);

   nt_disconnect(hServer);

   return -1;

  }

  printf("modify alarm group[id:%d] parent id [%d] successful!\n",nGroupIDs[i], nGroupIDs[i - 1]);

 }

}

//query child alarm group

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_groups(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child group failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildGroupID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child group successful, child group id %d!\n", nGroupIDs[i], nChildGroupID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child group complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child group, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

// add alarm tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 sprintf(alarmTag.szTagName, "alarmTag_%d", i);

 strcpy(alarmTag.szSourceTagName, normalTag.szTagName);

 strcpy(alarmTag.szTest1, "GT(100)");

 strcpy(alarmTag.szAction1, "1_hihi_unack");

 alarmTag.nAlarmGroupID = nGroupIDs[i];

 nRet = am_add_tag(hServer, &alarmTag, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

  | TAG_PROP_TEST1 | TAG_PROP_ACTION1 | TAG_PROP_ALARM_GROUP_ID);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTag.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm tag[%s] successful!\n", alarmTag.szTagName);

}

//query alarm group tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_tags(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child tags failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildAlarmTagID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child tag successful, child tag id %d!\n", nGroupIDs[i], nChildAlarmTagID);

   nRet = am_delete_tag(hServer, nChildAlarmTagID);

   if (nRet != RD_SUCCESS)

   {

    printf("delete alarm tag [id:%d] failed, error code [%d]!\n", nChildAlarmTagID, nRet);

    ut_free_iterator(hIter);

    nt_disconnect(hServer);

    return -1;

   }

   printf("delete alarm tag [id:%d] successful!\n", nChildAlarmTagID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child tag complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child tag, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//delete alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_delete_group(hServer, nGroupIDs[ALARM_GROUP_COUNT - i - 1]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete alarm group [id:%d] failed, error code [%d]!\n", nGroupIDs[ALARM_GROUP_COUNT - i - 1], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete alarm group [id:%d] successful!\n", nChildAlarmTagID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

?am_add_group

?am_delete_group

?am_modify_group_name

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


am_modify_group_name

Navigation: »No topics above this level«

am_modify_group_name

 Return to chapter overview

am_modify_group_name

Glossary Item Box

函数

在一台服务器中修改指定报警组的名称

int32 am_modify_group_name(

HDHANDLE hServer,

uint32 nGroupID,

const char* szName

);

参数

hServer

[in] 服务器句柄。

nGroupID

[in] 报警组ID。

szName

[in] 报警组名称。

返回值

修改成功，返回RD_SUCCESS。修改失败返回其它错误码，见error_code.h。

说明

同一个报警组下面的两个子报警组的名称不能相同

举例

am_modify_group_name

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

uint32 nOrphenGroupID = 0;

const int32 ALARM_GROUP_COUNT = 2;

uint32 nGroupIDs[ALARM_GROUP_COUNT] = {0};

HDAlarmGroup alarmGroups[ALARM_GROUP_COUNT];

memset(alarmGroups, 0, sizeof(alarmGroups));

int32 nErrCodes[ALARM_GROUP_COUNT];

TagProp normalTag;

HDHANDLE hIter = NULL;

uint32 nChildGroupID = 0;

uint32 nChildAlarmTagID = 0;

AlarmTagProp alarmTag;

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 sprintf(alarmGroups[i].szName, "alarm_group_name_%d", i);

 sprintf(alarmGroups[i].szDesc, "alarm_group_desc_%d", i);

 alarmGroups[i].nParentID = nOrphenGroupID;

 nRet = am_add_group(hServer, alarmGroups[i].szName, alarmGroups[i].szDesc, nOrphenGroupID);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm group[%s] failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm group[%s] successful!\n",alarmGroups[i].szName);

}

//query alarm group id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_groupid(hServer, alarmGroups[i].szName, nOrphenGroupID, &(nGroupIDs[i]));

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [%s] id failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%s] id successful!\n",alarmGroups[i].szName);

}

//query alarm group props

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 HDAlarmGroup queryAlarmGroups[ALARM_GROUP_COUNT];

 nRet = am_query_group_props(hServer, ALARM_GROUP_COUNT, nGroupIDs, queryAlarmGroups, nErrCodes);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] prop failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%d] prop successful!\n",nGroupIDs[i]);

}

//modify alarm group name

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szName, "_modify");

 nRet = am_modify_group_name(hServer,nGroupIDs[i], alarmGroups[i].szName);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] name failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] name successful!\n",nGroupIDs[i]);

}

//modify alarm group desc

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szDesc, "_modify");

 nRet = am_modify_group_desc(hServer, nGroupIDs[i], alarmGroups[i].szDesc);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] desc failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] desc successful!\n",nGroupIDs[i]);

}

//modify alarm group parent id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 if (i >= 1)

 {

  nRet = am_modify_group_parentid(hServer, nGroupIDs[i], nGroupIDs[i - 1]);

  if (nRet != RD_SUCCESS)

  {

   printf("modify alarm group [id:%d] parent id[%d] failed, error code [%d]!\n", nGroupIDs[i],  nGroupIDs[i - 1], nRet);

   nt_disconnect(hServer);

   return -1;

  }

  printf("modify alarm group[id:%d] parent id [%d] successful!\n",nGroupIDs[i], nGroupIDs[i - 1]);

 }

}

//query child alarm group

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_groups(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child group failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildGroupID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child group successful, child group id %d!\n", nGroupIDs[i], nChildGroupID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child group complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child group, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

// add alarm tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 sprintf(alarmTag.szTagName, "alarmTag_%d", i);

 strcpy(alarmTag.szSourceTagName, normalTag.szTagName);

 strcpy(alarmTag.szTest1, "GT(100)");

 strcpy(alarmTag.szAction1, "1_hihi_unack");

 alarmTag.nAlarmGroupID = nGroupIDs[i];

 nRet = am_add_tag(hServer, &alarmTag, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

  | TAG_PROP_TEST1 | TAG_PROP_ACTION1 | TAG_PROP_ALARM_GROUP_ID);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTag.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm tag[%s] successful!\n", alarmTag.szTagName);

}

//query alarm group tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_tags(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child tags failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildAlarmTagID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child tag successful, child tag id %d!\n", nGroupIDs[i], nChildAlarmTagID);

   nRet = am_delete_tag(hServer, nChildAlarmTagID);

   if (nRet != RD_SUCCESS)

   {

    printf("delete alarm tag [id:%d] failed, error code [%d]!\n", nChildAlarmTagID, nRet);

    ut_free_iterator(hIter);

    nt_disconnect(hServer);

    return -1;

   }

   printf("delete alarm tag [id:%d] successful!\n", nChildAlarmTagID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child tag complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child tag, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//delete alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_delete_group(hServer, nGroupIDs[ALARM_GROUP_COUNT - i - 1]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete alarm group [id:%d] failed, error code [%d]!\n", nGroupIDs[ALARM_GROUP_COUNT - i - 1], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete alarm group [id:%d] successful!\n", nChildAlarmTagID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}

?参见：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


am_modify_group_parentid

Navigation: »No topics above this level«

am_modify_group_parentid

 Return to chapter overview

am_modify_group_parentid

Glossary Item Box

函数

在一台服务器中修改指定报警组的父组

int32 am_modify_group_parentid(

HDHANDLE hServer,

uint32 nGroupID,

uint32 nParentID

);

参数

hServer

[in] 服务器句柄。

nGroupID

[in] 报警组ID。

nParentID

[in] 报警组父组ID。

返回值

修改成功，返回RD_SUCCESS。修改失败返回其它错误码，见error_code.h。

举例

am_modify_group_parentid

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

uint32 nOrphenGroupID = 0;

const int32 ALARM_GROUP_COUNT = 2;

uint32 nGroupIDs[ALARM_GROUP_COUNT] = {0};

HDAlarmGroup alarmGroups[ALARM_GROUP_COUNT];

memset(alarmGroups, 0, sizeof(alarmGroups));

int32 nErrCodes[ALARM_GROUP_COUNT];

TagProp normalTag;

HDHANDLE hIter = NULL;

uint32 nChildGroupID = 0;

uint32 nChildAlarmTagID = 0;

AlarmTagProp alarmTag;

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 sprintf(alarmGroups[i].szName, "alarm_group_name_%d", i);

 sprintf(alarmGroups[i].szDesc, "alarm_group_desc_%d", i);

 alarmGroups[i].nParentID = nOrphenGroupID;

 nRet = am_add_group(hServer, alarmGroups[i].szName, alarmGroups[i].szDesc, nOrphenGroupID);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm group[%s] failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm group[%s] successful!\n",alarmGroups[i].szName);

}

//query alarm group id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_groupid(hServer, alarmGroups[i].szName, nOrphenGroupID, &(nGroupIDs[i]));

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [%s] id failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%s] id successful!\n",alarmGroups[i].szName);

}

//query alarm group props

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 HDAlarmGroup queryAlarmGroups[ALARM_GROUP_COUNT];

 nRet = am_query_group_props(hServer, ALARM_GROUP_COUNT, nGroupIDs, queryAlarmGroups, nErrCodes);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] prop failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%d] prop successful!\n",nGroupIDs[i]);

}

//modify alarm group name

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szName, "_modify");

 nRet = am_modify_group_name(hServer,nGroupIDs[i], alarmGroups[i].szName);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] name failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] name successful!\n",nGroupIDs[i]);

}

//modify alarm group desc

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szDesc, "_modify");

 nRet = am_modify_group_desc(hServer, nGroupIDs[i], alarmGroups[i].szDesc);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] desc failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] desc successful!\n",nGroupIDs[i]);

}

//modify alarm group parent id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 if (i >= 1)

 {

  nRet = am_modify_group_parentid(hServer, nGroupIDs[i], nGroupIDs[i - 1]);

  if (nRet != RD_SUCCESS)

  {

   printf("modify alarm group [id:%d] parent id[%d] failed, error code [%d]!\n", nGroupIDs[i],  nGroupIDs[i - 1], nRet);

   nt_disconnect(hServer);

   return -1;

  }

  printf("modify alarm group[id:%d] parent id [%d] successful!\n",nGroupIDs[i], nGroupIDs[i - 1]);

 }

}

//query child alarm group

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_groups(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child group failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildGroupID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child group successful, child group id %d!\n", nGroupIDs[i], nChildGroupID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child group complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child group, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

// add alarm tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 sprintf(alarmTag.szTagName, "alarmTag_%d", i);

 strcpy(alarmTag.szSourceTagName, normalTag.szTagName);

 strcpy(alarmTag.szTest1, "GT(100)");

 strcpy(alarmTag.szAction1, "1_hihi_unack");

 alarmTag.nAlarmGroupID = nGroupIDs[i];

 nRet = am_add_tag(hServer, &alarmTag, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

  | TAG_PROP_TEST1 | TAG_PROP_ACTION1 | TAG_PROP_ALARM_GROUP_ID);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTag.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm tag[%s] successful!\n", alarmTag.szTagName);

}

//query alarm group tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_tags(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child tags failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildAlarmTagID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child tag successful, child tag id %d!\n", nGroupIDs[i], nChildAlarmTagID);

   nRet = am_delete_tag(hServer, nChildAlarmTagID);

   if (nRet != RD_SUCCESS)

   {

    printf("delete alarm tag [id:%d] failed, error code [%d]!\n", nChildAlarmTagID, nRet);

    ut_free_iterator(hIter);

    nt_disconnect(hServer);

    return -1;

   }

   printf("delete alarm tag [id:%d] successful!\n", nChildAlarmTagID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child tag complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child tag, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//delete alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_delete_group(hServer, nGroupIDs[ALARM_GROUP_COUNT - i - 1]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete alarm group [id:%d] failed, error code [%d]!\n", nGroupIDs[ALARM_GROUP_COUNT - i - 1], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete alarm group [id:%d] successful!\n", nChildAlarmTagID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

?am_add_group

?am_delete_group

?am_modify_group_name

?am_modify_group_desc

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


am_modify_tag_prop

Navigation: »No topics above this level«

am_modify_tag_prop

 Return to chapter overview

am_modify_tag_prop

Glossary Item Box

函数

在一台服务器中修改一个报警点的属性

int32 am_modify_tag_prop(

HDHANDLE hServer,

uint32 nTagID,

const AlarmTagProp* pTagProp,

int64 nPropMask

);

参数

hServer

[in] 服务器句柄。

nTagID

[in] 报警点ID。

pTagProp

[in] 报警点属性。

nPropMask

[in] 报警点属性掩码。

说明

创建日期，修改日期，报警点ID，报警点名称和报警点类型不允许修改。

举例

am_modify_tag_prop

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

AlarmTagProp alarmTagSave;

AlarmTagProp alarmTagQuery;

const char* szTagName_1 = "szAlarmTagName_1";

const char* szTagName_2 = "szAlarmTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  normalTag.szTagName, normalTag.nTagID);

//add two alarm tag

strcpy(alarmTagSave.szTagName, szTagName_1);

strcpy(alarmTagSave.szSourceTagName, normalTag.szTagName);

strcpy(alarmTagSave.szTest1, "GT(100)");

strcpy(alarmTagSave.szAction1, "1_hihi_unack");

nRet = am_add_tag(hServer, &alarmTagSave, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

 | TAG_PROP_TEST1 | TAG_PROP_ACTION1);

if (nRet != RD_SUCCESS)

{

 printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add alarm tag[%s] successful!\n", alarmTagSave.szTagName);

strcpy(alarmTagSave.szTagName, szTagName_2);

strcpy(alarmTagSave.szSourceTagName, normalTag.szTagName);

strcpy(alarmTagSave.szTest1, "LT(10)");

strcpy(alarmTagSave.szAction1, "2_lolo_unack");

nRet = am_add_tag(hServer, &alarmTagSave, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

 | TAG_PROP_TEST1 | TAG_PROP_ACTION1);

if (nRet != RD_SUCCESS)

{

 printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add alarm tag[%s] successful!\n", alarmTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_DIGITAL);

nRet = am_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query calc tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &alarmTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query alarm tag successful, tag name is %s!\n", alarmTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query alarm tag complete!\n");

  break;

 }

 else

 {

  printf("query alarm tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you queried %d alarm tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = am_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query alarm tag id failed,  alarm tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  szTagName_1, nTagID);

//modify tag desc

strcpy(alarmTagSave.szDescriptor, "alarm tag descriptor is modified");

nRet = am_modify_tag_prop(hServer, nTagID, &alarmTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify alarm tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = am_query_tag_prop(hServer, nTagID, &alarmTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query alarm tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query alarm tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 alarmTagQuery.nTagID, alarmTagQuery.szTagName, alarmTagQuery.szDescriptor);

//delete tag

nRet = am_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete alarm tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参见：

am_add_tag

am_delete_tag

am_modify_tag_prop

am_query_tag_names

am_query_tag_prop

am_query_tagid

am_query_tags_cond

am_query_group_child_tags


am_query_group_child_groups

Navigation: »No topics above this level«

am_query_group_child_groups

 Return to chapter overview

am_query_group_child_groups

Glossary Item Box

函数

在一台服务器中查询一个报警组下面的子报警组

int32 am_query_group_child_groups(

HDHANDLE hServer,

uint32 nGroupID,

HDHANDLE* pHIter

);

参数

hServer

[in] 服务器句柄。

nGroupID

[in] 报警组ID。

pHIter

[out] 查询迭代器。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

说明

调用该接口成功后会获得一个查询迭代器的句柄，然后调用ut_get_item_step接口，传入迭代器句柄和分配的空间(uint32*)，返回RD_SUCCESS就可以获得第一个子报警组的ID，再调用ut_get_item_step返回RD_SUCCESS就可以获得第二个子报警组的ID。如此循环的查询直到调用ut_get_item_step返回错误码为EC_HD_API_QUERY_END表明所有的子报警组的ID都查询完毕了。查询完毕后调用ut_free_iterator方法来释放迭代器。

举例

am_query_group_child_groups

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

uint32 nOrphenGroupID = 0;

const int32 ALARM_GROUP_COUNT = 2;

uint32 nGroupIDs[ALARM_GROUP_COUNT] = {0};

HDAlarmGroup alarmGroups[ALARM_GROUP_COUNT];

memset(alarmGroups, 0, sizeof(alarmGroups));

int32 nErrCodes[ALARM_GROUP_COUNT];

TagProp normalTag;

HDHANDLE hIter = NULL;

uint32 nChildGroupID = 0;

uint32 nChildAlarmTagID = 0;

AlarmTagProp alarmTag;

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 sprintf(alarmGroups[i].szName, "alarm_group_name_%d", i);

 sprintf(alarmGroups[i].szDesc, "alarm_group_desc_%d", i);

 alarmGroups[i].nParentID = nOrphenGroupID;

 nRet = am_add_group(hServer, alarmGroups[i].szName, alarmGroups[i].szDesc, nOrphenGroupID);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm group[%s] failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm group[%s] successful!\n",alarmGroups[i].szName);

}

//query alarm group id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_groupid(hServer, alarmGroups[i].szName, nOrphenGroupID, &(nGroupIDs[i]));

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [%s] id failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%s] id successful!\n",alarmGroups[i].szName);

}

//query alarm group props

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 HDAlarmGroup queryAlarmGroups[ALARM_GROUP_COUNT];

 nRet = am_query_group_props(hServer, ALARM_GROUP_COUNT, nGroupIDs, queryAlarmGroups, nErrCodes);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] prop failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%d] prop successful!\n",nGroupIDs[i]);

}

//modify alarm group name

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szName, "_modify");

 nRet = am_modify_group_name(hServer,nGroupIDs[i], alarmGroups[i].szName);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] name failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] name successful!\n",nGroupIDs[i]);

}

//modify alarm group desc

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szDesc, "_modify");

 nRet = am_modify_group_desc(hServer, nGroupIDs[i], alarmGroups[i].szDesc);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] desc failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] desc successful!\n",nGroupIDs[i]);

}

//modify alarm group parent id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 if (i >= 1)

 {

  nRet = am_modify_group_parentid(hServer, nGroupIDs[i], nGroupIDs[i - 1]);

  if (nRet != RD_SUCCESS)

  {

   printf("modify alarm group [id:%d] parent id[%d] failed, error code [%d]!\n", nGroupIDs[i],  nGroupIDs[i - 1], nRet);

   nt_disconnect(hServer);

   return -1;

  }

  printf("modify alarm group[id:%d] parent id [%d] successful!\n",nGroupIDs[i], nGroupIDs[i - 1]);

 }

}

//query child alarm group

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_groups(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child group failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildGroupID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child group successful, child group id %d!\n", nGroupIDs[i], nChildGroupID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child group complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child group, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

// add alarm tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 sprintf(alarmTag.szTagName, "alarmTag_%d", i);

 strcpy(alarmTag.szSourceTagName, normalTag.szTagName);

 strcpy(alarmTag.szTest1, "GT(100)");

 strcpy(alarmTag.szAction1, "1_hihi_unack");

 alarmTag.nAlarmGroupID = nGroupIDs[i];

 nRet = am_add_tag(hServer, &alarmTag, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

  | TAG_PROP_TEST1 | TAG_PROP_ACTION1 | TAG_PROP_ALARM_GROUP_ID);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTag.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm tag[%s] successful!\n", alarmTag.szTagName);

}

//query alarm group tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_tags(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child tags failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildAlarmTagID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child tag successful, child tag id %d!\n", nGroupIDs[i], nChildAlarmTagID);

   nRet = am_delete_tag(hServer, nChildAlarmTagID);

   if (nRet != RD_SUCCESS)

   {

    printf("delete alarm tag [id:%d] failed, error code [%d]!\n", nChildAlarmTagID, nRet);

    ut_free_iterator(hIter);

    nt_disconnect(hServer);

    return -1;

   }

   printf("delete alarm tag [id:%d] successful!\n", nChildAlarmTagID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child tag complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child tag, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//delete alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_delete_group(hServer, nGroupIDs[ALARM_GROUP_COUNT - i - 1]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete alarm group [id:%d] failed, error code [%d]!\n", nGroupIDs[ALARM_GROUP_COUNT - i - 1], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete alarm group [id:%d] successful!\n", nChildAlarmTagID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

?am_add_group

?am_delete_group

?am_modify_group_name

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_tags

©2015. All Rights Reserved.


am_query_group_child_tags

Navigation: »No topics above this level«

am_query_group_child_tags

 Return to chapter overview

am_query_group_child_tags

Glossary Item Box

函数

在一台服务器中查询一个报警组下面的子报警点

int32 am_query_group_child_tags(

HDHANDLE hServer,

uint32 nGroupID,

HDHANDLE* pHIter

);

参数

hServer

[in] 服务器句柄。

nGroupID

[in] 报警组ID。

pHIter

[out] 查询迭代器。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

说明

调用该接口成功后会获得一个查询迭代器的句柄，然后调用ut_get_item_step接口，传入迭代器句柄和分配的空间(uint32*)，返回RD_SUCCESS就可以获得第一个子报警点的ID，再调用ut_get_item_step返回RD_SUCCESS就可以获得第二个子报警点的ID。如此循环的查询直到调用ut_get_item_step返回错误码为EC_HD_API_QUERY_END表明所有的子报警点的ID都查询完毕了。查询完毕后调用ut_free_iterator方法来释放迭代器.

举例

am_query_group_child_tags

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

uint32 nOrphenGroupID = 0;

const int32 ALARM_GROUP_COUNT = 2;

uint32 nGroupIDs[ALARM_GROUP_COUNT] = {0};

HDAlarmGroup alarmGroups[ALARM_GROUP_COUNT];

memset(alarmGroups, 0, sizeof(alarmGroups));

int32 nErrCodes[ALARM_GROUP_COUNT];

TagProp normalTag;

HDHANDLE hIter = NULL;

uint32 nChildGroupID = 0;

uint32 nChildAlarmTagID = 0;

AlarmTagProp alarmTag;

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 sprintf(alarmGroups[i].szName, "alarm_group_name_%d", i);

 sprintf(alarmGroups[i].szDesc, "alarm_group_desc_%d", i);

 alarmGroups[i].nParentID = nOrphenGroupID;

 nRet = am_add_group(hServer, alarmGroups[i].szName, alarmGroups[i].szDesc, nOrphenGroupID);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm group[%s] failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm group[%s] successful!\n",alarmGroups[i].szName);

}

//query alarm group id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_groupid(hServer, alarmGroups[i].szName, nOrphenGroupID, &(nGroupIDs[i]));

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [%s] id failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%s] id successful!\n",alarmGroups[i].szName);

}

//query alarm group props

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 HDAlarmGroup queryAlarmGroups[ALARM_GROUP_COUNT];

 nRet = am_query_group_props(hServer, ALARM_GROUP_COUNT, nGroupIDs, queryAlarmGroups, nErrCodes);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] prop failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%d] prop successful!\n",nGroupIDs[i]);

}

//modify alarm group name

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szName, "_modify");

 nRet = am_modify_group_name(hServer,nGroupIDs[i], alarmGroups[i].szName);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] name failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] name successful!\n",nGroupIDs[i]);

}

//modify alarm group desc

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szDesc, "_modify");

 nRet = am_modify_group_desc(hServer, nGroupIDs[i], alarmGroups[i].szDesc);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] desc failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] desc successful!\n",nGroupIDs[i]);

}

//modify alarm group parent id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 if (i >= 1)

 {

  nRet = am_modify_group_parentid(hServer, nGroupIDs[i], nGroupIDs[i - 1]);

  if (nRet != RD_SUCCESS)

  {

   printf("modify alarm group [id:%d] parent id[%d] failed, error code [%d]!\n", nGroupIDs[i],  nGroupIDs[i - 1], nRet);

   nt_disconnect(hServer);

   return -1;

  }

  printf("modify alarm group[id:%d] parent id [%d] successful!\n",nGroupIDs[i], nGroupIDs[i - 1]);

 }

}

//query child alarm group

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_groups(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child group failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildGroupID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child group successful, child group id %d!\n", nGroupIDs[i], nChildGroupID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child group complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child group, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

// add alarm tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 sprintf(alarmTag.szTagName, "alarmTag_%d", i);

 strcpy(alarmTag.szSourceTagName, normalTag.szTagName);

 strcpy(alarmTag.szTest1, "GT(100)");

 strcpy(alarmTag.szAction1, "1_hihi_unack");

 alarmTag.nAlarmGroupID = nGroupIDs[i];

 nRet = am_add_tag(hServer, &alarmTag, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

  | TAG_PROP_TEST1 | TAG_PROP_ACTION1 | TAG_PROP_ALARM_GROUP_ID);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTag.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm tag[%s] successful!\n", alarmTag.szTagName);

}

//query alarm group tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_tags(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child tags failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildAlarmTagID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child tag successful, child tag id %d!\n", nGroupIDs[i], nChildAlarmTagID);

   nRet = am_delete_tag(hServer, nChildAlarmTagID);

   if (nRet != RD_SUCCESS)

   {

    printf("delete alarm tag [id:%d] failed, error code [%d]!\n", nChildAlarmTagID, nRet);

    ut_free_iterator(hIter);

    nt_disconnect(hServer);

    return -1;

   }

   printf("delete alarm tag [id:%d] successful!\n", nChildAlarmTagID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child tag complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child tag, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//delete alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_delete_group(hServer, nGroupIDs[ALARM_GROUP_COUNT - i - 1]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete alarm group [id:%d] failed, error code [%d]!\n", nGroupIDs[ALARM_GROUP_COUNT - i - 1], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete alarm group [id:%d] successful!\n", nChildAlarmTagID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参数：

?am_add_group

?am_delete_group

?am_modify_group_name

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

©2015. All Rights Reserved.


am_query_groupid

Navigation: »No topics above this level«

am_query_groupid

 Return to chapter overview

am_query_groupid

Glossary Item Box

参数

在一台服务器中根据报警组的名称和报警组的父组ID查询报警组的ID

int32 am_query_groupid(

HDHANDLE hServer,

const char* szName,

uint32 nParentID,

uint32* pGroupID

);

参数

hServer

[in] 服务器句柄。

szName

[in] 报警组名称。

nParentID

[in] 报警组父组ID。

pGroupID

[out] 报警组ID。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

说明

报警组的ID是唯一的，同一个父报警组下的报警组名称是不能重复的，根据父组ID和报警组名称可以唯一的查询到一个报警组ID。

举例

am_query_groupid

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

uint32 nOrphenGroupID = 0;

const int32 ALARM_GROUP_COUNT = 2;

uint32 nGroupIDs[ALARM_GROUP_COUNT] = {0};

HDAlarmGroup alarmGroups[ALARM_GROUP_COUNT];

memset(alarmGroups, 0, sizeof(alarmGroups));

int32 nErrCodes[ALARM_GROUP_COUNT];

TagProp normalTag;

HDHANDLE hIter = NULL;

uint32 nChildGroupID = 0;

uint32 nChildAlarmTagID = 0;

AlarmTagProp alarmTag;

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 sprintf(alarmGroups[i].szName, "alarm_group_name_%d", i);

 sprintf(alarmGroups[i].szDesc, "alarm_group_desc_%d", i);

 alarmGroups[i].nParentID = nOrphenGroupID;

 nRet = am_add_group(hServer, alarmGroups[i].szName, alarmGroups[i].szDesc, nOrphenGroupID);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm group[%s] failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm group[%s] successful!\n",alarmGroups[i].szName);

}

//query alarm group id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_groupid(hServer, alarmGroups[i].szName, nOrphenGroupID, &(nGroupIDs[i]));

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [%s] id failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%s] id successful!\n",alarmGroups[i].szName);

}

//query alarm group props

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 HDAlarmGroup queryAlarmGroups[ALARM_GROUP_COUNT];

 nRet = am_query_group_props(hServer, ALARM_GROUP_COUNT, nGroupIDs, queryAlarmGroups, nErrCodes);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] prop failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%d] prop successful!\n",nGroupIDs[i]);

}

//modify alarm group name

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szName, "_modify");

 nRet = am_modify_group_name(hServer,nGroupIDs[i], alarmGroups[i].szName);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] name failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] name successful!\n",nGroupIDs[i]);

}

//modify alarm group desc

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szDesc, "_modify");

 nRet = am_modify_group_desc(hServer, nGroupIDs[i], alarmGroups[i].szDesc);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] desc failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] desc successful!\n",nGroupIDs[i]);

}

//modify alarm group parent id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 if (i >= 1)

 {

  nRet = am_modify_group_parentid(hServer, nGroupIDs[i], nGroupIDs[i - 1]);

  if (nRet != RD_SUCCESS)

  {

   printf("modify alarm group [id:%d] parent id[%d] failed, error code [%d]!\n", nGroupIDs[i],  nGroupIDs[i - 1], nRet);

   nt_disconnect(hServer);

   return -1;

  }

  printf("modify alarm group[id:%d] parent id [%d] successful!\n",nGroupIDs[i], nGroupIDs[i - 1]);

 }

}

//query child alarm group

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_groups(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child group failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildGroupID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child group successful, child group id %d!\n", nGroupIDs[i], nChildGroupID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child group complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child group, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

// add alarm tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 sprintf(alarmTag.szTagName, "alarmTag_%d", i);

 strcpy(alarmTag.szSourceTagName, normalTag.szTagName);

 strcpy(alarmTag.szTest1, "GT(100)");

 strcpy(alarmTag.szAction1, "1_hihi_unack");

 alarmTag.nAlarmGroupID = nGroupIDs[i];

 nRet = am_add_tag(hServer, &alarmTag, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

  | TAG_PROP_TEST1 | TAG_PROP_ACTION1 | TAG_PROP_ALARM_GROUP_ID);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTag.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm tag[%s] successful!\n", alarmTag.szTagName);

}

//query alarm group tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_tags(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child tags failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildAlarmTagID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child tag successful, child tag id %d!\n", nGroupIDs[i], nChildAlarmTagID);

   nRet = am_delete_tag(hServer, nChildAlarmTagID);

   if (nRet != RD_SUCCESS)

   {

    printf("delete alarm tag [id:%d] failed, error code [%d]!\n", nChildAlarmTagID, nRet);

    ut_free_iterator(hIter);

    nt_disconnect(hServer);

    return -1;

   }

   printf("delete alarm tag [id:%d] successful!\n", nChildAlarmTagID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child tag complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child tag, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//delete alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_delete_group(hServer, nGroupIDs[ALARM_GROUP_COUNT - i - 1]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete alarm group [id:%d] failed, error code [%d]!\n", nGroupIDs[ALARM_GROUP_COUNT - i - 1], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete alarm group [id:%d] successful!\n", nChildAlarmTagID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

?am_add_group

?am_delete_group

?am_modify_group_name

?am_modify_group_desc

?am_modify_group_parentid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


am_query_group_props

Navigation: »No topics above this level«

am_query_group_props

 Return to chapter overview

am_query_group_props

Glossary Item Box

函数

在一台服务器中查询多个报警组的属性

int32 am_query_group_props(

HDHANDLE hServer,

int32 nGroupNum,

uint32 nGroupIDs[],

HDAlarmGroup groups[],

int32 nErrCodes[]

);

参数

hServer

[in] 服务器句柄。

nGroupNum

[in] 报警组个数。

nGroupIDs

[in] 报警组ID数组。

groups

[out] 报警组ID数组。

nErrCodes

[out] 错误码数组。

返回值

查询成功，返回RD_SUCCESS。一部分成功返回EC_HD_API_QUERY_ALARM_GROUP_PROPS_FAILED，查询失败返回其它错误码，见error_code.h。

说明

返回RD_SUCCESS表明所有的组的属性查询都成功。

返回EC_HD_API_QUERY_ALARM_GROUP_PROPS_FAILED表明一部分组的属性查询成功，通过查询错误码数组nErrCodes[]可以知道哪些组查询成功。

返回其它错误码表明查询失败。

举例

am_query_group_props

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

uint32 nOrphenGroupID = 0;

const int32 ALARM_GROUP_COUNT = 2;

uint32 nGroupIDs[ALARM_GROUP_COUNT] = {0};

HDAlarmGroup alarmGroups[ALARM_GROUP_COUNT];

memset(alarmGroups, 0, sizeof(alarmGroups));

int32 nErrCodes[ALARM_GROUP_COUNT];

TagProp normalTag;

HDHANDLE hIter = NULL;

uint32 nChildGroupID = 0;

uint32 nChildAlarmTagID = 0;

AlarmTagProp alarmTag;

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 sprintf(alarmGroups[i].szName, "alarm_group_name_%d", i);

 sprintf(alarmGroups[i].szDesc, "alarm_group_desc_%d", i);

 alarmGroups[i].nParentID = nOrphenGroupID;

 nRet = am_add_group(hServer, alarmGroups[i].szName, alarmGroups[i].szDesc, nOrphenGroupID);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm group[%s] failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm group[%s] successful!\n",alarmGroups[i].szName);

}

//query alarm group id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_groupid(hServer, alarmGroups[i].szName, nOrphenGroupID, &(nGroupIDs[i]));

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [%s] id failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%s] id successful!\n",alarmGroups[i].szName);

}

//query alarm group props

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 HDAlarmGroup queryAlarmGroups[ALARM_GROUP_COUNT];

 nRet = am_query_group_props(hServer, ALARM_GROUP_COUNT, nGroupIDs, queryAlarmGroups, nErrCodes);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] prop failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%d] prop successful!\n",nGroupIDs[i]);

}

//modify alarm group name

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szName, "_modify");

 nRet = am_modify_group_name(hServer,nGroupIDs[i], alarmGroups[i].szName);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] name failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] name successful!\n",nGroupIDs[i]);

}

//modify alarm group desc

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szDesc, "_modify");

 nRet = am_modify_group_desc(hServer, nGroupIDs[i], alarmGroups[i].szDesc);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] desc failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] desc successful!\n",nGroupIDs[i]);

}

//modify alarm group parent id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 if (i >= 1)

 {

  nRet = am_modify_group_parentid(hServer, nGroupIDs[i], nGroupIDs[i - 1]);

  if (nRet != RD_SUCCESS)

  {

   printf("modify alarm group [id:%d] parent id[%d] failed, error code [%d]!\n", nGroupIDs[i],  nGroupIDs[i - 1], nRet);

   nt_disconnect(hServer);

   return -1;

  }

  printf("modify alarm group[id:%d] parent id [%d] successful!\n",nGroupIDs[i], nGroupIDs[i - 1]);

 }

}

//query child alarm group

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_groups(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child group failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildGroupID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child group successful, child group id %d!\n", nGroupIDs[i], nChildGroupID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child group complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child group, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

// add alarm tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 sprintf(alarmTag.szTagName, "alarmTag_%d", i);

 strcpy(alarmTag.szSourceTagName, normalTag.szTagName);

 strcpy(alarmTag.szTest1, "GT(100)");

 strcpy(alarmTag.szAction1, "1_hihi_unack");

 alarmTag.nAlarmGroupID = nGroupIDs[i];

 nRet = am_add_tag(hServer, &alarmTag, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

  | TAG_PROP_TEST1 | TAG_PROP_ACTION1 | TAG_PROP_ALARM_GROUP_ID);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTag.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm tag[%s] successful!\n", alarmTag.szTagName);

}

//query alarm group tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_tags(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child tags failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildAlarmTagID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child tag successful, child tag id %d!\n", nGroupIDs[i], nChildAlarmTagID);

   nRet = am_delete_tag(hServer, nChildAlarmTagID);

   if (nRet != RD_SUCCESS)

   {

    printf("delete alarm tag [id:%d] failed, error code [%d]!\n", nChildAlarmTagID, nRet);

    ut_free_iterator(hIter);

    nt_disconnect(hServer);

    return -1;

   }

   printf("delete alarm tag [id:%d] successful!\n", nChildAlarmTagID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child tag complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child tag, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//delete alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_delete_group(hServer, nGroupIDs[ALARM_GROUP_COUNT - i - 1]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete alarm group [id:%d] failed, error code [%d]!\n", nGroupIDs[ALARM_GROUP_COUNT - i - 1], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete alarm group [id:%d] successful!\n", nChildAlarmTagID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

?am_add_group

?am_delete_group

?am_modify_group_name

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


am_query_group_records

Navigation: »No topics above this level«

am_query_group_records

 Return to chapter overview

am_query_group_records

Glossary Item Box

函数

int32 am_query_group_records(

HDHANDLE hServer,

uint32 nAlarmGroupID,

const HDAlarmQuery* pQueryCond,

int64 nPropMask,

HDHANDLE* pHIter

);

参数

hServer

[in] 服务器句柄

nAlarmGroupID

[in] 报警组ID

pQueryCond

[in] 查询条件

nPropMask

[in] 返回的报警记录的属性掩码

pHIter

[out] 报警记录迭代器句柄,查询的报警记录包括实时记录和历史记录

返回值

查询成功,返回RD_SUCCESS,查询失败返回其他错误码,见error.h

说明

举例

am_query_group_records

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

#include <windows.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

AlarmTagProp alarmTag;

int32 nRecNum = 3;

const int32 ALARM_TAG_NUM = 3;

uint32 nAlarmTagIDs[ALARM_TAG_NUM];

HDAlarmQuery queryCond;

HDRecord snapshot;

HDHANDLE hIter = NULL;

HDAlarmRecord alarmRecord;

HDAlarmRecord snAlarms[ALARM_TAG_NUM];

int32 nErrorCodes[ALARM_TAG_NUM];

HDTime alarmTimes[ALARM_TAG_NUM];

int32 i = 0;

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

return -1;

}

// add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

//add alarm tag

strcpy(alarmTag.szSourceTagName, normalTag.szTagName);

strcpy(alarmTag.szTest1, "GT(34)");

strcpy(alarmTag.szAction1, "1_hihi_ack");

strcpy(alarmTag.szTest2, "LT(34)");

strcpy(alarmTag.szAction2, "2_lolo_unack");

alarmTag.nAutoAck = ALARM_AUTO_ACK_NO;

for (i = 0; i < ALARM_TAG_NUM; i ++)

{

sprintf(alarmTag.szTagName, "alarmTag_%d", i);

nRet = am_add_tag(hServer, &alarmTag, TAG_PROP_TAG_NAME|TAG_PROP_SOURCE_TAG

|TAG_PROP_TEST1|TAG_PROP_ACTION1|TAG_PROP_TEST2|TAG_PROP_ACTION2

| TAG_PROP_AUTOACK);

if (nRet != RD_SUCCESS)

{

printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add alarm tag[%s] successful!\n", normalTag.szTagName);

nRet = am_query_tagid(hServer, alarmTag.szTagName, nAlarmTagIDs + i );

if (nRet != RD_SUCCESS)

{

printf("query alarm tag[%s] id failed, error code [%d]!\n", alarmTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("query alarm tag[%s] id successful!\n", normalTag.szTagName);

}

//save snapshots generate alarms

for (i = 0; i < nRecNum; i++)

{

snapshot.nSec = i + 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

if (0 == i % 2)

{

snapshot.value.nInt32 = 0;

}

else

{

snapshot.value.nInt32 = 66;

}

nRet = sn_save_snapshot(hServer, normalTag.nTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

printf("save snapshot failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("save snapshot successful!\n");

}

Sleep(3000);

//query alarm snapshot

nRet = am_query_snapshots(hServer, ALARM_TAG_NUM, nAlarmTagIDs,

ALARM_REC_PROP_ALL, snAlarms, nErrorCodes);

if (RD_SUCCESS == nRet)

{

printf("query alarm snapshots successful!\n");

}

else if (EC_HD_API_AM_QUERY_SNAPSHOTS_FAILED == nRet)

{

for (i = 0; i < ALARM_TAG_NUM; i ++)

{

if (nErrorCodes[i] != RD_SUCCESS)

{

printf("query alarm tag[%d] snapshot failed, error code [%d]!\n", nAlarmTagIDs[i], nErrorCodes[i]);

}

}

}

else

{

printf("query alarm snapshots failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

//ack alarms

for (i = 0; i < nRecNum; i++)

{

alarmTimes[i].nSec = snAlarms[i].tvStartTime.nSec;

alarmTimes[i].nMsec = snAlarms[i].tvStartTime.nMsec;

}

nRet = am_acknowledge_alarms(hServer, nAlarmTagIDs, alarmTimes, ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

printf("acknowledge alarms failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("acknowledge alarms successful!\n");

//comment alarms

nRet = am_comment_alarms(hServer, nAlarmTagIDs, alarmTimes, "this is a comment", ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

printf("comment alarms failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("comment alarms successful!\n");

//query tag alarm records

queryCond.tvStart.nSec = 1;

queryCond.tvStart.nMsec = 0;

queryCond.tvEnd.nMsec =0;

queryCond.tvEnd.nSec =100;

queryCond.nAckMask = (int8)MASK_ALARM_ALL;

queryCond.nPriorMask = (int8)MASK_ALARM_ALL;

queryCond.nTypeMask = (int8)MASK_ALARM_ALL;

queryCond.nCommentMask = (int8)MASK_ALARM_ALL;

queryCond.nRestoreMask = (int8)MASK_ALARM_ALL;

nRet = am_query_tag_records(hServer, nAlarmTagIDs[0], &queryCond, ALARM_REC_PROP_ALL, &hIter);

while (true)

{

nRet = ut_get_item_step(hIter, &alarmRecord);

if (RD_SUCCESS == nRet)

{

printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query tags records complete\n");

nRet = RD_SUCCESS;

break;

}

else

{

printf("query tags all records failed, error code [%d]\n", nRet);

}

}

ut_free_iterator(hIter);

//query tags all alarm records include am snapshots

nRet = am_query_tags_all_records(hServer, nAlarmTagIDs, ALARM_TAG_NUM, &queryCond,

ALARM_REC_PROP_ALL, &hIter);

while (true)

{

nRet = ut_get_item_step(hIter, &alarmRecord);

if (RD_SUCCESS == nRet)

{

printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query tags all records complete\n");

nRet = RD_SUCCESS;

break;

}

else

{

printf("query tags all records failed, error code [%d]\n", nRet);

}

}

ut_free_iterator(hIter);

//query group alarm records

nRet = am_query_group_records(hServer, 0, &queryCond, ALARM_REC_PROP_ALL, &hIter);

while (true)

{

nRet = ut_get_item_step(hIter, &alarmRecord);

if (RD_SUCCESS == nRet)

{

printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group all records complete\n");

nRet = RD_SUCCESS;

break;

}

else

{

printf("query group records failed, error code [%d]\n", nRet);

}

}

ut_free_iterator(hIter);

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

am_acknowledge_alarm

am_query_snapshots

am_register_alarm_record_info

am_query_tag_records

am_query_tags_all_records

am_query_group_records

am_comment_alarms


am_query_snapshots

Navigation: »No topics above this level«

am_query_snapshots

 Return to chapter overview

am_query_snapshots

Glossary Item Box

函数

在一台服务器中查询多个报警点的实时报警记录

int32 am_query_snapshots(

HDHANDLE hServer,

int32 nRecNum,

uint32 nTagIDs[],

int64 nPropMask,

HDAlarmRecord alarmRecords[],

int32 nErrCodes[]

);

参数

hServer

[in] 服务器句柄。

nRecNum

[in] 报警点个数。

nTagIDs

[in] 报警点ID数组。

nPropMask

[in]返回的报警记录的属性掩码

alarmRecords

[out] 报警记录数组。

nErrCodes

[out] 错误码数组。

返回值

查询成功，返回RD_SUCCESS。一部分成功返回EC_HD_API_AM_QUERY_SNAPSHOTS_FAILED，查询失败返回其它错误码，见error_code.h。

说明

举例

am_query_snapshots

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

#include <windows.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

AlarmTagProp alarmTag;

int32 nRecNum = 3;

const int32 ALARM_TAG_NUM = 3;

uint32 nAlarmTagIDs[ALARM_TAG_NUM];

HDAlarmQuery queryCond;

HDRecord snapshot;

HDHANDLE hIter = NULL;

HDAlarmRecord alarmRecord;

HDAlarmRecord snAlarms[ALARM_TAG_NUM];

int32 nErrorCodes[ALARM_TAG_NUM];

HDTime alarmTimes[ALARM_TAG_NUM];

int32 i = 0;

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 return -1;

}

// add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

//add alarm tag

strcpy(alarmTag.szSourceTagName, normalTag.szTagName);

strcpy(alarmTag.szTest1, "GT(34)");

strcpy(alarmTag.szAction1, "1_hihi_ack");

strcpy(alarmTag.szTest2, "LT(34)");

strcpy(alarmTag.szAction2, "2_lolo_unack");

alarmTag.nAutoAck = ALARM_AUTO_ACK_NO;

for (i = 0; i < ALARM_TAG_NUM; i ++)

{

 sprintf(alarmTag.szTagName, "alarmTag_%d", i);

 nRet = am_add_tag(hServer, &alarmTag,  TAG_PROP_TAG_NAME|TAG_PROP_SOURCE_TAG

  |TAG_PROP_TEST1|TAG_PROP_ACTION1|TAG_PROP_TEST2|TAG_PROP_ACTION2

  | TAG_PROP_AUTOACK);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTag.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm tag[%s] successful!\n", normalTag.szTagName);

 nRet = am_query_tagid(hServer, alarmTag.szTagName, nAlarmTagIDs + i );

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm tag[%s] id failed, error code [%d]!\n", alarmTag.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm tag[%s] id successful!\n", normalTag.szTagName);

}

//save snapshots generate alarms

for (i = 0; i < nRecNum; i++)

{

 snapshot.nSec =  i + 1;

 snapshot.nMsec = 0;

 snapshot.nQuality = 192;

 if (0 == i % 2)

 {

  snapshot.value.nInt32 = 0;

 }

 else

 {

  snapshot.value.nInt32 = 66;

 }

 nRet = sn_save_snapshot(hServer, normalTag.nTagID, &snapshot);

 if (nRet != RD_SUCCESS)

 {

  printf("save snapshot failed, error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("save snapshot successful!\n");

}

Sleep(3000);

//query alarm snapshot

nRet = am_query_snapshots(hServer, ALARM_TAG_NUM, nAlarmTagIDs,

 ALARM_REC_PROP_ALL, snAlarms, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query alarm snapshots successful!\n");

}

else if (EC_HD_API_AM_QUERY_SNAPSHOTS_FAILED == nRet)

{

 for (i = 0; i < ALARM_TAG_NUM; i ++)

 {

  if (nErrorCodes[i] != RD_SUCCESS)

  {

   printf("query alarm tag[%d] snapshot failed, error code [%d]!\n", nAlarmTagIDs[i], nErrorCodes[i]);

  }

 }

}

else

{

 printf("query alarm snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//ack alarms

for (i = 0; i < nRecNum; i++)

{

 alarmTimes[i].nSec = snAlarms[i].tvStartTime.nSec;

 alarmTimes[i].nMsec = snAlarms[i].tvStartTime.nMsec;

}

nRet = am_acknowledge_alarms(hServer, nAlarmTagIDs, alarmTimes,  ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("acknowledge alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("acknowledge alarms successful!\n");

//comment alarms

nRet = am_comment_alarms(hServer, nAlarmTagIDs, alarmTimes, "this is a comment", ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("comment alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("comment alarms successful!\n");

//query tag alarm records

queryCond.tvStart.nSec = 1;

queryCond.tvStart.nMsec = 0;

queryCond.tvEnd.nMsec =0;

queryCond.tvEnd.nSec =100;

queryCond.nAckMask = (int8)MASK_ALARM_ALL;

queryCond.nPriorMask = (int8)MASK_ALARM_ALL;

queryCond.nTypeMask = (int8)MASK_ALARM_ALL;

queryCond.nCommentMask = (int8)MASK_ALARM_ALL;

queryCond.nRestoreMask = (int8)MASK_ALARM_ALL;

nRet = am_query_tag_records(hServer, nAlarmTagIDs[0], &queryCond, ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &alarmRecord);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

   alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags all records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query tags all alarm records include am snapshots

nRet = am_query_tags_all_records(hServer, nAlarmTagIDs, ALARM_TAG_NUM, &queryCond,

 ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &alarmRecord);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

   alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags all records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query group alarm records

nRet = am_query_group_records(hServer, 0, &queryCond, ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &alarmRecord);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

   alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query group records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

am_acknowledge_alarm

am_register_alarm_record_info

am_query_tag_records

am_query_tags_all_records

am_query_group_records

am_comment_alarms


am_query_tagid

Navigation: »No topics above this level«

am_query_tagid

 Return to chapter overview

am_query_tagid

Glossary Item Box

函数

在一台服务器中通过报警点的名称查询该报警点的ID

int32 am_query_tagid(

HDHANDLE hServer,

const char* szName,

uint32* pTagID

);

参数

hServer

[in] 服务器句柄。

szName

[in] 报警点名称。

pTagID

[out] 报警点ID。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

am_query_tag_id

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

AlarmTagProp alarmTagSave;

AlarmTagProp alarmTagQuery;

const char* szTagName_1 = "szAlarmTagName_1";

const char* szTagName_2 = "szAlarmTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  normalTag.szTagName, normalTag.nTagID);

//add two alarm tag

strcpy(alarmTagSave.szTagName, szTagName_1);

strcpy(alarmTagSave.szSourceTagName, normalTag.szTagName);

strcpy(alarmTagSave.szTest1, "GT(100)");

strcpy(alarmTagSave.szAction1, "1_hihi_unack");

nRet = am_add_tag(hServer, &alarmTagSave, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

 | TAG_PROP_TEST1 | TAG_PROP_ACTION1);

if (nRet != RD_SUCCESS)

{

 printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add alarm tag[%s] successful!\n", alarmTagSave.szTagName);

strcpy(alarmTagSave.szTagName, szTagName_2);

strcpy(alarmTagSave.szSourceTagName, normalTag.szTagName);

strcpy(alarmTagSave.szTest1, "LT(10)");

strcpy(alarmTagSave.szAction1, "2_lolo_unack");

nRet = am_add_tag(hServer, &alarmTagSave, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

 | TAG_PROP_TEST1 | TAG_PROP_ACTION1);

if (nRet != RD_SUCCESS)

{

 printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add alarm tag[%s] successful!\n", alarmTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_DIGITAL);

nRet = am_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query calc tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &alarmTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query alarm tag successful, tag name is %s!\n", alarmTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query alarm tag complete!\n");

  break;

 }

 else

 {

  printf("query alarm tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you queried %d alarm tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = am_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query alarm tag id failed,  alarm tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  szTagName_1, nTagID);

//modify tag desc

strcpy(alarmTagSave.szDescriptor, "alarm tag descriptor is modified");

nRet = am_modify_tag_prop(hServer, nTagID, &alarmTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify alarm tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = am_query_tag_prop(hServer, nTagID, &alarmTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query alarm tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query alarm tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 alarmTagQuery.nTagID, alarmTagQuery.szTagName, alarmTagQuery.szDescriptor);

//delete tag

nRet = am_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete alarm tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参见：

am_add_tag

am_delete_tag

am_modify_tag_prop

am_query_tag_names

am_query_tag_prop

am_query_tagid

am_query_tags_cond


am_query_tag_names

Navigation: »No topics above this level«

am_query_tag_names

 Return to chapter overview

am_query_tag_names

Glossary Item Box

函数

在一台服务器中查询多个报警点的名称

int32 am_query_tag_names(

HDHANDLE hServer,

int32 nTagNum,

uint32 nTagIDs[],

char szTagNames[][HD_LEN_TAG_NAME],

int32 nErrCodes[]

);

函数

hServer

[in] 服务器句柄。

nTagNum

[in] 报警点个数。

nTagIDs

[in] 报警点ID数组。

szTagNames

[out] 报警点名称数组。

nErrCodes

[out] 错误码数组。

返回值

查询成功，返回RD_SUCCESS。一部分成功返回EC_HD_API_AM_QUERY_TAG_NAMES_FAILED，查询失败返回其它错误码，见error_code.h。

说明

返回RD_SUCCESS表明所有的报警点的名称查询都成功。

返回EC_HD_API_AM_QUERY_TAG_NAMES_FAILED表明一部分报警点的名称查询成功，通过查询错误码数组nErrCodes[]可以知道哪些报警点查询成功。

返回其它错误码表明查询失败。

举例

am_query_tag_names

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

AlarmTagProp alarmTagSave;

AlarmTagProp alarmTagQuery;

const char* szTagName_1 = "szAlarmTagName_1";

const char* szTagName_2 = "szAlarmTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  normalTag.szTagName, normalTag.nTagID);

//add two alarm tag

strcpy(alarmTagSave.szTagName, szTagName_1);

strcpy(alarmTagSave.szSourceTagName, normalTag.szTagName);

strcpy(alarmTagSave.szTest1, "GT(100)");

strcpy(alarmTagSave.szAction1, "1_hihi_unack");

nRet = am_add_tag(hServer, &alarmTagSave, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

 | TAG_PROP_TEST1 | TAG_PROP_ACTION1);

if (nRet != RD_SUCCESS)

{

 printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add alarm tag[%s] successful!\n", alarmTagSave.szTagName);

strcpy(alarmTagSave.szTagName, szTagName_2);

strcpy(alarmTagSave.szSourceTagName, normalTag.szTagName);

strcpy(alarmTagSave.szTest1, "LT(10)");

strcpy(alarmTagSave.szAction1, "2_lolo_unack");

nRet = am_add_tag(hServer, &alarmTagSave, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

 | TAG_PROP_TEST1 | TAG_PROP_ACTION1);

if (nRet != RD_SUCCESS)

{

 printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add alarm tag[%s] successful!\n", alarmTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_DIGITAL);

nRet = am_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query calc tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &alarmTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query alarm tag successful, tag name is %s!\n", alarmTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query alarm tag complete!\n");

  break;

 }

 else

 {

  printf("query alarm tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you queried %d alarm tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = am_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query alarm tag id failed,  alarm tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  szTagName_1, nTagID);

//modify tag desc

strcpy(alarmTagSave.szDescriptor, "alarm tag descriptor is modified");

nRet = am_modify_tag_prop(hServer, nTagID, &alarmTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify alarm tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = am_query_tag_prop(hServer, nTagID, &alarmTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query alarm tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query alarm tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 alarmTagQuery.nTagID, alarmTagQuery.szTagName, alarmTagQuery.szDescriptor);

//delete tag

nRet = am_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete alarm tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参见：

am_add_tag

am_delete_tag

am_modify_tag_prop

am_query_tag_names

am_query_tag_prop

am_query_tagid

am_query_tags_cond


am_query_tag_prop

Navigation: »No topics above this level«

am_query_tag_prop

 Return to chapter overview

am_query_tag_prop

Glossary Item Box

函数

在一台服务器中查询一个报警点的属性

int32 am_query_tag_prop(

HDHANDLE hServer,

uint32 nTagID,

AlarmTagProp* pTagProp

);

参数

hServer

[in] 服务器句柄。

nTagID

[in] 报警点ID。

pTagProp

[out] 报警点属性。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

am_query_tag_props

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

AlarmTagProp alarmTagSave;

AlarmTagProp alarmTagQuery;

const char* szTagName_1 = "szAlarmTagName_1";

const char* szTagName_2 = "szAlarmTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  normalTag.szTagName, normalTag.nTagID);

//add two alarm tag

strcpy(alarmTagSave.szTagName, szTagName_1);

strcpy(alarmTagSave.szSourceTagName, normalTag.szTagName);

strcpy(alarmTagSave.szTest1, "GT(100)");

strcpy(alarmTagSave.szAction1, "1_hihi_unack");

nRet = am_add_tag(hServer, &alarmTagSave, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

 | TAG_PROP_TEST1 | TAG_PROP_ACTION1);

if (nRet != RD_SUCCESS)

{

 printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add alarm tag[%s] successful!\n", alarmTagSave.szTagName);

strcpy(alarmTagSave.szTagName, szTagName_2);

strcpy(alarmTagSave.szSourceTagName, normalTag.szTagName);

strcpy(alarmTagSave.szTest1, "LT(10)");

strcpy(alarmTagSave.szAction1, "2_lolo_unack");

nRet = am_add_tag(hServer, &alarmTagSave, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

 | TAG_PROP_TEST1 | TAG_PROP_ACTION1);

if (nRet != RD_SUCCESS)

{

 printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add alarm tag[%s] successful!\n", alarmTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_DIGITAL);

nRet = am_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query calc tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &alarmTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query alarm tag successful, tag name is %s!\n", alarmTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query alarm tag complete!\n");

  break;

 }

 else

 {

  printf("query alarm tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you queried %d alarm tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = am_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query alarm tag id failed,  alarm tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  szTagName_1, nTagID);

//modify tag desc

strcpy(alarmTagSave.szDescriptor, "alarm tag descriptor is modified");

nRet = am_modify_tag_prop(hServer, nTagID, &alarmTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify alarm tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = am_query_tag_prop(hServer, nTagID, &alarmTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query alarm tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query alarm tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 alarmTagQuery.nTagID, alarmTagQuery.szTagName, alarmTagQuery.szDescriptor);

//delete tag

nRet = am_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete alarm tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参见：

am_add_tag

am_delete_tag

am_modify_tag_prop

am_query_tag_names

am_query_tag_prop

am_query_tagid

am_query_tags_cond


am_query_tag_records

Navigation: »No topics above this level«

am_query_tag_records

 Return to chapter overview

am_query_tag_records

Glossary Item Box

函数

查询多个报警点的报警记录

int32 am_query_tag_records(

HDHANDLE hServer,

uint32 nTagID,

const HDAlarmQuery* pQueryCond,

int64 nPropMask,

HDHANDLE* pHIter

);

参数

hServer

[in] 服务器句柄

nTagID

[in] 报警点ID数组

nTagNum

[in] 报警点数组个数

pQueryCond

[in] 查询条件

nPropMask

[in] 返回的报警记录的属性掩码

pHIter

[out] 报警记录迭代器句柄,查询的报警记录包括实时记录和历史记录

返回值

查询成功,返回RD_SUCCESS,查询失败返回其他错误码,见error.h

说明

举例

am_query_tag_records

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

#include <windows.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

AlarmTagProp alarmTag;

int32 nRecNum = 3;

const int32 ALARM_TAG_NUM = 3;

uint32 nAlarmTagIDs[ALARM_TAG_NUM];

HDAlarmQuery queryCond;

HDRecord snapshot;

HDHANDLE hIter = NULL;

HDAlarmRecord alarmRecord;

HDAlarmRecord snAlarms[ALARM_TAG_NUM];

int32 nErrorCodes[ALARM_TAG_NUM];

HDTime alarmTimes[ALARM_TAG_NUM];

int32 i = 0;

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

return -1;

}

// add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

//add alarm tag

strcpy(alarmTag.szSourceTagName, normalTag.szTagName);

strcpy(alarmTag.szTest1, "GT(34)");

strcpy(alarmTag.szAction1, "1_hihi_ack");

strcpy(alarmTag.szTest2, "LT(34)");

strcpy(alarmTag.szAction2, "2_lolo_unack");

alarmTag.nAutoAck = ALARM_AUTO_ACK_NO;

for (i = 0; i < ALARM_TAG_NUM; i ++)

{

sprintf(alarmTag.szTagName, "alarmTag_%d", i);

nRet = am_add_tag(hServer, &alarmTag, TAG_PROP_TAG_NAME|TAG_PROP_SOURCE_TAG

|TAG_PROP_TEST1|TAG_PROP_ACTION1|TAG_PROP_TEST2|TAG_PROP_ACTION2

| TAG_PROP_AUTOACK);

if (nRet != RD_SUCCESS)

{

printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add alarm tag[%s] successful!\n", normalTag.szTagName);

nRet = am_query_tagid(hServer, alarmTag.szTagName, nAlarmTagIDs + i );

if (nRet != RD_SUCCESS)

{

printf("query alarm tag[%s] id failed, error code [%d]!\n", alarmTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("query alarm tag[%s] id successful!\n", normalTag.szTagName);

}

//save snapshots generate alarms

for (i = 0; i < nRecNum; i++)

{

snapshot.nSec = i + 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

if (0 == i % 2)

{

snapshot.value.nInt32 = 0;

}

else

{

snapshot.value.nInt32 = 66;

}

nRet = sn_save_snapshot(hServer, normalTag.nTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

printf("save snapshot failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("save snapshot successful!\n");

}

Sleep(3000);

//query alarm snapshot

nRet = am_query_snapshots(hServer, ALARM_TAG_NUM, nAlarmTagIDs,

ALARM_REC_PROP_ALL, snAlarms, nErrorCodes);

if (RD_SUCCESS == nRet)

{

printf("query alarm snapshots successful!\n");

}

else if (EC_HD_API_AM_QUERY_SNAPSHOTS_FAILED == nRet)

{

for (i = 0; i < ALARM_TAG_NUM; i ++)

{

if (nErrorCodes[i] != RD_SUCCESS)

{

printf("query alarm tag[%d] snapshot failed, error code [%d]!\n", nAlarmTagIDs[i], nErrorCodes[i]);

}

}

}

else

{

printf("query alarm snapshots failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

//ack alarms

for (i = 0; i < nRecNum; i++)

{

alarmTimes[i].nSec = snAlarms[i].tvStartTime.nSec;

alarmTimes[i].nMsec = snAlarms[i].tvStartTime.nMsec;

}

nRet = am_acknowledge_alarms(hServer, nAlarmTagIDs, alarmTimes, ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

printf("acknowledge alarms failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("acknowledge alarms successful!\n");

//comment alarms

nRet = am_comment_alarms(hServer, nAlarmTagIDs, alarmTimes, "this is a comment", ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

printf("comment alarms failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("comment alarms successful!\n");

//query tag alarm records

queryCond.tvStart.nSec = 1;

queryCond.tvStart.nMsec = 0;

queryCond.tvEnd.nMsec =0;

queryCond.tvEnd.nSec =100;

queryCond.nAckMask = (int8)MASK_ALARM_ALL;

queryCond.nPriorMask = (int8)MASK_ALARM_ALL;

queryCond.nTypeMask = (int8)MASK_ALARM_ALL;

queryCond.nCommentMask = (int8)MASK_ALARM_ALL;

queryCond.nRestoreMask = (int8)MASK_ALARM_ALL;

nRet = am_query_tag_records(hServer, nAlarmTagIDs[0], &queryCond, ALARM_REC_PROP_ALL, &hIter);

while (true)

{

nRet = ut_get_item_step(hIter, &alarmRecord);

if (RD_SUCCESS == nRet)

{

printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query tags records complete\n");

nRet = RD_SUCCESS;

break;

}

else

{

printf("query tags all records failed, error code [%d]\n", nRet);

}

}

ut_free_iterator(hIter);

//query tags all alarm records include am snapshots

nRet = am_query_tags_all_records(hServer, nAlarmTagIDs, ALARM_TAG_NUM, &queryCond,

ALARM_REC_PROP_ALL, &hIter);

while (true)

{

nRet = ut_get_item_step(hIter, &alarmRecord);

if (RD_SUCCESS == nRet)

{

printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query tags all records complete\n");

nRet = RD_SUCCESS;

break;

}

else

{

printf("query tags all records failed, error code [%d]\n", nRet);

}

}

ut_free_iterator(hIter);

//query group alarm records

nRet = am_query_group_records(hServer, 0, &queryCond, ALARM_REC_PROP_ALL, &hIter);

while (true)

{

nRet = ut_get_item_step(hIter, &alarmRecord);

if (RD_SUCCESS == nRet)

{

printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group all records complete\n");

nRet = RD_SUCCESS;

break;

}

else

{

printf("query group records failed, error code [%d]\n", nRet);

}

}

ut_free_iterator(hIter);

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

am_acknowledge_alarm

am_query_snapshots

am_register_alarm_record_info

am_query_tag_records

am_query_tags_all_records

am_query_group_records

am_comment_alarms


am_query_tags_all_records

Navigation: »No topics above this level«

am_query_tags_all_records

 Return to chapter overview

am_query_tags_all_records

Glossary Item Box

函数

查询报警点的全部报警记录

int32 am_query_tags_all_records(

HDHANDLE hServer,

uint32 nTagIDs[],

int32 nTagNum,

const HDAlarmQuery* pQueryCond,

int64 nPropMask,

HDHANDLE* pHIter

);

参数

hServer

[in] 服务器句柄

nTagIDs[]

[in] 报警点ID数组

nTagNum

[in] 报警点数组个数

pQueryCond

[in] 查询条件

nPropMask

[in] 返回的报警记录的属性掩码

pHIter

[out] 报警记录迭代器句柄,查询的报警记录包括实时记录和历史记录

返回值

查询成功,返回RD_SUCCESS;查询失败返回其他错误码,见error.h

说明

举例

am_query_tags_all_records

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

#include <windows.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

AlarmTagProp alarmTag;

int32 nRecNum = 3;

const int32 ALARM_TAG_NUM = 3;

uint32 nAlarmTagIDs[ALARM_TAG_NUM];

HDAlarmQuery queryCond;

HDRecord snapshot;

HDHANDLE hIter = NULL;

HDAlarmRecord alarmRecord;

HDAlarmRecord snAlarms[ALARM_TAG_NUM];

int32 nErrorCodes[ALARM_TAG_NUM];

HDTime alarmTimes[ALARM_TAG_NUM];

int32 i = 0;

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

return -1;

}

// add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

//add alarm tag

strcpy(alarmTag.szSourceTagName, normalTag.szTagName);

strcpy(alarmTag.szTest1, "GT(34)");

strcpy(alarmTag.szAction1, "1_hihi_ack");

strcpy(alarmTag.szTest2, "LT(34)");

strcpy(alarmTag.szAction2, "2_lolo_unack");

alarmTag.nAutoAck = ALARM_AUTO_ACK_NO;

for (i = 0; i < ALARM_TAG_NUM; i ++)

{

sprintf(alarmTag.szTagName, "alarmTag_%d", i);

nRet = am_add_tag(hServer, &alarmTag, TAG_PROP_TAG_NAME|TAG_PROP_SOURCE_TAG

|TAG_PROP_TEST1|TAG_PROP_ACTION1|TAG_PROP_TEST2|TAG_PROP_ACTION2

| TAG_PROP_AUTOACK);

if (nRet != RD_SUCCESS)

{

printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add alarm tag[%s] successful!\n", normalTag.szTagName);

nRet = am_query_tagid(hServer, alarmTag.szTagName, nAlarmTagIDs + i );

if (nRet != RD_SUCCESS)

{

printf("query alarm tag[%s] id failed, error code [%d]!\n", alarmTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("query alarm tag[%s] id successful!\n", normalTag.szTagName);

}

//save snapshots generate alarms

for (i = 0; i < nRecNum; i++)

{

snapshot.nSec = i + 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

if (0 == i % 2)

{

snapshot.value.nInt32 = 0;

}

else

{

snapshot.value.nInt32 = 66;

}

nRet = sn_save_snapshot(hServer, normalTag.nTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

printf("save snapshot failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("save snapshot successful!\n");

}

Sleep(3000);

//query alarm snapshot

nRet = am_query_snapshots(hServer, ALARM_TAG_NUM, nAlarmTagIDs,

ALARM_REC_PROP_ALL, snAlarms, nErrorCodes);

if (RD_SUCCESS == nRet)

{

printf("query alarm snapshots successful!\n");

}

else if (EC_HD_API_AM_QUERY_SNAPSHOTS_FAILED == nRet)

{

for (i = 0; i < ALARM_TAG_NUM; i ++)

{

if (nErrorCodes[i] != RD_SUCCESS)

{

printf("query alarm tag[%d] snapshot failed, error code [%d]!\n", nAlarmTagIDs[i], nErrorCodes[i]);

}

}

}

else

{

printf("query alarm snapshots failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

//ack alarms

for (i = 0; i < nRecNum; i++)

{

alarmTimes[i].nSec = snAlarms[i].tvStartTime.nSec;

alarmTimes[i].nMsec = snAlarms[i].tvStartTime.nMsec;

}

nRet = am_acknowledge_alarms(hServer, nAlarmTagIDs, alarmTimes, ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

printf("acknowledge alarms failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("acknowledge alarms successful!\n");

//comment alarms

nRet = am_comment_alarms(hServer, nAlarmTagIDs, alarmTimes, "this is a comment", ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

printf("comment alarms failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("comment alarms successful!\n");

//query tag alarm records

queryCond.tvStart.nSec = 1;

queryCond.tvStart.nMsec = 0;

queryCond.tvEnd.nMsec =0;

queryCond.tvEnd.nSec =100;

queryCond.nAckMask = (int8)MASK_ALARM_ALL;

queryCond.nPriorMask = (int8)MASK_ALARM_ALL;

queryCond.nTypeMask = (int8)MASK_ALARM_ALL;

queryCond.nCommentMask = (int8)MASK_ALARM_ALL;

queryCond.nRestoreMask = (int8)MASK_ALARM_ALL;

nRet = am_query_tag_records(hServer, nAlarmTagIDs[0], &queryCond, ALARM_REC_PROP_ALL, &hIter);

while (true)

{

nRet = ut_get_item_step(hIter, &alarmRecord);

if (RD_SUCCESS == nRet)

{

printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query tags records complete\n");

nRet = RD_SUCCESS;

break;

}

else

{

printf("query tags all records failed, error code [%d]\n", nRet);

}

}

ut_free_iterator(hIter);

//query tags all alarm records include am snapshots

nRet = am_query_tags_all_records(hServer, nAlarmTagIDs, ALARM_TAG_NUM, &queryCond,

ALARM_REC_PROP_ALL, &hIter);

while (true)

{

nRet = ut_get_item_step(hIter, &alarmRecord);

if (RD_SUCCESS == nRet)

{

printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query tags all records complete\n");

nRet = RD_SUCCESS;

break;

}

else

{

printf("query tags all records failed, error code [%d]\n", nRet);

}

}

ut_free_iterator(hIter);

//query group alarm records

nRet = am_query_group_records(hServer, 0, &queryCond, ALARM_REC_PROP_ALL, &hIter);

while (true)

{

nRet = ut_get_item_step(hIter, &alarmRecord);

if (RD_SUCCESS == nRet)

{

printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group all records complete\n");

nRet = RD_SUCCESS;

break;

}

else

{

printf("query group records failed, error code [%d]\n", nRet);

}

}

ut_free_iterator(hIter);

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

am_acknowledge_alarm

am_query_snapshots

am_register_alarm_record_info

am_query_tag_records

am_query_tags_all_records

am_query_group_records

am_comment_alarms


am_query_tags_cond

Navigation: »No topics above this level«

am_query_tags_cond

 Return to chapter overview

am_query_tags_cond

Glossary Item Box

函数

在一台服务器中通过查询条件查询满足条件的报警点

int32 am_query_tags_cond(

HDHANDLE hServer,

QueryTagPropItem pQueryItems[],

int32 nQueryItemNum,

int64 nPropMask,

HDHANDLE* pHIter

);

参数

hServer

[in] 服务器句柄。

pQueryItems

[in] 查询条件数组。

nQueryItemNum

[in] 查询条件个数。

nPropMask

[in] 返回报警点掩码，表明返回哪些报警点的属性。

pHIter

[out] 查询迭代器。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

说明

调用该接口成功后会获得一个查询迭代器的句柄，然后调用ut_get_item_step接口，传入迭代器句柄和分配的空间(AlarmTagProp*)，返回RD_SUCCESS就可以获得第一个报警点的属性，再调用ut_get_item_step返回RD_SUCCESS就可以获得第二个报警点的属性。如此循环的查询直到调用ut_get_item_step返回错误码为EC_HD_API_QUERY_END表明所有的报警点的ID都查询完毕了。查询完毕后调用ut_free_iterator方法来释放迭代器。

Type your Drop Down Section text here.

举例

am_query_tags_cond

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

AlarmTagProp alarmTagSave;

AlarmTagProp alarmTagQuery;

const char* szTagName_1 = "szAlarmTagName_1";

const char* szTagName_2 = "szAlarmTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  normalTag.szTagName, normalTag.nTagID);

//add two alarm tag

strcpy(alarmTagSave.szTagName, szTagName_1);

strcpy(alarmTagSave.szSourceTagName, normalTag.szTagName);

strcpy(alarmTagSave.szTest1, "GT(100)");

strcpy(alarmTagSave.szAction1, "1_hihi_unack");

nRet = am_add_tag(hServer, &alarmTagSave, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

 | TAG_PROP_TEST1 | TAG_PROP_ACTION1);

if (nRet != RD_SUCCESS)

{

 printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add alarm tag[%s] successful!\n", alarmTagSave.szTagName);

strcpy(alarmTagSave.szTagName, szTagName_2);

strcpy(alarmTagSave.szSourceTagName, normalTag.szTagName);

strcpy(alarmTagSave.szTest1, "LT(10)");

strcpy(alarmTagSave.szAction1, "2_lolo_unack");

nRet = am_add_tag(hServer, &alarmTagSave, TAG_PROP_TAG_NAME | TAG_PROP_SOURCE_TAG

 | TAG_PROP_TEST1 | TAG_PROP_ACTION1);

if (nRet != RD_SUCCESS)

{

 printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add alarm tag[%s] successful!\n", alarmTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_DIGITAL);

nRet = am_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query calc tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &alarmTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query alarm tag successful, tag name is %s!\n", alarmTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query alarm tag complete!\n");

  break;

 }

 else

 {

  printf("query alarm tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you queried %d alarm tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = am_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query alarm tag id failed,  alarm tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  szTagName_1, nTagID);

//modify tag desc

strcpy(alarmTagSave.szDescriptor, "alarm tag descriptor is modified");

nRet = am_modify_tag_prop(hServer, nTagID, &alarmTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify alarm tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = am_query_tag_prop(hServer, nTagID, &alarmTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query alarm tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query alarm tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 alarmTagQuery.nTagID, alarmTagQuery.szTagName, alarmTagQuery.szDescriptor);

//delete tag

nRet = am_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete alarm tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参见：

am_add_tag

am_delete_tag

am_modify_tag_prop

am_query_tag_names

am_query_tag_prop

am_query_tagid

am_query_tags_cond


am_register_alarm_record_info

Navigation: »No topics above this level«

am_register_alarm_record_info

 Return to chapter overview

am_register_alarm_record_info

Glossary Item Box

函数

向一台服务器中注册实时报警记录通知，每当服务器有新的报警记录产生时，用户传入的回调函数就会被调用。

int32 am_register_alarm_record_info(

HDHANDLE hServer,

void (*pFunc)(HDHANDLE hServer, uint32 nTagID, const HDAlarmRecord* pRecord)

);

参数

hServer

[in] 服务器句柄。

pFunc

[in] 报警记录回调函数，回调函数的参数分别为服务器句柄、报警点ID、服务器发送过来的报警记录。

返回值

注册成功，返回RD_SUCCESS。注册失败返回其它错误码，见error_code.h。

说明

回调函数可以为NULL

在回调函数中不能调用其它的iHyperDB的API。

举例

am_register_alarm_record_info

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

#include <windows.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

AlarmTagProp alarmTag;

int32 nRecNum = 3;

const int32 ALARM_TAG_NUM = 3;

uint32 nAlarmTagIDs[ALARM_TAG_NUM];

HDAlarmQuery queryCond;

HDRecord snapshot;

HDHANDLE hIter = NULL;

HDAlarmRecord alarmRecord;

HDAlarmRecord snAlarms[ALARM_TAG_NUM];

int32 nErrorCodes[ALARM_TAG_NUM];

HDTime alarmTimes[ALARM_TAG_NUM];

int32 i = 0;

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 return -1;

}

// add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

//add alarm tag

strcpy(alarmTag.szSourceTagName, normalTag.szTagName);

strcpy(alarmTag.szTest1, "GT(34)");

strcpy(alarmTag.szAction1, "1_hihi_ack");

strcpy(alarmTag.szTest2, "LT(34)");

strcpy(alarmTag.szAction2, "2_lolo_unack");

alarmTag.nAutoAck = ALARM_AUTO_ACK_NO;

for (i = 0; i < ALARM_TAG_NUM; i ++)

{

 sprintf(alarmTag.szTagName, "alarmTag_%d", i);

 nRet = am_add_tag(hServer, &alarmTag,  TAG_PROP_TAG_NAME|TAG_PROP_SOURCE_TAG

  |TAG_PROP_TEST1|TAG_PROP_ACTION1|TAG_PROP_TEST2|TAG_PROP_ACTION2

  | TAG_PROP_AUTOACK);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm tag[%s] failed, error code [%d]!\n", alarmTag.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm tag[%s] successful!\n", normalTag.szTagName);

 nRet = am_query_tagid(hServer, alarmTag.szTagName, nAlarmTagIDs + i );

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm tag[%s] id failed, error code [%d]!\n", alarmTag.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm tag[%s] id successful!\n", normalTag.szTagName);

}

//save snapshots generate alarms

for (i = 0; i < nRecNum; i++)

{

 snapshot.nSec =  i + 1;

 snapshot.nMsec = 0;

 snapshot.nQuality = 192;

 if (0 == i % 2)

 {

  snapshot.value.nInt32 = 0;

 }

 else

 {

  snapshot.value.nInt32 = 66;

 }

 nRet = sn_save_snapshot(hServer, normalTag.nTagID, &snapshot);

 if (nRet != RD_SUCCESS)

 {

  printf("save snapshot failed, error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("save snapshot successful!\n");

}

Sleep(3000);

//query alarm snapshot

nRet = am_query_snapshots(hServer, ALARM_TAG_NUM, nAlarmTagIDs,

 ALARM_REC_PROP_ALL, snAlarms, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query alarm snapshots successful!\n");

}

else if (EC_HD_API_AM_QUERY_SNAPSHOTS_FAILED == nRet)

{

 for (i = 0; i < ALARM_TAG_NUM; i ++)

 {

  if (nErrorCodes[i] != RD_SUCCESS)

  {

   printf("query alarm tag[%d] snapshot failed, error code [%d]!\n", nAlarmTagIDs[i], nErrorCodes[i]);

  }

 }

}

else

{

 printf("query alarm snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//ack alarms

for (i = 0; i < nRecNum; i++)

{

 alarmTimes[i].nSec = snAlarms[i].tvStartTime.nSec;

 alarmTimes[i].nMsec = snAlarms[i].tvStartTime.nMsec;

}

nRet = am_acknowledge_alarms(hServer, nAlarmTagIDs, alarmTimes,  ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("acknowledge alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("acknowledge alarms successful!\n");

//comment alarms

nRet = am_comment_alarms(hServer, nAlarmTagIDs, alarmTimes, "this is a comment", ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("comment alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("comment alarms successful!\n");

//query tag alarm records

queryCond.tvStart.nSec = 1;

queryCond.tvStart.nMsec = 0;

queryCond.tvEnd.nMsec =0;

queryCond.tvEnd.nSec =100;

queryCond.nAckMask = (int8)MASK_ALARM_ALL;

queryCond.nPriorMask = (int8)MASK_ALARM_ALL;

queryCond.nTypeMask = (int8)MASK_ALARM_ALL;

queryCond.nCommentMask = (int8)MASK_ALARM_ALL;

queryCond.nRestoreMask = (int8)MASK_ALARM_ALL;

nRet = am_query_tag_records(hServer, nAlarmTagIDs[0], &queryCond, ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &alarmRecord);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

   alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags all records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query tags all alarm records include am snapshots

nRet = am_query_tags_all_records(hServer, nAlarmTagIDs, ALARM_TAG_NUM, &queryCond,

 ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &alarmRecord);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

   alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags all records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query group alarm records

nRet = am_query_group_records(hServer, 0, &queryCond, ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &alarmRecord);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", alarmRecord.nAlarmTagID,

   alarmRecord.tvStartTime.nSec, alarmRecord.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query group records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

am_acknowledge_alarm

am_query_snapshots

am_register_alarm_record_info

am_query_tag_records

am_query_tags_all_records

am_query_group_records

am_comment_alarms


API接口

Navigation: »No topics above this level«

API接口

 Return to chapter overview

API接口

Glossary Item Box

API(Application Program Interface)应用程序接口是一组定义、程序与协议的集合，通过API接口实现计算机软件之间的相互通信。API的一个主要功能就是提供通用功能集。程序员通过使用API函数开发应用程序，从而可以避免编写无用程序，以减轻编程任务。iHyperDB提供独立API安装程序给二次开发人员使用。


ar_delete_record

Navigation: »No topics above this level«

ar_delete_record

 Return to chapter overview

ar_delete_record

Glossary Item Box

函数

删除一条存储记录

int32 ar_delete_record(

HDHANDLE hServer,

uint32 nTagID,

const HDTime* pTime

);

参数

hServer

[in] 服务器句柄。

nTagID

[in] TagID。

pTime

[in] 被删除的记录的时间戳。

返回值

删除成功，返回RD_SUCCESS。删除失败返回错误码，见error_code.h。

说明

该接口用来删除一个普通点在某一个时刻的原始记录，一旦记录被删除就无法恢复。

举例

ar_delete_record

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName = "szTagName";

int32 nRecNum = 3;

HDRecord records[3];

uint32 nTagIDs[3];

int32 nErrorCodes[3];

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add tag

strcpy(tag.szTagName, szTagName);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag id

nRet = pt_query_tagid(hServer, tag.szTagName, &tag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",   tag.szTagName,tag.nTagID);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

 nTagIDs[i] = tag.nTagID;

 records[i].nSec = 1 + i;

 records[i].nMsec = 0;

 records[i].nQuality = 192;

 records[i].value.nInt32 = records[i].nSec;

}

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, records, nErrorCodes);

if (nRet != RD_SUCCESS)

{

 printf("save snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

return -1;

}

//query raw recs num

HDTime startTime;

HDTime endTime;

int32 nRecNumQueried;

startTime.nSec = 1;

startTime.nMsec = 0;

endTime.nSec = 36000;

endTime.nMsec = 0;

nRet = ar_query_raw_records_number(hServer,tag.nTagID, &startTime, &endTime, &nRecNumQueried);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query raw records number failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query raw records number successful, nRecNum is %d in time area [%d s : %d ms] to  [%d s : %d ms] !\n",

 tag.nTagID, nRecNumQueried,  startTime.nSec, startTime.nMsec, endTime.nSec, endTime.nMsec );

//query raw recs

HDRecord recordsQueried[2];

nRecNumQueried = 2;

do

{

 nRet = ar_query_raw_records(hServer, nTagIDs[0], &startTime, &endTime, &nRecNumQueried, recordsQueried);

if (nRet != RD_SUCCESS)

 {

  printf("tag [id:%d] query raw records failed, error code[%d]!\n", tag.nTagID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

for (i = 0; i < nRecNumQueried; i ++)

 {

  printf("tag [id:%d] record time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

//reset end time

if (2 == nRecNumQueried)

 {

  endTime.nSec = recordsQueried[1].nSec;

  endTime.nMsec = recordsQueried[1].nMsec;

  if ( 0 == endTime.nMsec )

  {

   endTime.nSec --;

   endTime.nMsec = 999;

  }

  else

  {

   endTime.nMsec --;

  }

 }

} while (2 == nRecNumQueried);

//query specify number records

startTime.nSec = 100;

startTime.nMsec = 0;

nRecNumQueried = 2;

nRet = ar_query_specify_num_raw_recs(hServer, tag.nTagID, &startTime, true, &nRecNumQueried, recordsQueried);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query 2 records from time [%d s : %d ms] to the earlier time failed, error code[%d]!\n",

  tag.nTagID, startTime.nSec, startTime.nMsec, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query 2 records from time [%d s : %d ms] to the earlier time successful!\n",

 tag.nTagID, startTime.nSec, startTime.nMsec);

for (i = 0; i < 2; i ++)

{

 printf("tag [id:%d] raw record time [%d s : %d ms], quality [%d], value [%d]!\n",

  tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

  recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

}

//modify record

recordsQueried[0].value.nInt32 = 999;

nRet = ar_modify_record(hServer, tag.nTagID, &recordsQueried[0]);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] modify record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] modify record successful!\n", tag.nTagID);

//delete record

HDTime hdTime;

hdTime.nSec = recordsQueried[0].nSec;

hdTime.nMsec = recordsQueried[0].nMsec;

nRet = ar_delete_record(hServer, tag.nTagID, &hdTime);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] delete record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] delete record successful!\n", tag.nTagID);

//query one linear interpolate rec

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 500;

nRet = ar_query_interp_record(hServer, tag.nTagID, &(recordsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

 tag.nTagID, recordsQueried[0].nSec, recordsQueried[0].nMsec,

 recordsQueried[0].nQuality, recordsQueried[0].value.nInt32);

//query linear interpolate records

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 300;

recordsQueried[1].nSec = 1;

recordsQueried[1].nMsec = 800;

nRet = ar_query_interp_records(hServer, tag.nTagID, 2, recordsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query tag [id:%d] interpolate records successful\n", tag.nTagID);

for (i = 0; i < 2; i ++)

 {

  printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

}

else if (EC_HD_API_QUERY_INTERP_REC_FAILED == nRet)

{

for (i = 0; i < 2; i ++)

 {

  if (RD_SUCCESS == nErrorCodes[i])

  {

   printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

    tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

    recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

  }

  else

  {

   printf("tag [id:%d] query interpolate record failed, error code [%d], record time [%d s : %d ms]!\n",

    tag.nTagID, nErrorCodes[i], recordsQueried[i].nSec, recordsQueried[i].nMsec);

  }

 }

}

else

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

//query one interpolate rec by mode

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 500;

nRet = ar_query_interp_record_by_mode(hServer, HD_REC_INTERP_QUERY_MODE_LINEAR, tag.nTagID, &(recordsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query interpolate record by mode failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query interpolate record by mode successful, time [%d s : %d ms], quality [%d], value [%d]!\n",

 tag.nTagID, recordsQueried[0].nSec, recordsQueried[0].nMsec,

 recordsQueried[0].nQuality, recordsQueried[0].value.nInt32);

//query interpolate records

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 300;

recordsQueried[1].nSec = 1;

recordsQueried[1].nMsec = 800;

nRet = ar_query_interp_records_by_mode(hServer, HD_REC_INTERP_QUERY_MODE_PREV, tag.nTagID, 2, recordsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query tag [id:%d] interpolate records by mode successful\n", tag.nTagID);

for (i = 0; i < 2; i ++)

 {

  printf("tag [id:%d] query interpolate records by mode successful,  time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

}

else if (EC_HD_API_QUERY_INTERP_REC_FAILED == nRet)

{

for (i = 0; i < 2; i ++)

 {

  if (RD_SUCCESS == nErrorCodes[i])

  {

   printf("tag [id:%d] query interpolate record time by mode [%d s : %d ms], quality [%d], value [%d]!\n",

    tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

    recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

  }

  else

  {

   printf("tag [id:%d] query interpolate record failed, error code [%d], record time [%d s : %d ms]!\n",

    tag.nTagID, nErrorCodes[i], recordsQueried[i].nSec, recordsQueried[i].nMsec);

  }

 }

}

else

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

ar_delete_record

ar modify record

ar_query_interp_record

ar_query_interp_records

ar_query_raw_records

ar_query_raw_records_number

ar_query_specify_num_raw_recs

ar_query_interp_record_by_mode

ar_query_interp_records_by_mode


归档数据接口

Navigation: »No topics above this level«

归档数据接口

 Return to chapter overview

归档数据接口

Glossary Item Box

《归档数据接口》的主要内容包：

?ar_delete_record

?ar_modify_record

?ar_query_interp_record

?ar_query_interp_records

?ar_query_raw_records

?ar_query_raw_records_number

?ar_query_specify_num_raw_recs

©2015. All Rights Reserved.


ar_modify_record

Navigation: »No topics above this level«

ar_modify_record

 Return to chapter overview

ar_modify_record

Glossary Item Box

函数

修改一条记录的值

int32 ar_modify_record(

HDHANDLE hServer,

uint32 nTagID,

HDRecord *pRecord

);

参数

hServer

[in] 服务器句柄。

nTagID

[in] TagID。

pRecord

[in] 被修改的记录。

返回值

修改成功，返回RD_SUCCESS。修改失败返回错误码，见error_code.h。

说明

调用该接口可以修改一个普通点在某个时间上的一条归档记录，一旦修改成功原来的归档记录无法恢复。

举例

ar_modify_record

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName = "szTagName";

int32 nRecNum = 3;

HDRecord records[3];

uint32 nTagIDs[3];

int32 nErrorCodes[3];

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add tag

strcpy(tag.szTagName, szTagName);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag id

nRet = pt_query_tagid(hServer, tag.szTagName, &tag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",   tag.szTagName,tag.nTagID);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

 nTagIDs[i] = tag.nTagID;

 records[i].nSec = 1 + i;

 records[i].nMsec = 0;

 records[i].nQuality = 192;

 records[i].value.nInt32 = records[i].nSec;

}

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, records, nErrorCodes);

if (nRet != RD_SUCCESS)

{

 printf("save snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

return -1;

}

//query raw recs num

HDTime startTime;

HDTime endTime;

int32 nRecNumQueried;

startTime.nSec = 1;

startTime.nMsec = 0;

endTime.nSec = 36000;

endTime.nMsec = 0;

nRet = ar_query_raw_records_number(hServer,tag.nTagID, &startTime, &endTime, &nRecNumQueried);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query raw records number failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query raw records number successful, nRecNum is %d in time area [%d s : %d ms] to  [%d s : %d ms] !\n",

 tag.nTagID, nRecNumQueried,  startTime.nSec, startTime.nMsec, endTime.nSec, endTime.nMsec );

//query raw recs

HDRecord recordsQueried[2];

nRecNumQueried = 2;

do

{

 nRet = ar_query_raw_records(hServer, nTagIDs[0], &startTime, &endTime, &nRecNumQueried, recordsQueried);

if (nRet != RD_SUCCESS)

 {

  printf("tag [id:%d] query raw records failed, error code[%d]!\n", tag.nTagID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

for (i = 0; i < nRecNumQueried; i ++)

 {

  printf("tag [id:%d] record time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

//reset end time

if (2 == nRecNumQueried)

 {

  endTime.nSec = recordsQueried[1].nSec;

  endTime.nMsec = recordsQueried[1].nMsec;

  if ( 0 == endTime.nMsec )

  {

   endTime.nSec --;

   endTime.nMsec = 999;

  }

  else

  {

   endTime.nMsec --;

  }

 }

} while (2 == nRecNumQueried);

//query specify number records

startTime.nSec = 100;

startTime.nMsec = 0;

nRecNumQueried = 2;

nRet = ar_query_specify_num_raw_recs(hServer, tag.nTagID, &startTime, true, &nRecNumQueried, recordsQueried);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query 2 records from time [%d s : %d ms] to the earlier time failed, error code[%d]!\n",

  tag.nTagID, startTime.nSec, startTime.nMsec, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query 2 records from time [%d s : %d ms] to the earlier time successful!\n",

 tag.nTagID, startTime.nSec, startTime.nMsec);

for (i = 0; i < 2; i ++)

{

 printf("tag [id:%d] raw record time [%d s : %d ms], quality [%d], value [%d]!\n",

  tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

  recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

}

//modify record

recordsQueried[0].value.nInt32 = 999;

nRet = ar_modify_record(hServer, tag.nTagID, &recordsQueried[0]);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] modify record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] modify record successful!\n", tag.nTagID);

//delete record

HDTime hdTime;

hdTime.nSec = recordsQueried[0].nSec;

hdTime.nMsec = recordsQueried[0].nMsec;

nRet = ar_delete_record(hServer, tag.nTagID, &hdTime);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] delete record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] delete record successful!\n", tag.nTagID);

//query one linear interpolate rec

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 500;

nRet = ar_query_interp_record(hServer, tag.nTagID, &(recordsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

 tag.nTagID, recordsQueried[0].nSec, recordsQueried[0].nMsec,

 recordsQueried[0].nQuality, recordsQueried[0].value.nInt32);

//query linear interpolate records

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 300;

recordsQueried[1].nSec = 1;

recordsQueried[1].nMsec = 800;

nRet = ar_query_interp_records(hServer, tag.nTagID, 2, recordsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query tag [id:%d] interpolate records successful\n", tag.nTagID);

for (i = 0; i < 2; i ++)

 {

  printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

}

else if (EC_HD_API_QUERY_INTERP_REC_FAILED == nRet)

{

for (i = 0; i < 2; i ++)

 {

  if (RD_SUCCESS == nErrorCodes[i])

  {

   printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

    tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

    recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

  }

  else

  {

   printf("tag [id:%d] query interpolate record failed, error code [%d], record time [%d s : %d ms]!\n",

    tag.nTagID, nErrorCodes[i], recordsQueried[i].nSec, recordsQueried[i].nMsec);

  }

 }

}

else

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

//query one interpolate rec by mode

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 500;

nRet = ar_query_interp_record_by_mode(hServer, HD_REC_INTERP_QUERY_MODE_LINEAR, tag.nTagID, &(recordsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query interpolate record by mode failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query interpolate record by mode successful, time [%d s : %d ms], quality [%d], value [%d]!\n",

 tag.nTagID, recordsQueried[0].nSec, recordsQueried[0].nMsec,

 recordsQueried[0].nQuality, recordsQueried[0].value.nInt32);

//query interpolate records

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 300;

recordsQueried[1].nSec = 1;

recordsQueried[1].nMsec = 800;

nRet = ar_query_interp_records_by_mode(hServer, HD_REC_INTERP_QUERY_MODE_PREV, tag.nTagID, 2, recordsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query tag [id:%d] interpolate records by mode successful\n", tag.nTagID);

for (i = 0; i < 2; i ++)

 {

  printf("tag [id:%d] query interpolate records by mode successful,  time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

}

else if (EC_HD_API_QUERY_INTERP_REC_FAILED == nRet)

{

for (i = 0; i < 2; i ++)

 {

  if (RD_SUCCESS == nErrorCodes[i])

  {

   printf("tag [id:%d] query interpolate record time by mode [%d s : %d ms], quality [%d], value [%d]!\n",

    tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

    recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

  }

  else

  {

   printf("tag [id:%d] query interpolate record failed, error code [%d], record time [%d s : %d ms]!\n",

    tag.nTagID, nErrorCodes[i], recordsQueried[i].nSec, recordsQueried[i].nMsec);

  }

 }

}

else

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

ar_delete_record

ar_modify_record

ar_query_interp_record

ar_query_interp_records

ar_query_raw_records

ar_query_raw_records_number

ar_query_specify_num_raw_recs

ar_query_interp_record_by_mode

ar_query_interp_records_by_mode


ar_query_interp_record

Navigation: »No topics above this level«

ar_query_interp_record

 Return to chapter overview

ar_query_interp_record

Glossary Item Box

函数

查询某一个普通点在某一时刻的插值记录

int32 ar_query_interp_record(

HDHANDLE hServer,

uint32 nTagID,

HDRecord* pRecord

);

参数

hServer:

[in] 服务器句柄。

nTagID

[in] TagID。

pRecord

[in,out]in：插值时间戳，out：插值记录的值。

返回值

查询成功返回RD_SUCCESS，查询失败返回错误码，见error_code.h。

说明

iHyperDB的8种数据类型都支持插值查询。

插值时，选定的插值时刻，需要前后都有好的原始记录，方可插值，此外如果插值时间点正好等于原始记录的时间戳，则此数据也能插值得到；

如果是最后一个点，那么在大于最后这点的时间戳的时刻进行插值是无法得到数据记录的，因为此时后面的原始数据时没有的，

原理类似于

线性函数两个点之间的插值，如果中间那个店（即插值点）的后一个点还没有原始数据，那么，这个点做插值，就无法插值成功。。

对于普通点而言，如果要获取某一秒的数据，一般插值会使用这一秒的999毫秒来进行插值。比如实际存储的两条记录时间戳为1'1ms, 2'1ms，如果用户想要获取2'时的数据，那么传进来进行插值的时间戳使用2'999ms，则基本上2'的数据都能被插值得到（在999ms之前的点都可以通过前点插值得到），因此一般建议插值时ms取为999ms。

举例

ar_query_interp_record

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName = "szTagName";

int32 nRecNum = 3;

HDRecord records[3];

uint32 nTagIDs[3];

int32 nErrorCodes[3];

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add tag

strcpy(tag.szTagName, szTagName);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag id

nRet = pt_query_tagid(hServer, tag.szTagName, &tag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",   tag.szTagName,tag.nTagID);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

 nTagIDs[i] = tag.nTagID;

 records[i].nSec = 1 + i;

 records[i].nMsec = 0;

 records[i].nQuality = 192;

 records[i].value.nInt32 = records[i].nSec;

}

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, records, nErrorCodes);

if (nRet != RD_SUCCESS)

{

 printf("save snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

return -1;

}

//query raw recs num

HDTime startTime;

HDTime endTime;

int32 nRecNumQueried;

startTime.nSec = 1;

startTime.nMsec = 0;

endTime.nSec = 36000;

endTime.nMsec = 0;

nRet = ar_query_raw_records_number(hServer,tag.nTagID, &startTime, &endTime, &nRecNumQueried);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query raw records number failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query raw records number successful, nRecNum is %d in time area [%d s : %d ms] to  [%d s : %d ms] !\n",

 tag.nTagID, nRecNumQueried,  startTime.nSec, startTime.nMsec, endTime.nSec, endTime.nMsec );

//query raw recs

HDRecord recordsQueried[2];

nRecNumQueried = 2;

do

{

 nRet = ar_query_raw_records(hServer, nTagIDs[0], &startTime, &endTime, &nRecNumQueried, recordsQueried);

if (nRet != RD_SUCCESS)

 {

  printf("tag [id:%d] query raw records failed, error code[%d]!\n", tag.nTagID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

for (i = 0; i < nRecNumQueried; i ++)

 {

  printf("tag [id:%d] record time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

//reset end time

if (2 == nRecNumQueried)

 {

  endTime.nSec = recordsQueried[1].nSec;

  endTime.nMsec = recordsQueried[1].nMsec;

  if ( 0 == endTime.nMsec )

  {

   endTime.nSec --;

   endTime.nMsec = 999;

  }

  else

  {

   endTime.nMsec --;

  }

 }

} while (2 == nRecNumQueried);

//query specify number records

startTime.nSec = 100;

startTime.nMsec = 0;

nRecNumQueried = 2;

nRet = ar_query_specify_num_raw_recs(hServer, tag.nTagID, &startTime, true, &nRecNumQueried, recordsQueried);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query 2 records from time [%d s : %d ms] to the earlier time failed, error code[%d]!\n",

  tag.nTagID, startTime.nSec, startTime.nMsec, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query 2 records from time [%d s : %d ms] to the earlier time successful!\n",

 tag.nTagID, startTime.nSec, startTime.nMsec);

for (i = 0; i < 2; i ++)

{

 printf("tag [id:%d] raw record time [%d s : %d ms], quality [%d], value [%d]!\n",

  tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

  recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

}

//modify record

recordsQueried[0].value.nInt32 = 999;

nRet = ar_modify_record(hServer, tag.nTagID, &recordsQueried[0]);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] modify record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] modify record successful!\n", tag.nTagID);

//delete record

HDTime hdTime;

hdTime.nSec = recordsQueried[0].nSec;

hdTime.nMsec = recordsQueried[0].nMsec;

nRet = ar_delete_record(hServer, tag.nTagID, &hdTime);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] delete record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] delete record successful!\n", tag.nTagID);

//query one linear interpolate rec

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 500;

nRet = ar_query_interp_record(hServer, tag.nTagID, &(recordsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

 tag.nTagID, recordsQueried[0].nSec, recordsQueried[0].nMsec,

 recordsQueried[0].nQuality, recordsQueried[0].value.nInt32);

//query linear interpolate records

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 300;

recordsQueried[1].nSec = 1;

recordsQueried[1].nMsec = 800;

nRet = ar_query_interp_records(hServer, tag.nTagID, 2, recordsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query tag [id:%d] interpolate records successful\n", tag.nTagID);

for (i = 0; i < 2; i ++)

 {

  printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

}

else if (EC_HD_API_QUERY_INTERP_REC_FAILED == nRet)

{

for (i = 0; i < 2; i ++)

 {

  if (RD_SUCCESS == nErrorCodes[i])

  {

   printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

    tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

    recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

  }

  else

  {

   printf("tag [id:%d] query interpolate record failed, error code [%d], record time [%d s : %d ms]!\n",

    tag.nTagID, nErrorCodes[i], recordsQueried[i].nSec, recordsQueried[i].nMsec);

  }

 }

}

else

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

//query one interpolate rec by mode

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 500;

nRet = ar_query_interp_record_by_mode(hServer, HD_REC_INTERP_QUERY_MODE_LINEAR, tag.nTagID, &(recordsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query interpolate record by mode failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query interpolate record by mode successful, time [%d s : %d ms], quality [%d], value [%d]!\n",

 tag.nTagID, recordsQueried[0].nSec, recordsQueried[0].nMsec,

 recordsQueried[0].nQuality, recordsQueried[0].value.nInt32);

//query interpolate records

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 300;

recordsQueried[1].nSec = 1;

recordsQueried[1].nMsec = 800;

nRet = ar_query_interp_records_by_mode(hServer, HD_REC_INTERP_QUERY_MODE_PREV, tag.nTagID, 2, recordsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query tag [id:%d] interpolate records by mode successful\n", tag.nTagID);

for (i = 0; i < 2; i ++)

 {

  printf("tag [id:%d] query interpolate records by mode successful,  time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

}

else if (EC_HD_API_QUERY_INTERP_REC_FAILED == nRet)

{

for (i = 0; i < 2; i ++)

 {

  if (RD_SUCCESS == nErrorCodes[i])

  {

   printf("tag [id:%d] query interpolate record time by mode [%d s : %d ms], quality [%d], value [%d]!\n",

    tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

    recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

  }

  else

  {

   printf("tag [id:%d] query interpolate record failed, error code [%d], record time [%d s : %d ms]!\n",

    tag.nTagID, nErrorCodes[i], recordsQueried[i].nSec, recordsQueried[i].nMsec);

  }

 }

}

else

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

ar_delete_record

ar modify record

ar_query_interp_record

ar_query_interp_records

ar_query_raw_records

ar_query_raw_records_number

ar_query_specify_num_raw_recs

ar_query_interp_record_by_mode

ar_query_interp_records_by_mode


ar_query_interp_record_by_mode

Navigation: »No topics above this level«

ar_query_interp_record_by_mode

 Return to chapter overview

ar_query_interp_record_by_mode

Glossary Item Box

函数

根据插值类型的不同查询某一个普通点在某一时刻的插值记录

int32 ar_query_interp_record_by_mode(

HDHANDLE hServer,

uint8 nMode,

uint32 nTagID,

HDRecord* pRecord

)

参数

hServer:

[in] 服务器句柄。

nMode

[in]插值类型，值为1表示前向插值，即将某一个时刻之前最近的一条原始值作为改时刻的插值；值为0表示线性插值，即根据某一时刻之前的最近一条原始值和该时刻之后最近一条原始值来进行线性计算该时刻的插值。

nTagID

[in] TagID。

pRecord

[in,out]in：插值时间戳，out：插值记录的值。

返回值

查询成功返回RD_SUCCESS，查询失败返回错误码，见error_code.h。

说明

iHyperDB的8种数据类型都支持插值查询。

插值时，选定的插值时刻，需要前后都有好的原始记录，方可插值，此外如果插值时间点正好等于原始记录的时间戳，则此数据也能插值得到；

如果是最后一个点，那么在大于最后这点的时间戳的时刻进行插值是无法得到数据记录的，因为此时后面的原始数据时没有的，这种原理类似于

线性函数两个点之间的插值，如果中间那个店（即插值点）的后一个点还没有原始数据，那么，这个点做插值，就无法插值成功。

对于普通点，如果要获取某一秒的数据，一般插值会使用这一秒的999毫秒来进行插值。比如实际存储的两条记录时间戳为1'1ms, 2'1ms，如果用户想要获取2'时的数据，那么传进来进行插值的时间戳使用2'999ms，则基本上2'的数据都能被插值得到（在999ms之前的点都可以通过前点插值得到），因此一般建议插值时ms取为999ms。

举例

ar_query_interp_record_by_mode

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName = "szTagName";

int32 nRecNum = 3;

HDRecord records[3];

uint32 nTagIDs[3];

int32 nErrorCodes[3];

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add tag

strcpy(tag.szTagName, szTagName);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag id

nRet = pt_query_tagid(hServer, tag.szTagName, &tag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",   tag.szTagName,tag.nTagID);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

 nTagIDs[i] = tag.nTagID;

 records[i].nSec = 1 + i;

 records[i].nMsec = 0;

 records[i].nQuality = 192;

 records[i].value.nInt32 = records[i].nSec;

}

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, records, nErrorCodes);

if (nRet != RD_SUCCESS)

{

 printf("save snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

return -1;

}

//query raw recs num

HDTime startTime;

HDTime endTime;

int32 nRecNumQueried;

startTime.nSec = 1;

startTime.nMsec = 0;

endTime.nSec = 36000;

endTime.nMsec = 0;

nRet = ar_query_raw_records_number(hServer,tag.nTagID, &startTime, &endTime, &nRecNumQueried);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query raw records number failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query raw records number successful, nRecNum is %d in time area [%d s : %d ms] to  [%d s : %d ms] !\n",

 tag.nTagID, nRecNumQueried,  startTime.nSec, startTime.nMsec, endTime.nSec, endTime.nMsec );

//query raw recs

HDRecord recordsQueried[2];

nRecNumQueried = 2;

do

{

 nRet = ar_query_raw_records(hServer, nTagIDs[0], &startTime, &endTime, &nRecNumQueried, recordsQueried);

if (nRet != RD_SUCCESS)

 {

  printf("tag [id:%d] query raw records failed, error code[%d]!\n", tag.nTagID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

for (i = 0; i < nRecNumQueried; i ++)

 {

  printf("tag [id:%d] record time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

//reset end time

if (2 == nRecNumQueried)

 {

  endTime.nSec = recordsQueried[1].nSec;

  endTime.nMsec = recordsQueried[1].nMsec;

  if ( 0 == endTime.nMsec )

  {

   endTime.nSec --;

   endTime.nMsec = 999;

  }

  else

  {

   endTime.nMsec --;

  }

 }

} while (2 == nRecNumQueried);

//query specify number records

startTime.nSec = 100;

startTime.nMsec = 0;

nRecNumQueried = 2;

nRet = ar_query_specify_num_raw_recs(hServer, tag.nTagID, &startTime, true, &nRecNumQueried, recordsQueried);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query 2 records from time [%d s : %d ms] to the earlier time failed, error code[%d]!\n",

  tag.nTagID, startTime.nSec, startTime.nMsec, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query 2 records from time [%d s : %d ms] to the earlier time successful!\n",

 tag.nTagID, startTime.nSec, startTime.nMsec);

for (i = 0; i < 2; i ++)

{

 printf("tag [id:%d] raw record time [%d s : %d ms], quality [%d], value [%d]!\n",

  tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

  recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

}

//modify record

recordsQueried[0].value.nInt32 = 999;

nRet = ar_modify_record(hServer, tag.nTagID, &recordsQueried[0]);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] modify record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] modify record successful!\n", tag.nTagID);

//delete record

HDTime hdTime;

hdTime.nSec = recordsQueried[0].nSec;

hdTime.nMsec = recordsQueried[0].nMsec;

nRet = ar_delete_record(hServer, tag.nTagID, &hdTime);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] delete record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] delete record successful!\n", tag.nTagID);

//query one linear interpolate rec

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 500;

nRet = ar_query_interp_record(hServer, tag.nTagID, &(recordsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

 tag.nTagID, recordsQueried[0].nSec, recordsQueried[0].nMsec,

 recordsQueried[0].nQuality, recordsQueried[0].value.nInt32);

//query linear interpolate records

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 300;

recordsQueried[1].nSec = 1;

recordsQueried[1].nMsec = 800;

nRet = ar_query_interp_records(hServer, tag.nTagID, 2, recordsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query tag [id:%d] interpolate records successful\n", tag.nTagID);

for (i = 0; i < 2; i ++)

 {

  printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

}

else if (EC_HD_API_QUERY_INTERP_REC_FAILED == nRet)

{

for (i = 0; i < 2; i ++)

 {

  if (RD_SUCCESS == nErrorCodes[i])

  {

   printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

    tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

    recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

  }

  else

  {

   printf("tag [id:%d] query interpolate record failed, error code [%d], record time [%d s : %d ms]!\n",

    tag.nTagID, nErrorCodes[i], recordsQueried[i].nSec, recordsQueried[i].nMsec);

  }

 }

}

else

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

//query one interpolate rec by mode

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 500;

nRet = ar_query_interp_record_by_mode(hServer, HD_REC_INTERP_QUERY_MODE_LINEAR, tag.nTagID, &(recordsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query interpolate record by mode failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query interpolate record by mode successful, time [%d s : %d ms], quality [%d], value [%d]!\n",

 tag.nTagID, recordsQueried[0].nSec, recordsQueried[0].nMsec,

 recordsQueried[0].nQuality, recordsQueried[0].value.nInt32);

//query interpolate records

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 300;

recordsQueried[1].nSec = 1;

recordsQueried[1].nMsec = 800;

nRet = ar_query_interp_records_by_mode(hServer, HD_REC_INTERP_QUERY_MODE_PREV, tag.nTagID, 2, recordsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query tag [id:%d] interpolate records by mode successful\n", tag.nTagID);

for (i = 0; i < 2; i ++)

 {

  printf("tag [id:%d] query interpolate records by mode successful,  time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

}

else if (EC_HD_API_QUERY_INTERP_REC_FAILED == nRet)

{

for (i = 0; i < 2; i ++)

 {

  if (RD_SUCCESS == nErrorCodes[i])

  {

   printf("tag [id:%d] query interpolate record time by mode [%d s : %d ms], quality [%d], value [%d]!\n",

    tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

    recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

  }

  else

  {

   printf("tag [id:%d] query interpolate record failed, error code [%d], record time [%d s : %d ms]!\n",

    tag.nTagID, nErrorCodes[i], recordsQueried[i].nSec, recordsQueried[i].nMsec);

  }

 }

}

else

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

ar_delete_record

ar modify record

ar_query_interp_record

ar_query_interp_records

ar_query_raw_records

ar_query_raw_records_number

ar_query_specify_num_raw_recs

ar_query_interp_records_by_mode


ar_query_interp_records

Navigation: »No topics above this level«

ar_query_interp_records

 Return to chapter overview

ar_query_interp_records

Glossary Item Box

函数

查询一个普通点在若干时间点的插值记录

int32 ar_query_interp_records(

HDHANDLE hServer,

uint32 nTagID,

int32 nRecNum,

HDRecord records[],

int32 nErrCodes[]

);

参数

hServer

[in] 服务器句柄。

nTagID

[in] TagID。

nRecNum

[in] 返回记录的数量不能超过65535。

records

[in,out] 记录数组，in：插值时间戳，out：记录值。

nErrCodes

[out] 错误码数组。

返回值

全部查询成功，返回RD_SUCCESS，不是全部查询成功返回EC_HD_API_QUERY_INTERP_REC_FAILED，查询失败返回错误码，见error_code.h。

说明

具体的每一条插值记录的查询结果在nErrorCodes数组中。

插值时，选定的插值时刻，需要前后都有好的原始记录，方可插值，此外如果插值时间点正好等于原始记录的时间戳，则此数据也能插值得到；

如果是最后一个点，那么在大于最后这点的时间戳的时刻进行插值是无法得到数据记录的，因为此时后面的原始数据时没有的，

原理类似于

线性函数两个点之间的插值，如果中间那个店（即插值点）的后一个点还没有原始数据，那么，这个点做插值，就无法插值成功。

对于普通点而言，如果要获取某一秒的数据，一般插值会使用这一秒的999毫秒来进行插值。比如实际存储的两条记录时间戳为1'1ms, 2'1ms，如果用户想要获取2'时的数据，那么传进来进行插值的时间戳使用2'999ms，则基本上2'的数据都能被插值得到（在999ms之前的点都可以通过前点插值得到），因此一般建议插值时ms取为999ms。

举例

ar_query_interp_records

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName = "szTagName";

int32 nRecNum = 3;

HDRecord records[3];

uint32 nTagIDs[3];

int32 nErrorCodes[3];

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add tag

strcpy(tag.szTagName, szTagName);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag id

nRet = pt_query_tagid(hServer, tag.szTagName, &tag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",   tag.szTagName,tag.nTagID);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

 nTagIDs[i] = tag.nTagID;

 records[i].nSec = 1 + i;

 records[i].nMsec = 0;

 records[i].nQuality = 192;

 records[i].value.nInt32 = records[i].nSec;

}

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, records, nErrorCodes);

if (nRet != RD_SUCCESS)

{

 printf("save snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

return -1;

}

//query raw recs num

HDTime startTime;

HDTime endTime;

int32 nRecNumQueried;

startTime.nSec = 1;

startTime.nMsec = 0;

endTime.nSec = 36000;

endTime.nMsec = 0;

nRet = ar_query_raw_records_number(hServer,tag.nTagID, &startTime, &endTime, &nRecNumQueried);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query raw records number failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query raw records number successful, nRecNum is %d in time area [%d s : %d ms] to  [%d s : %d ms] !\n",

 tag.nTagID, nRecNumQueried,  startTime.nSec, startTime.nMsec, endTime.nSec, endTime.nMsec );

//query raw recs

HDRecord recordsQueried[2];

nRecNumQueried = 2;

do

{

 nRet = ar_query_raw_records(hServer, nTagIDs[0], &startTime, &endTime, &nRecNumQueried, recordsQueried);

if (nRet != RD_SUCCESS)

 {

  printf("tag [id:%d] query raw records failed, error code[%d]!\n", tag.nTagID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

for (i = 0; i < nRecNumQueried; i ++)

 {

  printf("tag [id:%d] record time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

//reset end time

if (2 == nRecNumQueried)

 {

  endTime.nSec = recordsQueried[1].nSec;

  endTime.nMsec = recordsQueried[1].nMsec;

  if ( 0 == endTime.nMsec )

  {

   endTime.nSec --;

   endTime.nMsec = 999;

  }

  else

  {

   endTime.nMsec --;

  }

 }

} while (2 == nRecNumQueried);

//query specify number records

startTime.nSec = 100;

startTime.nMsec = 0;

nRecNumQueried = 2;

nRet = ar_query_specify_num_raw_recs(hServer, tag.nTagID, &startTime, true, &nRecNumQueried, recordsQueried);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query 2 records from time [%d s : %d ms] to the earlier time failed, error code[%d]!\n",

  tag.nTagID, startTime.nSec, startTime.nMsec, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query 2 records from time [%d s : %d ms] to the earlier time successful!\n",

 tag.nTagID, startTime.nSec, startTime.nMsec);

for (i = 0; i < 2; i ++)

{

 printf("tag [id:%d] raw record time [%d s : %d ms], quality [%d], value [%d]!\n",

  tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

  recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

}

//modify record

recordsQueried[0].value.nInt32 = 999;

nRet = ar_modify_record(hServer, tag.nTagID, &recordsQueried[0]);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] modify record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] modify record successful!\n", tag.nTagID);

//delete record

HDTime hdTime;

hdTime.nSec = recordsQueried[0].nSec;

hdTime.nMsec = recordsQueried[0].nMsec;

nRet = ar_delete_record(hServer, tag.nTagID, &hdTime);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] delete record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] delete record successful!\n", tag.nTagID);

//query one linear interpolate rec

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 500;

nRet = ar_query_interp_record(hServer, tag.nTagID, &(recordsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

 tag.nTagID, recordsQueried[0].nSec, recordsQueried[0].nMsec,

 recordsQueried[0].nQuality, recordsQueried[0].value.nInt32);

//query linear interpolate records

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 300;

recordsQueried[1].nSec = 1;

recordsQueried[1].nMsec = 800;

nRet = ar_query_interp_records(hServer, tag.nTagID, 2, recordsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query tag [id:%d] interpolate records successful\n", tag.nTagID);

for (i = 0; i < 2; i ++)

 {

  printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

}

else if (EC_HD_API_QUERY_INTERP_REC_FAILED == nRet)

{

for (i = 0; i < 2; i ++)

 {

  if (RD_SUCCESS == nErrorCodes[i])

  {

   printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

    tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

    recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

  }

  else

  {

   printf("tag [id:%d] query interpolate record failed, error code [%d], record time [%d s : %d ms]!\n",

    tag.nTagID, nErrorCodes[i], recordsQueried[i].nSec, recordsQueried[i].nMsec);

  }

 }

}

else

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

//query one interpolate rec by mode

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 500;

nRet = ar_query_interp_record_by_mode(hServer, HD_REC_INTERP_QUERY_MODE_LINEAR, tag.nTagID, &(recordsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query interpolate record by mode failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query interpolate record by mode successful, time [%d s : %d ms], quality [%d], value [%d]!\n",

 tag.nTagID, recordsQueried[0].nSec, recordsQueried[0].nMsec,

 recordsQueried[0].nQuality, recordsQueried[0].value.nInt32);

//query interpolate records

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 300;

recordsQueried[1].nSec = 1;

recordsQueried[1].nMsec = 800;

nRet = ar_query_interp_records_by_mode(hServer, HD_REC_INTERP_QUERY_MODE_PREV, tag.nTagID, 2, recordsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query tag [id:%d] interpolate records by mode successful\n", tag.nTagID);

for (i = 0; i < 2; i ++)

 {

  printf("tag [id:%d] query interpolate records by mode successful,  time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

}

else if (EC_HD_API_QUERY_INTERP_REC_FAILED == nRet)

{

for (i = 0; i < 2; i ++)

 {

  if (RD_SUCCESS == nErrorCodes[i])

  {

   printf("tag [id:%d] query interpolate record time by mode [%d s : %d ms], quality [%d], value [%d]!\n",

    tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

    recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

  }

  else

  {

   printf("tag [id:%d] query interpolate record failed, error code [%d], record time [%d s : %d ms]!\n",

    tag.nTagID, nErrorCodes[i], recordsQueried[i].nSec, recordsQueried[i].nMsec);

  }

 }

}

else

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

ar_delete_record

ar modify record

ar_query_interp_record

ar_query_interp_records

ar_query_raw_records

ar_query_raw_records_number

ar_query_specify_num_raw_recs

ar_query_interp_record_by_mode

ar_query_interp_records_by_mode


ar_query_interp_records_by_mode

Navigation: »No topics above this level«

ar_query_interp_records_by_mode

 Return to chapter overview

ar_query_interp_records_by_mode

Glossary Item Box

函数

根据插值类型的不同查询若干点在某一时刻的插值记录

int32 ar_query_interp_records_by_mode(

HDHANDLE hServer,

uint8 nMode,

uint32 nTagID,

int32 nRecNum,

HDRecord records[],

int32 nErrCodes[]

);

参数

hServer:

[in] 服务器句柄。

nMode

[in]插值类型，值为1表示前向插值，即将某一个时刻之前最近的一条原始值作为改时刻的插值；值为0表示线性插值，即根据某一时刻之前的最近一条原始值和该时刻之后最近一条原始值来进行线性计算该时刻的插值。

nTagID

[in] TagID。

nRecNum

[in]记录的条数。

records[]

[in,out]in：查询时间戳，out：返回记录的值。

nErrCodes[]

[out]每条记录的Errorcode array。

返回值

查询成功返回RD_SUCCESS，查询失败返回错误码，见error_code.h。

说明

iHyperDB的8种数据类型都支持插值查询。

插值时，选定的插值时刻，需要前后都有好的原始记录，方可插值，此外如果插值时间点正好等于原始记录的时间戳，则此数据也能插值得到；

如果是最后一个点，那么在大于最后这点的时间戳的时刻进行插值是无法得到数据记录的，因为此时后面的原始数据时没有的，

原理类似于

线性函数两个点之间的插值，如果中间那个店（即插值点）的后一个点还没有原始数据，那么，这个点做插值，就无法插值成功。。

对于普通点而言，如果要获取某一秒的数据，一般插值会使用这一秒的999毫秒来进行插值。比如实际存储的两条记录时间戳为1'1ms, 2'1ms，如果用户想要获取2'时的数据，那么传进来进行插值的时间戳使用2'999ms，则基本上2'的数据都能被插值得到（在999ms之前的点都可以通过前点插值得到），因此一般建议插值时ms取为999ms。

举例

ar_query_interp_records_by_mode

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName = "szTagName";

int32 nRecNum = 3;

HDRecord records[3];

uint32 nTagIDs[3];

int32 nErrorCodes[3];

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add tag

strcpy(tag.szTagName, szTagName);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag id

nRet = pt_query_tagid(hServer, tag.szTagName, &tag.nTagID);

if (nRet != RD_SUCCESS)

{

printf("query tag id failed, tag name[%s], error code[%d]!\n", tag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n", tag.szTagName,tag.nTagID);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

nTagIDs[i] = tag.nTagID;

records[i].nSec = 1 + i;

records[i].nMsec = 0;

records[i].nQuality = 192;

records[i].value.nInt32 = records[i].nSec;

}

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, records, nErrorCodes);

if (nRet != RD_SUCCESS)

{

printf("save snapshots failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

//query raw recs num

HDTime startTime;

HDTime endTime;

int32 nRecNumQueried;

startTime.nSec = 1;

startTime.nMsec = 0;

endTime.nSec = 36000;

endTime.nMsec = 0;

nRet = ar_query_raw_records_number(hServer,tag.nTagID, &startTime, &endTime, &nRecNumQueried);

if (nRet != RD_SUCCESS)

{

printf("tag [id:%d] query raw records number failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query raw records number successful, nRecNum is %d in time area [%d s : %d ms] to [%d s : %d ms] !\n",

tag.nTagID, nRecNumQueried, startTime.nSec, startTime.nMsec, endTime.nSec, endTime.nMsec );

//query raw recs

HDRecord recordsQueried[2];

nRecNumQueried = 2;

do

{

nRet = ar_query_raw_records(hServer, nTagIDs[0], &startTime, &endTime, &nRecNumQueried, recordsQueried);

if (nRet != RD_SUCCESS)

{

printf("tag [id:%d] query raw records failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

for (i = 0; i < nRecNumQueried; i ++)

{

printf("tag [id:%d] record time [%d s : %d ms], quality [%d], value [%d]!\n",

tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

}

//reset end time

if (2 == nRecNumQueried)

{

endTime.nSec = recordsQueried[1].nSec;

endTime.nMsec = recordsQueried[1].nMsec;

if ( 0 == endTime.nMsec )

{

endTime.nSec --;

endTime.nMsec = 999;

}

else

{

endTime.nMsec --;

}

}

} while (2 == nRecNumQueried);

//query specify number records

startTime.nSec = 100;

startTime.nMsec = 0;

nRecNumQueried = 2;

nRet = ar_query_specify_num_raw_recs(hServer, tag.nTagID, &startTime, true, &nRecNumQueried, recordsQueried);

if (nRet != RD_SUCCESS)

{

printf("tag [id:%d] query 2 records from time [%d s : %d ms] to the earlier time failed, error code[%d]!\n",

tag.nTagID, startTime.nSec, startTime.nMsec, nRet);

nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query 2 records from time [%d s : %d ms] to the earlier time successful!\n",

tag.nTagID, startTime.nSec, startTime.nMsec);

for (i = 0; i < 2; i ++)

{

printf("tag [id:%d] raw record time [%d s : %d ms], quality [%d], value [%d]!\n",

tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

}

//modify record

recordsQueried[0].value.nInt32 = 999;

nRet = ar_modify_record(hServer, tag.nTagID, &recordsQueried[0]);

if (nRet != RD_SUCCESS)

{

printf("tag [id:%d] modify record failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] modify record successful!\n", tag.nTagID);

//delete record

HDTime hdTime;

hdTime.nSec = recordsQueried[0].nSec;

hdTime.nMsec = recordsQueried[0].nMsec;

nRet = ar_delete_record(hServer, tag.nTagID, &hdTime);

if (nRet != RD_SUCCESS)

{

printf("tag [id:%d] delete record failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] delete record successful!\n", tag.nTagID);

//query one linear interpolate rec

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 500;

nRet = ar_query_interp_record(hServer, tag.nTagID, &(recordsQueried[0]));

if (nRet != RD_SUCCESS)

{

printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

tag.nTagID, recordsQueried[0].nSec, recordsQueried[0].nMsec,

recordsQueried[0].nQuality, recordsQueried[0].value.nInt32);

//query linear interpolate records

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 300;

recordsQueried[1].nSec = 1;

recordsQueried[1].nMsec = 800;

nRet = ar_query_interp_records(hServer, tag.nTagID, 2, recordsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

printf("query tag [id:%d] interpolate records successful\n", tag.nTagID);

for (i = 0; i < 2; i ++)

{

printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

}

}

else if (EC_HD_API_QUERY_INTERP_REC_FAILED == nRet)

{

for (i = 0; i < 2; i ++)

{

if (RD_SUCCESS == nErrorCodes[i])

{

printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

}

else

{

printf("tag [id:%d] query interpolate record failed, error code [%d], record time [%d s : %d ms]!\n",

tag.nTagID, nErrorCodes[i], recordsQueried[i].nSec, recordsQueried[i].nMsec);

}

}

}

else

{

printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

//query one interpolate rec by mode

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 500;

nRet = ar_query_interp_record_by_mode(hServer, HD_REC_INTERP_QUERY_MODE_LINEAR, tag.nTagID, &(recordsQueried[0]));

if (nRet != RD_SUCCESS)

{

printf("tag [id:%d] query interpolate record by mode failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query interpolate record by mode successful, time [%d s : %d ms], quality [%d], value [%d]!\n",

tag.nTagID, recordsQueried[0].nSec, recordsQueried[0].nMsec,

recordsQueried[0].nQuality, recordsQueried[0].value.nInt32);

//query interpolate records

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 300;

recordsQueried[1].nSec = 1;

recordsQueried[1].nMsec = 800;

nRet = ar_query_interp_records_by_mode(hServer, HD_REC_INTERP_QUERY_MODE_PREV, tag.nTagID, 2, recordsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

printf("query tag [id:%d] interpolate records by mode successful\n", tag.nTagID);

for (i = 0; i < 2; i ++)

{

printf("tag [id:%d] query interpolate records by mode successful, time [%d s : %d ms], quality [%d], value [%d]!\n",

tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

}

}

else if (EC_HD_API_QUERY_INTERP_REC_FAILED == nRet)

{

for (i = 0; i < 2; i ++)

{

if (RD_SUCCESS == nErrorCodes[i])

{

printf("tag [id:%d] query interpolate record time by mode [%d s : %d ms], quality [%d], value [%d]!\n",

tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

}

else

{

printf("tag [id:%d] query interpolate record failed, error code [%d], record time [%d s : %d ms]!\n",

tag.nTagID, nErrorCodes[i], recordsQueried[i].nSec, recordsQueried[i].nMsec);

}

}

}

else

{

printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

ar_delete_record

ar modify record

ar_query_interp_record

ar_query_interp_records

ar_query_raw_records

ar_query_raw_records_number

ar_query_specify_num_raw_recs

ar_query_interp_record_by_mode


ar_query_raw_records

Navigation: »No topics above this level«

ar_query_raw_records

 Return to chapter overview

ar_query_raw_records

Glossary Item Box

函数

ar_query_records函数用来查询某一Tag点一个时间段内的实际记录，该操作支持并发执行。

int32 ar_query_raw_records(

HDHANDLE hServer,

uint32 nTagID,

const HDTime* pStartTime,

const HDTime* pEndTime,

int32* pRecNum,

HDRecord records[]

);

参数

hServer:

[in] 服务器句柄。

nTagID

[in] TagID。

pStartTime

[in] 查询的起始时间戳。

pEndTime

[in] 查询的结束时间戳。

pRecNum

[in,out] in：待查的记录数量。out：实际返回的记录的数量。若小于要查询的记录数量， 则表示该时间段的记录全部查完；若等于要查询的数量，则表示在该 时间段内还有记录没有查完，用户可以根据返回的最后一条记录的时间来重新设置结束时间，然后再次调用该接口来查询剩下的记录。记录个数不能超过65535。

records

[out] 记录数组，返回的记录是按照时间戳从大到小排列的，例如records[0]比records[1]的时间要大。

返回值

全部查询成功，返回RD_SUCCESS，查询失败返回错误码，见error_code.h。

说明

1 查询一个Tag在一个时间段内的记录，该接口支持所有的数据类型。

2 该接口的时间戳精确到秒。例如：开始时间为“2001-1-1 08:08:08. 111”，结束时间是为“2001-1-2 08:08:08. 222”，查询到的记录是“2001-1-1 08:08:08. 000”到“2001-1-2 08:08:08. 000”范围内的原始记录。

举例

ar_query_raw_records

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName = "szTagName";

int32 nRecNum = 3;

HDRecord records[3];

uint32 nTagIDs[3];

int32 nErrorCodes[3];

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add tag

strcpy(tag.szTagName, szTagName);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag id

nRet = pt_query_tagid(hServer, tag.szTagName, &tag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",   tag.szTagName,tag.nTagID);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

 nTagIDs[i] = tag.nTagID;

 records[i].nSec = 1 + i;

 records[i].nMsec = 0;

 records[i].nQuality = 192;

 records[i].value.nInt32 = records[i].nSec;

}

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, records, nErrorCodes);

if (nRet != RD_SUCCESS)

{

 printf("save snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

return -1;

}

//query raw recs num

HDTime startTime;

HDTime endTime;

int32 nRecNumQueried;

startTime.nSec = 1;

startTime.nMsec = 0;

endTime.nSec = 36000;

endTime.nMsec = 0;

nRet = ar_query_raw_records_number(hServer,tag.nTagID, &startTime, &endTime, &nRecNumQueried);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query raw records number failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query raw records number successful, nRecNum is %d in time area [%d s : %d ms] to  [%d s : %d ms] !\n",

 tag.nTagID, nRecNumQueried,  startTime.nSec, startTime.nMsec, endTime.nSec, endTime.nMsec );

//query raw recs

HDRecord recordsQueried[2];

nRecNumQueried = 2;

do

{

 nRet = ar_query_raw_records(hServer, nTagIDs[0], &startTime, &endTime, &nRecNumQueried, recordsQueried);

if (nRet != RD_SUCCESS)

 {

  printf("tag [id:%d] query raw records failed, error code[%d]!\n", tag.nTagID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

for (i = 0; i < nRecNumQueried; i ++)

 {

  printf("tag [id:%d] record time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

//reset end time

if (2 == nRecNumQueried)

 {

  endTime.nSec = recordsQueried[1].nSec;

  endTime.nMsec = recordsQueried[1].nMsec;

  if ( 0 == endTime.nMsec )

  {

   endTime.nSec --;

   endTime.nMsec = 999;

  }

  else

  {

   endTime.nMsec --;

  }

 }

} while (2 == nRecNumQueried);

//query specify number records

startTime.nSec = 100;

startTime.nMsec = 0;

nRecNumQueried = 2;

nRet = ar_query_specify_num_raw_recs(hServer, tag.nTagID, &startTime, true, &nRecNumQueried, recordsQueried);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query 2 records from time [%d s : %d ms] to the earlier time failed, error code[%d]!\n",

  tag.nTagID, startTime.nSec, startTime.nMsec, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query 2 records from time [%d s : %d ms] to the earlier time successful!\n",

 tag.nTagID, startTime.nSec, startTime.nMsec);

for (i = 0; i < 2; i ++)

{

 printf("tag [id:%d] raw record time [%d s : %d ms], quality [%d], value [%d]!\n",

  tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

  recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

}

//modify record

recordsQueried[0].value.nInt32 = 999;

nRet = ar_modify_record(hServer, tag.nTagID, &recordsQueried[0]);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] modify record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] modify record successful!\n", tag.nTagID);

//delete record

HDTime hdTime;

hdTime.nSec = recordsQueried[0].nSec;

hdTime.nMsec = recordsQueried[0].nMsec;

nRet = ar_delete_record(hServer, tag.nTagID, &hdTime);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] delete record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] delete record successful!\n", tag.nTagID);

//query one linear interpolate rec

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 500;

nRet = ar_query_interp_record(hServer, tag.nTagID, &(recordsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

 tag.nTagID, recordsQueried[0].nSec, recordsQueried[0].nMsec,

 recordsQueried[0].nQuality, recordsQueried[0].value.nInt32);

//query linear interpolate records

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 300;

recordsQueried[1].nSec = 1;

recordsQueried[1].nMsec = 800;

nRet = ar_query_interp_records(hServer, tag.nTagID, 2, recordsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query tag [id:%d] interpolate records successful\n", tag.nTagID);

for (i = 0; i < 2; i ++)

 {

  printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

}

else if (EC_HD_API_QUERY_INTERP_REC_FAILED == nRet)

{

for (i = 0; i < 2; i ++)

 {

  if (RD_SUCCESS == nErrorCodes[i])

  {

   printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

    tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

    recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

  }

  else

  {

   printf("tag [id:%d] query interpolate record failed, error code [%d], record time [%d s : %d ms]!\n",

    tag.nTagID, nErrorCodes[i], recordsQueried[i].nSec, recordsQueried[i].nMsec);

  }

 }

}

else

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

//query one interpolate rec by mode

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 500;

nRet = ar_query_interp_record_by_mode(hServer, HD_REC_INTERP_QUERY_MODE_LINEAR, tag.nTagID, &(recordsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query interpolate record by mode failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query interpolate record by mode successful, time [%d s : %d ms], quality [%d], value [%d]!\n",

 tag.nTagID, recordsQueried[0].nSec, recordsQueried[0].nMsec,

 recordsQueried[0].nQuality, recordsQueried[0].value.nInt32);

//query interpolate records

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 300;

recordsQueried[1].nSec = 1;

recordsQueried[1].nMsec = 800;

nRet = ar_query_interp_records_by_mode(hServer, HD_REC_INTERP_QUERY_MODE_PREV, tag.nTagID, 2, recordsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query tag [id:%d] interpolate records by mode successful\n", tag.nTagID);

for (i = 0; i < 2; i ++)

 {

  printf("tag [id:%d] query interpolate records by mode successful,  time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

}

else if (EC_HD_API_QUERY_INTERP_REC_FAILED == nRet)

{

for (i = 0; i < 2; i ++)

 {

  if (RD_SUCCESS == nErrorCodes[i])

  {

   printf("tag [id:%d] query interpolate record time by mode [%d s : %d ms], quality [%d], value [%d]!\n",

    tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

    recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

  }

  else

  {

   printf("tag [id:%d] query interpolate record failed, error code [%d], record time [%d s : %d ms]!\n",

    tag.nTagID, nErrorCodes[i], recordsQueried[i].nSec, recordsQueried[i].nMsec);

  }

 }

}

else

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

ar_delete_record

ar modify record

ar_query_interp_record

ar_query_interp_records

ar_query_raw_records

ar_query_raw_records_number

ar_query_specify_num_raw_recs

ar_query_interp_record_by_mode

ar_query_interp_records_by_mode


ar_query_raw_records_number

Navigation: »No topics above this level«

ar_query_raw_records_number

 Return to chapter overview

ar_query_raw_records_number

Glossary Item Box

函数

查询一个普通点在一个时间段的原始记录的个数

int32 ar_query_raw_records_number(

HDHANDLE hServer,

uint32 nTagID,

const HDTime* pStartTime,

const HDTime* pEndTime,

int32* pRecNum

);

参数

hServer

[in] 服务器句柄。

nTagID

[in] TagID。

pStartTime

[in] 开始时间戳。

pEndTime

[in] 结束时间戳。

pRecNum

[out] 原始记录条数。

返回值

查询成功，返回RD_SUCCESS。查询失败返回错误码，见error_code.h。

说明

该接口用来查询某一Tag指定时间段内的原始记录条数。

举例

ar_query_raw_records_number

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName = "szTagName";

int32 nRecNum = 3;

HDRecord records[3];

uint32 nTagIDs[3];

int32 nErrorCodes[3];

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add tag

strcpy(tag.szTagName, szTagName);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag id

nRet = pt_query_tagid(hServer, tag.szTagName, &tag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",   tag.szTagName,tag.nTagID);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

 nTagIDs[i] = tag.nTagID;

 records[i].nSec = 1 + i;

 records[i].nMsec = 0;

 records[i].nQuality = 192;

 records[i].value.nInt32 = records[i].nSec;

}

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, records, nErrorCodes);

if (nRet != RD_SUCCESS)

{

 printf("save snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

return -1;

}

//query raw recs num

HDTime startTime;

HDTime endTime;

int32 nRecNumQueried;

startTime.nSec = 1;

startTime.nMsec = 0;

endTime.nSec = 36000;

endTime.nMsec = 0;

nRet = ar_query_raw_records_number(hServer,tag.nTagID, &startTime, &endTime, &nRecNumQueried);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query raw records number failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query raw records number successful, nRecNum is %d in time area [%d s : %d ms] to  [%d s : %d ms] !\n",

 tag.nTagID, nRecNumQueried,  startTime.nSec, startTime.nMsec, endTime.nSec, endTime.nMsec );

//query raw recs

HDRecord recordsQueried[2];

nRecNumQueried = 2;

do

{

 nRet = ar_query_raw_records(hServer, nTagIDs[0], &startTime, &endTime, &nRecNumQueried, recordsQueried);

if (nRet != RD_SUCCESS)

 {

  printf("tag [id:%d] query raw records failed, error code[%d]!\n", tag.nTagID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

for (i = 0; i < nRecNumQueried; i ++)

 {

  printf("tag [id:%d] record time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

//reset end time

if (2 == nRecNumQueried)

 {

  endTime.nSec = recordsQueried[1].nSec;

  endTime.nMsec = recordsQueried[1].nMsec;

  if ( 0 == endTime.nMsec )

  {

   endTime.nSec --;

   endTime.nMsec = 999;

  }

  else

  {

   endTime.nMsec --;

  }

 }

} while (2 == nRecNumQueried);

//query specify number records

startTime.nSec = 100;

startTime.nMsec = 0;

nRecNumQueried = 2;

nRet = ar_query_specify_num_raw_recs(hServer, tag.nTagID, &startTime, true, &nRecNumQueried, recordsQueried);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query 2 records from time [%d s : %d ms] to the earlier time failed, error code[%d]!\n",

  tag.nTagID, startTime.nSec, startTime.nMsec, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query 2 records from time [%d s : %d ms] to the earlier time successful!\n",

 tag.nTagID, startTime.nSec, startTime.nMsec);

for (i = 0; i < 2; i ++)

{

 printf("tag [id:%d] raw record time [%d s : %d ms], quality [%d], value [%d]!\n",

  tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

  recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

}

//modify record

recordsQueried[0].value.nInt32 = 999;

nRet = ar_modify_record(hServer, tag.nTagID, &recordsQueried[0]);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] modify record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] modify record successful!\n", tag.nTagID);

//delete record

HDTime hdTime;

hdTime.nSec = recordsQueried[0].nSec;

hdTime.nMsec = recordsQueried[0].nMsec;

nRet = ar_delete_record(hServer, tag.nTagID, &hdTime);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] delete record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] delete record successful!\n", tag.nTagID);

//query one linear interpolate rec

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 500;

nRet = ar_query_interp_record(hServer, tag.nTagID, &(recordsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

 tag.nTagID, recordsQueried[0].nSec, recordsQueried[0].nMsec,

 recordsQueried[0].nQuality, recordsQueried[0].value.nInt32);

//query linear interpolate records

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 300;

recordsQueried[1].nSec = 1;

recordsQueried[1].nMsec = 800;

nRet = ar_query_interp_records(hServer, tag.nTagID, 2, recordsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query tag [id:%d] interpolate records successful\n", tag.nTagID);

for (i = 0; i < 2; i ++)

 {

  printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

}

else if (EC_HD_API_QUERY_INTERP_REC_FAILED == nRet)

{

for (i = 0; i < 2; i ++)

 {

  if (RD_SUCCESS == nErrorCodes[i])

  {

   printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

    tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

    recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

  }

  else

  {

   printf("tag [id:%d] query interpolate record failed, error code [%d], record time [%d s : %d ms]!\n",

    tag.nTagID, nErrorCodes[i], recordsQueried[i].nSec, recordsQueried[i].nMsec);

  }

 }

}

else

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

//query one interpolate rec by mode

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 500;

nRet = ar_query_interp_record_by_mode(hServer, HD_REC_INTERP_QUERY_MODE_LINEAR, tag.nTagID, &(recordsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query interpolate record by mode failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query interpolate record by mode successful, time [%d s : %d ms], quality [%d], value [%d]!\n",

 tag.nTagID, recordsQueried[0].nSec, recordsQueried[0].nMsec,

 recordsQueried[0].nQuality, recordsQueried[0].value.nInt32);

//query interpolate records

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 300;

recordsQueried[1].nSec = 1;

recordsQueried[1].nMsec = 800;

nRet = ar_query_interp_records_by_mode(hServer, HD_REC_INTERP_QUERY_MODE_PREV, tag.nTagID, 2, recordsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query tag [id:%d] interpolate records by mode successful\n", tag.nTagID);

for (i = 0; i < 2; i ++)

 {

  printf("tag [id:%d] query interpolate records by mode successful,  time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

}

else if (EC_HD_API_QUERY_INTERP_REC_FAILED == nRet)

{

for (i = 0; i < 2; i ++)

 {

  if (RD_SUCCESS == nErrorCodes[i])

  {

   printf("tag [id:%d] query interpolate record time by mode [%d s : %d ms], quality [%d], value [%d]!\n",

    tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

    recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

  }

  else

  {

   printf("tag [id:%d] query interpolate record failed, error code [%d], record time [%d s : %d ms]!\n",

    tag.nTagID, nErrorCodes[i], recordsQueried[i].nSec, recordsQueried[i].nMsec);

  }

 }

}

else

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

ar_delete_record

ar modify record

ar_query_interp_record

ar_query_interp_records

ar_query_raw_records

ar_query_raw_records_number

ar_query_specify_num_raw_recs

ar_query_interp_record_by_mode

ar_query_interp_records_by_mode


ar_query_specify_num_raw_recs

Navigation: »No topics above this level«

ar_query_specify_num_raw_recs

 Return to chapter overview

ar_query_specify_num_raw_recs

Glossary Item Box

函数

查询一个普通点在一个时间点前或者后的指定数量的原始记录

int32 ar_query_specify_num_raw_recs(

HDHANDLE hServer,

uint32 nTagID,

const HDTime* pTime,

bool bBackward,

int32* pQueryRecNum,

HDRecord records[]

)

参数

hServer

[in] 服务器句柄。

nTagID

[in] TagID。

pTime

[in] 指定的时间戳。

bBackward

[in] true表示向后查（记录时间小于指定时间点的记录），false表示向前查询（记录时间大于指定时间点的记录）

pQueryRecNum

[in, out]in:记录数组大小，out：实际返回的记录条数，不能超过65535 。

records

[out] 查询记录数组。

返回值

查询成功，返回RD_SUCCESS。查询失败返回错误码，见error_code.h。

说明

该接口用来查询某一Tag指定时间点前或后的多条记录。

举例

ar_query_specify_num_raw_recs

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName = "szTagName";

int32 nRecNum = 3;

HDRecord records[3];

uint32 nTagIDs[3];

int32 nErrorCodes[3];

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add tag

strcpy(tag.szTagName, szTagName);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag id

nRet = pt_query_tagid(hServer, tag.szTagName, &tag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",   tag.szTagName,tag.nTagID);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

 nTagIDs[i] = tag.nTagID;

 records[i].nSec = 1 + i;

 records[i].nMsec = 0;

 records[i].nQuality = 192;

 records[i].value.nInt32 = records[i].nSec;

}

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, records, nErrorCodes);

if (nRet != RD_SUCCESS)

{

 printf("save snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

return -1;

}

//query raw recs num

HDTime startTime;

HDTime endTime;

int32 nRecNumQueried;

startTime.nSec = 1;

startTime.nMsec = 0;

endTime.nSec = 36000;

endTime.nMsec = 0;

nRet = ar_query_raw_records_number(hServer,tag.nTagID, &startTime, &endTime, &nRecNumQueried);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query raw records number failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query raw records number successful, nRecNum is %d in time area [%d s : %d ms] to  [%d s : %d ms] !\n",

 tag.nTagID, nRecNumQueried,  startTime.nSec, startTime.nMsec, endTime.nSec, endTime.nMsec );

//query raw recs

HDRecord recordsQueried[2];

nRecNumQueried = 2;

do

{

 nRet = ar_query_raw_records(hServer, nTagIDs[0], &startTime, &endTime, &nRecNumQueried, recordsQueried);

if (nRet != RD_SUCCESS)

 {

  printf("tag [id:%d] query raw records failed, error code[%d]!\n", tag.nTagID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

for (i = 0; i < nRecNumQueried; i ++)

 {

  printf("tag [id:%d] record time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

//reset end time

if (2 == nRecNumQueried)

 {

  endTime.nSec = recordsQueried[1].nSec;

  endTime.nMsec = recordsQueried[1].nMsec;

  if ( 0 == endTime.nMsec )

  {

   endTime.nSec --;

   endTime.nMsec = 999;

  }

  else

  {

   endTime.nMsec --;

  }

 }

} while (2 == nRecNumQueried);

//query specify number records

startTime.nSec = 100;

startTime.nMsec = 0;

nRecNumQueried = 2;

nRet = ar_query_specify_num_raw_recs(hServer, tag.nTagID, &startTime, true, &nRecNumQueried, recordsQueried);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query 2 records from time [%d s : %d ms] to the earlier time failed, error code[%d]!\n",

  tag.nTagID, startTime.nSec, startTime.nMsec, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query 2 records from time [%d s : %d ms] to the earlier time successful!\n",

 tag.nTagID, startTime.nSec, startTime.nMsec);

for (i = 0; i < 2; i ++)

{

 printf("tag [id:%d] raw record time [%d s : %d ms], quality [%d], value [%d]!\n",

  tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

  recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

}

//modify record

recordsQueried[0].value.nInt32 = 999;

nRet = ar_modify_record(hServer, tag.nTagID, &recordsQueried[0]);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] modify record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] modify record successful!\n", tag.nTagID);

//delete record

HDTime hdTime;

hdTime.nSec = recordsQueried[0].nSec;

hdTime.nMsec = recordsQueried[0].nMsec;

nRet = ar_delete_record(hServer, tag.nTagID, &hdTime);

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] delete record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] delete record successful!\n", tag.nTagID);

//query one linear interpolate rec

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 500;

nRet = ar_query_interp_record(hServer, tag.nTagID, &(recordsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

 tag.nTagID, recordsQueried[0].nSec, recordsQueried[0].nMsec,

 recordsQueried[0].nQuality, recordsQueried[0].value.nInt32);

//query linear interpolate records

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 300;

recordsQueried[1].nSec = 1;

recordsQueried[1].nMsec = 800;

nRet = ar_query_interp_records(hServer, tag.nTagID, 2, recordsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query tag [id:%d] interpolate records successful\n", tag.nTagID);

for (i = 0; i < 2; i ++)

 {

  printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

}

else if (EC_HD_API_QUERY_INTERP_REC_FAILED == nRet)

{

for (i = 0; i < 2; i ++)

 {

  if (RD_SUCCESS == nErrorCodes[i])

  {

   printf("tag [id:%d] interpolate record time [%d s : %d ms], quality [%d], value [%d]!\n",

    tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

    recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

  }

  else

  {

   printf("tag [id:%d] query interpolate record failed, error code [%d], record time [%d s : %d ms]!\n",

    tag.nTagID, nErrorCodes[i], recordsQueried[i].nSec, recordsQueried[i].nMsec);

  }

 }

}

else

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

//query one interpolate rec by mode

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 500;

nRet = ar_query_interp_record_by_mode(hServer, HD_REC_INTERP_QUERY_MODE_LINEAR, tag.nTagID, &(recordsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("tag [id:%d] query interpolate record by mode failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag [id:%d] query interpolate record by mode successful, time [%d s : %d ms], quality [%d], value [%d]!\n",

 tag.nTagID, recordsQueried[0].nSec, recordsQueried[0].nMsec,

 recordsQueried[0].nQuality, recordsQueried[0].value.nInt32);

//query interpolate records

recordsQueried[0].nSec = 1;

recordsQueried[0].nMsec = 300;

recordsQueried[1].nSec = 1;

recordsQueried[1].nMsec = 800;

nRet = ar_query_interp_records_by_mode(hServer, HD_REC_INTERP_QUERY_MODE_PREV, tag.nTagID, 2, recordsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query tag [id:%d] interpolate records by mode successful\n", tag.nTagID);

for (i = 0; i < 2; i ++)

 {

  printf("tag [id:%d] query interpolate records by mode successful,  time [%d s : %d ms], quality [%d], value [%d]!\n",

   tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

   recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

 }

}

else if (EC_HD_API_QUERY_INTERP_REC_FAILED == nRet)

{

for (i = 0; i < 2; i ++)

 {

  if (RD_SUCCESS == nErrorCodes[i])

  {

   printf("tag [id:%d] query interpolate record time by mode [%d s : %d ms], quality [%d], value [%d]!\n",

    tag.nTagID, recordsQueried[i].nSec, recordsQueried[i].nMsec,

    recordsQueried[i].nQuality, recordsQueried[i].value.nInt32);

  }

  else

  {

   printf("tag [id:%d] query interpolate record failed, error code [%d], record time [%d s : %d ms]!\n",

    tag.nTagID, nErrorCodes[i], recordsQueried[i].nSec, recordsQueried[i].nMsec);

  }

 }

}

else

{

 printf("tag [id:%d] query interpolate record failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

ar_delete_record

ar modify record

ar_query_interp_record

ar_query_interp_records

ar_query_raw_records

ar_query_raw_records_number

ar_query_specify_num_raw_recs

ar_query_interp_record_by_mode

ar_query_interp_records_by_mode


备份配置

Navigation: »No topics above this level«

备份配置

 Return to chapter overview

备份的配置参数包括自动备份配置和手动备份配置两个方面内容：

·自动备份配置

双击自动备份库下的“备份配置”节点，显示如下图的配置界面：

·配置选项如下：

1.计划配置：包括两种模式“工作日”和“日月”。选择其中任意一种模式进行勾选，然后在最右勾选小时计划，填写“配置生效时间”即可配置计划。例如：从2016.5.11开始，每个周一的00：00都进行一次备份。

2.源服务器：填写要求备份的数据来源方实时数据库的服务器IP，端口号，用户名和密码。单击“测试连接”按钮，可以测试是否正确连接。

·当配置多备份库时，只支持同一个实时数据库的数据，每个备份库的IP和端口号都要一致，否则会导致备份失败。

3.备份库路径：新建备份库时填写的备份库路径，备份数据将保存到这个地址。不可修改。

4.备份数据起始时间：可以不填，即取消勾选。也可以自己填写。用户若要从第一条数据开始备份，则去掉起始时间勾选。若要备份至当前的最后一条数据，则去掉结束时间的勾选。

5.保存配置：单击右下方的“保存配置”按钮，配置的信息被保存到配置文件中，同时通知备份服务。

·手动备份配置

双击手动备份库下的“备份配置”节点，显示如下图的配置界面：

手动备份不用配置任务计划，只需配置源服务器和备份数据起止时间。配置同自动备份配置部分说明。


备份监控

Navigation: »No topics above this level«

备份监控

 Return to chapter overview

双击数据库备份工具的备份节点，可显示如下图的监控界面：

§备份监控以表格的形式进行展示，表格分为四列，分别为：开始时间、继续时间、状态和备注；

§表格的每一行表示一条备份任务，分为三种状态：正在备份（绿色表示）；备份完毕（蓝色表示）；备份出错（红色表示）；

§表格下方的进度条表示当前这条备份任务的进度，不表示备份整个过程；

§每有一个新的任务启动，表格的最上方会增加一条信息。

§“启动备份”按钮和“停止备份”按钮分别用于启动和停止备份，表示整个备份过程的启动和停止；

§注意:备份数据前,需进行"配置的备份",否则无法恢复!


BS SPC 配置(tupian)

BS SPC 配置

Navigation: »No topics above this level«

BS SPC 配置

 Return to chapter overview

Web数据库连接管理

Web数据库连接管理主要是配置iWebView服务端数据库连接，SPC客户端配置内容将存储在该数据库中供iWebView读取展示时使用。

1 MySQL数据库连接配置

单击界面右上方Web数据库连接管理按钮，弹出Web数据库连接配置对话框，数据库类型选择MySQL类型时如下图所示：

数据库类型：当前可选类型为MySQL和Oracle两种；

注：数据库名、用户名和密码均采用iWebView中默认的数据库名称、用户名和密码，用户不必更改；

Web数据库主机IP：默认为本机127.0.0.1，用户可自行配置需要连接的iWebView服务端数据库IP。Web数据库主机IP可以为空，为空时默认本机IP，即127.0.0.1；

端口号：默认为当前选中的数据库类型的默认端口号，如MySql为3306，Oracle为1521，用户可手动修改；

测试连接：测试是否能够用已经配置的数据库连接信息成功建立连接，如果建立连接成功，弹出连接成功提示框，失败则弹出连接失败提示框；

确定：在用户配置好数据库连接信息之后，需要点击确定按钮对Web数据库配置信息保存到配置文件中，保存的同时也对数据库是否有连接进行测试，如果连接成功，则弹出配置信息已保存提示框，用户单击确定后退出Web数据库连接配置界面；

注：如果在保存的同时连接没有成功，则弹出提示，询问是否保存配置信息，单击保存，则保存信息到配置文件，同时退出Web数据库连接配置界面；单击取消，则重新返回Web数据库连接配置界面。

2 Oracle数据库连接配置

当数据源类型选择为Oracle时，配置界面如下图所示：

Oracle连接服务需要SPC配置客户端所在机器配置Oracle客户端。下面给出一种推荐方式：

a. 从Oracle官方网站下载InstantClient压缩包，将压缩包中的DLL文件、可执行文件等全部解压到转储客户端所在的机器上，比如“D:\instantclient_11_2”；

b. 在“D:\instantclient_11_2”目录下创建tnsnames.ora文本文件，从Oracle服务端的tnsnames.ora文本文件中拷贝需要用到的dsn（DataSourceName，数据源名称）；

c. 将该InstantClient解压目录D:\instantclient_11_2添加到环境变量path中；

d. 创建环境变量 name：TNS_ADMIN，value：D:\instantclient_11_2；

e. 创建环境变量 name：NLS_LANG， value:AMERICAN_AMERICA.ZHS16GBK；

注：对于Oracle数据库，可用第三方客户端查看能否正确连接该数据库

数据源名称：Oracle数据库的数据源，可从Oracle服务端的tnsnames.ora文件中获得。

数据源名称不得为空，最大长度64字节。

3、 数据源管理

数据源管理主要是配置分析图所需要的数据源信息，包括iHyperDB数据源和关系数据库数据源

在主界面点击数据源管理，弹出数据源列表配置框，如下图所示：

页面上方显示已经添加的数据源信息，包括数据源类型，数据源名称，数据源地址和描述；在选中某一条数据源记录后，界面下方配置数据源框中显示该数据源的详细配置信息，只读状态。

3.1添加数据源

点击右侧添加按钮，配置数据源框变为可编辑状态，如下图所示：

数据源类型：数据源类型暂时只支持配置实时数据库iHyperDB数据源；

数据源名称：用户自定义，作为区分数据源的唯一标识，最大长度为128个字节；

数据源IP： 数据源类型为iHyperDB时，数据源IP为实时数据库资源管理器服务所在的IP；

数据源端口：数据源类型为iHyperDB时，数据源端口为该实时数据库资源管理器服务的端口

描述：描述信息，最大长度256个字节；

清空：清空配置信息；

保存：保存配置信息，同时在界面上显示已经添加的数据源信息，配置框变为不可编辑状态；

3.2修改数据源

选中某一行记录，右侧修改按钮变为可用状态，同时下方详细信息显示选中的记录的详细信息。

点击修改按钮，配置数据源框变为可编辑状态，如下图所示：

可以修改数据源的数据源名称、数据源IP、数据源端口和描述；

点击保存按钮，保存配置信息。

3.3删除数据源

勾选要删除的数据源记录前方的复选框，点击右侧删除按钮，将弹出确认删除对话框

点击“确定”按钮，将删除所选数据源，点击“取消”取消删除操作。

注：有数据源正在使用中，则该数据源不能被删除

4、变量组管理

变量组管理可以根据用户自定义的规则将分析图中需要用到的变量添加到自定义分组中,便于分析图添加

在主界面点击变量组管理按钮,主界面显示配置界面,如下图所示:

页面左侧显示已经添加的变量组信息,包括变量组名称,所属数据源,表和描述信息。如果该数据源为实时数据库数据源，则表信息为空；

页面右侧显示某一条变量组记录下已经添加的字段信息列表，在选中一条变量组记录后显示

4.1添加变量组

点击变量组列表框中“添加”按钮，弹出添加变量组对话框

变量组名称：用户自定义，最大长度128个字节；

所属数据源：选择已经添加的数据源，如果数据源为实时数据库数据源，则表框图不启用，（关系数据库数据源暂时不使用）；

描述：用户自定义描述信息，最大长度256个字节

点击保存按钮，保存配置的变量组信息，取消按钮，取消保存。

4.2修改变量组

用户选中某一条变量组记录，点击修改按钮（没有选中记录，则修改按钮为灰色）

修改完成后点击确定，完成修改。

4.3删除变量组

用户勾选要删除的变量组前复选框，选择完毕后点击上方删除按钮弹出确认删除提示框，如下图所示：

点击确定按钮确定删除，取消按钮返回。

注：有变量组记录正在使用中时候不能被删除，弹出提示框如下图所示：

4.4添加字段

用户选中某一条变量组记录，此时包含字段列表框中显示该变量组下已经添加的字段信息，包括字段名称（Tag点名），字段别名，类型，描述，serverIP和serverPort，添加字段按钮由灰色变为可使用

点击添加字段按钮，弹出添加变量对话框，如下图所示：

界面左侧为该变量组所选数据源的资源管理树

选中某一根节点，勾选只显示当前分组复选框，点击查询按钮，查询结果显示当前选中分组下存在的所有Tag点

选中某一根节点，去掉勾选只显示当前分组复选框，点击查询按钮，查询结果显示当前分组以及子分组下所有的Tag点

勾选查询结果中需要添加的Tag点前的复选框，点击添加按钮添加变量字段。

注：如果选取的Tag点中有重复的Tag点，界面弹出提示框，如下图所示：

添加结束后返回到变量组界面，点击界面右下方保存按钮，保存添加的字段信息，否则新添加的字段信息不保存

4.5删除字段

用户勾选要删除的字段前复选框，选择完毕后点击上方删除按钮弹出确认删除提示框，如下图所示：

点击确定按钮确认删除，点击取消按钮返回。

注：如果要删除的字段记录在分析图中正在被使用，则无法被删除

5、 控制图配置

控制图配置主要用来配置控制图的各项信息，包括Xbar图和XbarR图

配置主界面如下图所示：

界面左侧为已经配置好的控制图名称树形展示，右侧为某一控制图详细的配置信息

5.1添加控制图

右键点击要添加的控制图类型根节点，显示右键菜单如下图所示：

当选中根节点类型Xbar和XbarR时，修改和删除菜单无效；

点击添加控制图菜单，此时右侧控制图配置信息框中变为可编辑状态，用户编辑需要添加的控制图信息

5.1.1基本信息

控制图名称：用户自定义，最大长度为128个字节；

变量组名称：选择变量组；

分析变量： 选择该变量组下的分析变量；在数据源为实时数据库iHyperDB时，即当前变量组下的Tag点

控制图描述：最大长度为256个字节；

注：用户没有配置变量组或者选择的变量组下没有添加分析变量时无法添加新的控制图

5.1.2样本及分组变量

样本及分组变量配置也如下图所示：

5.1.3指标

指标页面如下图所示：

控制类型可选双侧控制，上单侧控制和下单侧控制三种类型

显示指标一栏选择是否在界面上显示该显示指标

部分指标定义如下：

Cp：（Capability Indies of Process）工序能力指数，也称过程能力指数，是过程在受控状态下的实际加工能力；

Cpk：有偏移情况下的过程能力指数，即当产品质量特性值分布的均值与公差中心不重合有偏移时，不合格品率增大Cp值降低，因此需要加以修正，修正后的过程能力指数为Cpk；

Cpu：单侧公差情况下的过程能力指数，只有上限要求，没有下限要求，则过程能力指数称为Cpu；

Cpl：单侧公差情况下的过程能力指数，只有下限要求，没有上限要求，则过程能力指数称为Cpl；

Pp：（Performance Indies of Process）过程性能指数，反映了当前过程的性能男足标准与规范的程度，是对瞬时或实时过程性能的描述；

Ppk：性能指数，定义为Ppu和Ppl的最小值，又称为初期能力指数，其计算不需要过程稳定；

Ppu：上单侧过程性能指数，只有规格上限要求，没有规格下限要求，则过程性能指数称为Ppu；

Ppl：下单侧过程性能指数，只有规格下限要求，而对规格上限没有要求，则过程性能指数称为Ppl；

5.1.4判异准则

Xbar图判异准则界面如下图所示，判异准则中默认采用国标形式。右侧为选择判异准则连续性为连续判异或者非连续判异

XbarR图判异准则界面如下图所示：

“默认国标”按钮：将左侧判异类型国标全部选中到右侧已选准则中；

用户可以选中某一判异准则，点击相应箭头选择或删除该判异准则。

l 异常一:M点落在A区以外

l 异常二:连续M点在中心线的同一侧

l 异常三:连续M点递增或递减

l 异常四:连续M点中相邻点上下交替

l 异常五:连续M点中有N点落在中心线同一侧的B区以外

l 异常六:连续M点中有N点落在中心线同一侧的C区以外

l 异常七:连续M点在C区域中心线上下

l 异常八:连续M点在中心线两侧,但无一在C区域中

其中，当UCL-CL=CL-LCL时,A取B区C区示意如下图所示:

判异准则的一些说明:

l 连续判异

序 | 异常类型 | 判异说明 | 临界说明
1 | 一点落在A区以外 |  | 等于UCL或LCL值的点不作为该异常；
2 | 连续9点在中心线的同一侧 | 标注在异常发生的末点上；参与过判异的点，移位后可以继续参与判异 | 等于CL值的点不参与计算
3 | 连续6点递增或递减 | 同2 | 数值相等不计算在递增或递减范围内
4 | 连续14点中相邻点上下交替 | 同3 | 有连续点数据相等，不计算
5 | 连续3点中有2点落在中心线同一侧的B区以外 | 1、连续3点作为前提条件; 2、异常判别用2点落在中心线同一侧的B区以外规则； 3、标注在落在B区以外的第2点上，(连续进行标注)； | 数据值等于B区与A区分界线上，不计算在B区以外
6 | 连续5点中有4点落在中心线同一侧的C区以外 | 同5 | 同5
7 | 连续15点在C区域中心线上下 | 标注在第15点上，参与过该异常类型计算过的点，可以循环计算。 （注意：本判异是中心线上下，并不需要上下交替） | 数值全部在中心线上，算异常7； 数据值等于C区与B区值，计算在内
8 | 连续8点在中心线两侧，但无一在C区中 | 标注在第8点上，（在上下侧都计算在内，既可以在同一侧，也可以不在同一侧） | 数据值等于C区与B区值，不计算在内

l 非连续判异

序 | 异常类型 | 判异说明 | 临界说明
1 | 一点落在A区以外 |  | 等于UCL或LCL值的点不作为该异常；
2 | 连续9点在中心线的同一侧 | 标注在异常发生的末点上；参与过该异常类型计算过的点，不再循环计算；（即，第十点也满足该条件时，不计算在内，从第10点往后计算）； | 等于CL值的点不参与计算
3 | 连续6点递增或递减 | 同2 | 数值相等不计算在递增或递减范围内
4 | 连续14点中相邻点上下交替 | 同3 | 有连续点数据相等，不计算
5 | 连续3点中有2点落在中心线同一侧的B区以外 | 1、连续3点作为前提条件; 2、异常判别用2点落在中心线同一侧的B区以外规则； 3、标注在落在B区以外的第2点上，(每两点一组来标注)； | 数据值等于B区与A区分界线上，不计算在B区以外
6 | 连续5点中有4点落在中心线同一侧的C区以外 | 同5 | 同5
7 | 连续15点在C区域中心线上下 | 标注在第15点上，参与过该异常类型计算过的点，不再循环计算。 （注意：本判异是中心线上下，并不需要上下交替） | 数值全部在中心线上，算异常7； 数据值等于C区与B区值，计算在内
8 | 连续8点在中心线两侧，但无一在C区中 | 标注在第8点上，（在上下侧都计算在内，既可以在同一侧，也可以不在同一侧） | 数据值等于C区与B区值，不计算在内

5.1.5显示样式

显示样式界面如下图所示：

X轴标签和Y轴标签分别配置界面显示图形中横轴和纵轴的显示标签；

图例位置可选：顶部，底部和不显示；

控制点大小可选：小，中，大和微小

控制点形状可选：点，实心点等等；

5.1.6显示配置

显示配置界面如下图所示：

每项颜色均配置有默认值

用户在对每项内容进行配置完毕后，点击界面右下方保存按钮，保存配置的该控制图，如下图所示：

界面弹出保存成功提示，在左侧控制图树上显示添加的控制图名称

5.2修改控制图

在左侧控制图树中右键点击已经添加的控制图名称，选择修改菜单，如下图所示：

5.2修改控制图

在左侧控制图树中右键点击已经添加的控制图名称，选择修改菜单，如下图所示：

右侧控制图配置信息中变为可编辑状态，用户可编辑该控制图信息，编辑完成后点击右下方保存按钮，对修改后的信息进行保存。

5.3删除控制图

在左侧控制图树中右键点击已经添加的控制图名称，选择删除菜单，界面弹出确认删除提示框：

点击确定按钮，删除该控制图以及配置的属性信息，点击取消按钮取消。


ca_add_tag

Navigation: »No topics above this level«

ca_add_tag

 Return to chapter overview

ca_add_tag

Glossary Item Box

函数

添加计算点

int32 ca_add_tag(

HDHANDLE hServer,

const CalcTagProp* pTagProp,

int64 nPropMask

);

参数

hServer

[in] 服务器句柄。

pTagProp

[in] 指向计算点属性结构体的指针。

nPropMask

[in] 属性掩码。掩码必须包含TagName和TagType。

返回值

添加成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

举例

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

CalcTagProp calcTagSave;

CalcTagProp calcTagQuery;

const char* szTagName_1 = "szCalcTagName_1";

const char* szTagName_2 = "szCalcTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  normalTag.szTagName, normalTag.nTagID);

//add two calc tag

strcpy(calcTagSave.szTagName, szTagName_1);

calcTagSave.nTagType = TAG_TYPE_INT32;

calcTagSave.nCalcMode = HD_CALC_MODE_POLL;

calcTagSave.nCalcPeriod = 60;

sprintf(calcTagSave.szCalcExpr, "\'%s\' + 1", normalTag.szTagName);

nRet = ca_add_tag(hServer, &calcTagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE

 | TAG_PROP_CALC_PERIOD | TAG_PROP_CALC_MODE | TAG_PROP_CALC_EXPR);

if (nRet != RD_SUCCESS)

{

 printf("add calc tag[%s] failed, error code [%d]!\n", calcTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add calc tag[%s] successful!\n", calcTagSave.szTagName);

strcpy(calcTagSave.szTagName, szTagName_2);

calcTagSave.nTagType = TAG_TYPE_INT32;

calcTagSave.nCalcMode = HD_CALC_MODE_POLL;

calcTagSave.nCalcPeriod = 60;

sprintf(calcTagSave.szCalcExpr, "\'%s\' + 1", normalTag.szTagName);

nRet = ca_add_tag(hServer, &calcTagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE

 | TAG_PROP_CALC_PERIOD | TAG_PROP_CALC_MODE | TAG_PROP_CALC_EXPR);

if (nRet != RD_SUCCESS)

{

 printf("add calc tag[%s] failed, error code [%d]!\n", calcTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add calc tag[%s] successful!\n", calcTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_INT32);

nRet = ca_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query calc tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &calcTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query calc tag successful, tag name is %s!\n", calcTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query calc tag complete!\n");

  break;

 }

 else

 {

  printf("query calc tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you queried %d calc tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = ca_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query calc tag id failed, calc tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("calc tag[%s] query tag id successful,  calc tag id[%d]!\n",  szTagName_1, nTagID);

//modify tag desc

strcpy(calcTagSave.szDescriptor, "calc tag descriptor is modified");

nRet = ca_modify_tag_prop(hServer, nTagID, &calcTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify calc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify calc tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = ca_query_tag_prop(hServer, nTagID, &calcTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query calc tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query calc tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 calcTagQuery.nTagID, calcTagQuery.szTagName, calcTagQuery.szDescriptor);

//delete tag

nRet = ca_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete calc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete calc tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参考：

ca_query_tagid

ca query tags cond

ca_query_tag_name

ca_delete_tag

ca_modify_tag_prop

ca_query_tag_prop


ca_delete_tag

Navigation: »No topics above this level«

ca_delete_tag

 Return to chapter overview

ca_delete_tag

Glossary Item Box

函数

删除计算点

int32 ca_delete_tag(

HDHANDLE hServer,

uint32 nTagID);

参数

hServer

[in] 服务器句柄。

pTagID

[out] 计算点ID。

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

举例

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

CalcTagProp calcTagSave;

CalcTagProp calcTagQuery;

const char* szTagName_1 = "szCalcTagName_1";

const char* szTagName_2 = "szCalcTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

printf("query tag id failed, tag name[%s], error code[%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n", normalTag.szTagName, normalTag.nTagID);

//add two calc tag

strcpy(calcTagSave.szTagName, szTagName_1);

calcTagSave.nTagType = TAG_TYPE_INT32;

calcTagSave.nCalcMode = HD_CALC_MODE_POLL;

calcTagSave.nCalcPeriod = 60;

sprintf(calcTagSave.szCalcExpr, "\'%s\' + 1", normalTag.szTagName);

nRet = ca_add_tag(hServer, &calcTagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE

| TAG_PROP_CALC_PERIOD | TAG_PROP_CALC_MODE | TAG_PROP_CALC_EXPR);

if (nRet != RD_SUCCESS)

{

printf("add calc tag[%s] failed, error code [%d]!\n", calcTagSave.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add calc tag[%s] successful!\n", calcTagSave.szTagName);

strcpy(calcTagSave.szTagName, szTagName_2);

calcTagSave.nTagType = TAG_TYPE_INT32;

calcTagSave.nCalcMode = HD_CALC_MODE_POLL;

calcTagSave.nCalcPeriod = 60;

sprintf(calcTagSave.szCalcExpr, "\'%s\' + 1", normalTag.szTagName);

nRet = ca_add_tag(hServer, &calcTagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE

| TAG_PROP_CALC_PERIOD | TAG_PROP_CALC_MODE | TAG_PROP_CALC_EXPR);

if (nRet != RD_SUCCESS)

{

printf("add calc tag[%s] failed, error code [%d]!\n", calcTagSave.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add calc tag[%s] successful!\n", calcTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_INT32);

nRet = ca_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

printf("query calc tags by condition failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &calcTagQuery);

if (RD_SUCCESS == nRet)

{

nTagNum ++;

printf("query calc tag successful, tag name is %s!\n", calcTagQuery.szTagName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query calc tag complete!\n");

break;

}

else

{

printf("query calc tag failed, error code [%d]!\n", nRet);

break;

}

}

printf("you queried %d calc tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = ca_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

printf("query calc tag id failed, calc tag name[%s], error code[%d]!\n", szTagName_1, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[%s] query tag id successful, calc tag id[%d]!\n", szTagName_1, nTagID);

//modify tag desc

strcpy(calcTagSave.szDescriptor, "calc tag descriptor is modified");

nRet = ca_modify_tag_prop(hServer, nTagID, &calcTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

printf("modify calc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify calc tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = ca_query_tag_prop(hServer, nTagID, &calcTagQuery);

if (nRet != RD_SUCCESS)

{

printf("query calc tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("query calc tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

calcTagQuery.nTagID, calcTagQuery.szTagName, calcTagQuery.szDescriptor);

//delete tag

nRet = ca_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

printf("delete calc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("delete calc tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参考：

ca_add_tag

ca_query_tagid

ca query tags cond

ca_query_tag_name

ca_modify_tag_prop

ca_query_tag_prop


ca_modify_tag_prop

Navigation: »No topics above this level«

ca_modify_tag_prop

 Return to chapter overview

ca_modify_tag_prop

Glossary Item Box

函数

修改计算点属性

int32 ca_modify_tag_prop(

HDHANDLE hServer,

uint32 nTagID,

const CalcTagProp* pTagProp,

int64 nPropMask

);

参数

hServer

[in] 服务器句柄。

pTagProp

[in] 指向计算点属性结构体的指针。

nPropMask

[in] 属性掩码。掩码必须包含TagName和TagType。

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

举例

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

CalcTagProp calcTagSave;

CalcTagProp calcTagQuery;

const char* szTagName_1 = "szCalcTagName_1";

const char* szTagName_2 = "szCalcTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

printf("query tag id failed, tag name[%s], error code[%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n", normalTag.szTagName, normalTag.nTagID);

//add two calc tag

strcpy(calcTagSave.szTagName, szTagName_1);

calcTagSave.nTagType = TAG_TYPE_INT32;

calcTagSave.nCalcMode = HD_CALC_MODE_POLL;

calcTagSave.nCalcPeriod = 60;

sprintf(calcTagSave.szCalcExpr, "\'%s\' + 1", normalTag.szTagName);

nRet = ca_add_tag(hServer, &calcTagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE

| TAG_PROP_CALC_PERIOD | TAG_PROP_CALC_MODE | TAG_PROP_CALC_EXPR);

if (nRet != RD_SUCCESS)

{

printf("add calc tag[%s] failed, error code [%d]!\n", calcTagSave.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add calc tag[%s] successful!\n", calcTagSave.szTagName);

strcpy(calcTagSave.szTagName, szTagName_2);

calcTagSave.nTagType = TAG_TYPE_INT32;

calcTagSave.nCalcMode = HD_CALC_MODE_POLL;

calcTagSave.nCalcPeriod = 60;

sprintf(calcTagSave.szCalcExpr, "\'%s\' + 1", normalTag.szTagName);

nRet = ca_add_tag(hServer, &calcTagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE

| TAG_PROP_CALC_PERIOD | TAG_PROP_CALC_MODE | TAG_PROP_CALC_EXPR);

if (nRet != RD_SUCCESS)

{

printf("add calc tag[%s] failed, error code [%d]!\n", calcTagSave.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add calc tag[%s] successful!\n", calcTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_INT32);

nRet = ca_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

printf("query calc tags by condition failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &calcTagQuery);

if (RD_SUCCESS == nRet)

{

nTagNum ++;

printf("query calc tag successful, tag name is %s!\n", calcTagQuery.szTagName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query calc tag complete!\n");

break;

}

else

{

printf("query calc tag failed, error code [%d]!\n", nRet);

break;

}

}

printf("you queried %d calc tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = ca_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

printf("query calc tag id failed, calc tag name[%s], error code[%d]!\n", szTagName_1, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[%s] query tag id successful, calc tag id[%d]!\n", szTagName_1, nTagID);

//modify tag desc

strcpy(calcTagSave.szDescriptor, "calc tag descriptor is modified");

nRet = ca_modify_tag_prop(hServer, nTagID, &calcTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

printf("modify calc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify calc tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = ca_query_tag_prop(hServer, nTagID, &calcTagQuery);

if (nRet != RD_SUCCESS)

{

printf("query calc tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("query calc tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

calcTagQuery.nTagID, calcTagQuery.szTagName, calcTagQuery.szDescriptor);

//delete tag

nRet = ca_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

printf("delete calc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("delete calc tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参考：

ca_add_tag

ca_query_tagid

ca query tags cond

ca_query_tag_name

ca_delete_tag

ca_query_tag_prop


ca_query_tag_name

Navigation: »No topics above this level«

ca_query_tag_name

 Return to chapter overview

ca_query_tag_name

Glossary Item Box

函数

根据计算点ID查询计算点名称

int32 ca_query_tag_name(

HDHANDLE hServer,

uint32 nTagID,

char* szName

);

参数

hServer

[in] 服务器句柄。

pTagID

[out] 计算点ID。

szTagName

[in] 计算点名称。

返回值

添加成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

举例

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

CalcTagProp calcTagSave;

CalcTagProp calcTagQuery;

const char* szTagName_1 = "szCalcTagName_1";

const char* szTagName_2 = "szCalcTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

printf("query tag id failed, tag name[%s], error code[%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n", normalTag.szTagName, normalTag.nTagID);

//add two calc tag

strcpy(calcTagSave.szTagName, szTagName_1);

calcTagSave.nTagType = TAG_TYPE_INT32;

calcTagSave.nCalcMode = HD_CALC_MODE_POLL;

calcTagSave.nCalcPeriod = 60;

sprintf(calcTagSave.szCalcExpr, "\'%s\' + 1", normalTag.szTagName);

nRet = ca_add_tag(hServer, &calcTagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE

| TAG_PROP_CALC_PERIOD | TAG_PROP_CALC_MODE | TAG_PROP_CALC_EXPR);

if (nRet != RD_SUCCESS)

{

printf("add calc tag[%s] failed, error code [%d]!\n", calcTagSave.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add calc tag[%s] successful!\n", calcTagSave.szTagName);

strcpy(calcTagSave.szTagName, szTagName_2);

calcTagSave.nTagType = TAG_TYPE_INT32;

calcTagSave.nCalcMode = HD_CALC_MODE_POLL;

calcTagSave.nCalcPeriod = 60;

sprintf(calcTagSave.szCalcExpr, "\'%s\' + 1", normalTag.szTagName);

nRet = ca_add_tag(hServer, &calcTagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE

| TAG_PROP_CALC_PERIOD | TAG_PROP_CALC_MODE | TAG_PROP_CALC_EXPR);

if (nRet != RD_SUCCESS)

{

printf("add calc tag[%s] failed, error code [%d]!\n", calcTagSave.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add calc tag[%s] successful!\n", calcTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_INT32);

nRet = ca_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

printf("query calc tags by condition failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &calcTagQuery);

if (RD_SUCCESS == nRet)

{

nTagNum ++;

printf("query calc tag successful, tag name is %s!\n", calcTagQuery.szTagName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query calc tag complete!\n");

break;

}

else

{

printf("query calc tag failed, error code [%d]!\n", nRet);

break;

}

}

printf("you queried %d calc tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = ca_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

printf("query calc tag id failed, calc tag name[%s], error code[%d]!\n", szTagName_1, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[%s] query tag id successful, calc tag id[%d]!\n", szTagName_1, nTagID);

//modify tag desc

strcpy(calcTagSave.szDescriptor, "calc tag descriptor is modified");

nRet = ca_modify_tag_prop(hServer, nTagID, &calcTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

printf("modify calc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify calc tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = ca_query_tag_prop(hServer, nTagID, &calcTagQuery);

if (nRet != RD_SUCCESS)

{

printf("query calc tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("query calc tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

calcTagQuery.nTagID, calcTagQuery.szTagName, calcTagQuery.szDescriptor);

//delete tag

nRet = ca_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

printf("delete calc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("delete calc tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参考：

ca_add_tag

ca_query_tagid

ca query tags cond

ca_delete_tag

ca_modify_tag_prop

ca_query_tag_prop


ca_query_tag_prop

Navigation: »No topics above this level«

ca_query_tag_prop

 Return to chapter overview

ca_query_tag_prop

Glossary Item Box

函数

条件查询计算点属性

int32 ca_query_tag_prop(

HDHANDLE hServer,

uint32 nTagID,

CalcTagProp* pTagProp

);

参数

hServer

[in]服务器句柄

nTagID

[in]计算点ID

pTagProp

[in] 指向计算点属性结构体的指针。

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

举例

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

CalcTagProp calcTagSave;

CalcTagProp calcTagQuery;

const char* szTagName_1 = "szCalcTagName_1";

const char* szTagName_2 = "szCalcTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

printf("query tag id failed, tag name[%s], error code[%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n", normalTag.szTagName, normalTag.nTagID);

//add two calc tag

strcpy(calcTagSave.szTagName, szTagName_1);

calcTagSave.nTagType = TAG_TYPE_INT32;

calcTagSave.nCalcMode = HD_CALC_MODE_POLL;

calcTagSave.nCalcPeriod = 60;

sprintf(calcTagSave.szCalcExpr, "\'%s\' + 1", normalTag.szTagName);

nRet = ca_add_tag(hServer, &calcTagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE

| TAG_PROP_CALC_PERIOD | TAG_PROP_CALC_MODE | TAG_PROP_CALC_EXPR);

if (nRet != RD_SUCCESS)

{

printf("add calc tag[%s] failed, error code [%d]!\n", calcTagSave.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add calc tag[%s] successful!\n", calcTagSave.szTagName);

strcpy(calcTagSave.szTagName, szTagName_2);

calcTagSave.nTagType = TAG_TYPE_INT32;

calcTagSave.nCalcMode = HD_CALC_MODE_POLL;

calcTagSave.nCalcPeriod = 60;

sprintf(calcTagSave.szCalcExpr, "\'%s\' + 1", normalTag.szTagName);

nRet = ca_add_tag(hServer, &calcTagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE

| TAG_PROP_CALC_PERIOD | TAG_PROP_CALC_MODE | TAG_PROP_CALC_EXPR);

if (nRet != RD_SUCCESS)

{

printf("add calc tag[%s] failed, error code [%d]!\n", calcTagSave.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add calc tag[%s] successful!\n", calcTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_INT32);

nRet = ca_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

printf("query calc tags by condition failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &calcTagQuery);

if (RD_SUCCESS == nRet)

{

nTagNum ++;

printf("query calc tag successful, tag name is %s!\n", calcTagQuery.szTagName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query calc tag complete!\n");

break;

}

else

{

printf("query calc tag failed, error code [%d]!\n", nRet);

break;

}

}

printf("you queried %d calc tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = ca_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

printf("query calc tag id failed, calc tag name[%s], error code[%d]!\n", szTagName_1, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[%s] query tag id successful, calc tag id[%d]!\n", szTagName_1, nTagID);

//modify tag desc

strcpy(calcTagSave.szDescriptor, "calc tag descriptor is modified");

nRet = ca_modify_tag_prop(hServer, nTagID, &calcTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

printf("modify calc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify calc tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = ca_query_tag_prop(hServer, nTagID, &calcTagQuery);

if (nRet != RD_SUCCESS)

{

printf("query calc tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("query calc tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

calcTagQuery.nTagID, calcTagQuery.szTagName, calcTagQuery.szDescriptor);

//delete tag

nRet = ca_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

printf("delete calc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("delete calc tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参考：

ca_add_tag

ca_query_tagid

ca query tags cond

ca_query_tag_name

ca_delete_tag

ca_modify_tag_prop


ca_query_tagid

Navigation: »No topics above this level«

ca_query_tagid

 Return to chapter overview

ca_query_tagid

Glossary Item Box

函数

查询计算点ID

int32 ca_query_tagid(

HDHANDLE hServer,

const char* szName,

uint32* pTagID

);

参数

hServer

[in] 服务器句柄。

szTagName

[in] 计算点名称。

pTagID

[out] 计算点ID。

返回值

添加成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

举例

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

CalcTagProp calcTagSave;

CalcTagProp calcTagQuery;

const char* szTagName_1 = "szCalcTagName_1";

const char* szTagName_2 = "szCalcTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

printf("query tag id failed, tag name[%s], error code[%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n", normalTag.szTagName, normalTag.nTagID);

//add two calc tag

strcpy(calcTagSave.szTagName, szTagName_1);

calcTagSave.nTagType = TAG_TYPE_INT32;

calcTagSave.nCalcMode = HD_CALC_MODE_POLL;

calcTagSave.nCalcPeriod = 60;

sprintf(calcTagSave.szCalcExpr, "\'%s\' + 1", normalTag.szTagName);

nRet = ca_add_tag(hServer, &calcTagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE

| TAG_PROP_CALC_PERIOD | TAG_PROP_CALC_MODE | TAG_PROP_CALC_EXPR);

if (nRet != RD_SUCCESS)

{

printf("add calc tag[%s] failed, error code [%d]!\n", calcTagSave.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add calc tag[%s] successful!\n", calcTagSave.szTagName);

strcpy(calcTagSave.szTagName, szTagName_2);

calcTagSave.nTagType = TAG_TYPE_INT32;

calcTagSave.nCalcMode = HD_CALC_MODE_POLL;

calcTagSave.nCalcPeriod = 60;

sprintf(calcTagSave.szCalcExpr, "\'%s\' + 1", normalTag.szTagName);

nRet = ca_add_tag(hServer, &calcTagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE

| TAG_PROP_CALC_PERIOD | TAG_PROP_CALC_MODE | TAG_PROP_CALC_EXPR);

if (nRet != RD_SUCCESS)

{

printf("add calc tag[%s] failed, error code [%d]!\n", calcTagSave.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add calc tag[%s] successful!\n", calcTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_INT32);

nRet = ca_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

printf("query calc tags by condition failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &calcTagQuery);

if (RD_SUCCESS == nRet)

{

nTagNum ++;

printf("query calc tag successful, tag name is %s!\n", calcTagQuery.szTagName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query calc tag complete!\n");

break;

}

else

{

printf("query calc tag failed, error code [%d]!\n", nRet);

break;

}

}

printf("you queried %d calc tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = ca_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

printf("query calc tag id failed, calc tag name[%s], error code[%d]!\n", szTagName_1, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[%s] query tag id successful, calc tag id[%d]!\n", szTagName_1, nTagID);

//modify tag desc

strcpy(calcTagSave.szDescriptor, "calc tag descriptor is modified");

nRet = ca_modify_tag_prop(hServer, nTagID, &calcTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

printf("modify calc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify calc tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = ca_query_tag_prop(hServer, nTagID, &calcTagQuery);

if (nRet != RD_SUCCESS)

{

printf("query calc tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("query calc tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

calcTagQuery.nTagID, calcTagQuery.szTagName, calcTagQuery.szDescriptor);

//delete tag

nRet = ca_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

printf("delete calc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("delete calc tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参考：

ca_add_tag

ca query tags cond

ca_query_tag_name

ca_delete_tag

ca_modify_tag_prop

ca_query_tag_prop


ca query tags cond

Navigation: »No topics above this level«

ca query tags cond

 Return to chapter overview

ca query tags cond

Glossary Item Box

函数

条件查询统计点属性

int32 ca_query_tags_cond(

HDHANDLE hServer,

QueryTagPropItem pQueryItems[],

int32 nQueryItemNum,

int64 nPropMask,

HDHANDLE* pHIter

);

参数

hServer

[in]服务器句柄

pQueryItems[]

[in]查询条件项

nQueryItemNum

[in]查询条件项个数

nPropMask

[in]查询信息掩码，控制返回的统计点的哪些属性

pHIter

[out]查询迭代器

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

举例

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

CalcTagProp calcTagSave;

CalcTagProp calcTagQuery;

const char* szTagName_1 = "szCalcTagName_1";

const char* szTagName_2 = "szCalcTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

printf("query tag id failed, tag name[%s], error code[%d]!\n", normalTag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n", normalTag.szTagName, normalTag.nTagID);

//add two calc tag

strcpy(calcTagSave.szTagName, szTagName_1);

calcTagSave.nTagType = TAG_TYPE_INT32;

calcTagSave.nCalcMode = HD_CALC_MODE_POLL;

calcTagSave.nCalcPeriod = 60;

sprintf(calcTagSave.szCalcExpr, "\'%s\' + 1", normalTag.szTagName);

nRet = ca_add_tag(hServer, &calcTagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE

| TAG_PROP_CALC_PERIOD | TAG_PROP_CALC_MODE | TAG_PROP_CALC_EXPR);

if (nRet != RD_SUCCESS)

{

printf("add calc tag[%s] failed, error code [%d]!\n", calcTagSave.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add calc tag[%s] successful!\n", calcTagSave.szTagName);

strcpy(calcTagSave.szTagName, szTagName_2);

calcTagSave.nTagType = TAG_TYPE_INT32;

calcTagSave.nCalcMode = HD_CALC_MODE_POLL;

calcTagSave.nCalcPeriod = 60;

sprintf(calcTagSave.szCalcExpr, "\'%s\' + 1", normalTag.szTagName);

nRet = ca_add_tag(hServer, &calcTagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE

| TAG_PROP_CALC_PERIOD | TAG_PROP_CALC_MODE | TAG_PROP_CALC_EXPR);

if (nRet != RD_SUCCESS)

{

printf("add calc tag[%s] failed, error code [%d]!\n", calcTagSave.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add calc tag[%s] successful!\n", calcTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_INT32);

nRet = ca_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

printf("query calc tags by condition failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &calcTagQuery);

if (RD_SUCCESS == nRet)

{

nTagNum ++;

printf("query calc tag successful, tag name is %s!\n", calcTagQuery.szTagName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query calc tag complete!\n");

break;

}

else

{

printf("query calc tag failed, error code [%d]!\n", nRet);

break;

}

}

printf("you queried %d calc tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = ca_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

printf("query calc tag id failed, calc tag name[%s], error code[%d]!\n", szTagName_1, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[%s] query tag id successful, calc tag id[%d]!\n", szTagName_1, nTagID);

//modify tag desc

strcpy(calcTagSave.szDescriptor, "calc tag descriptor is modified");

nRet = ca_modify_tag_prop(hServer, nTagID, &calcTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

printf("modify calc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify calc tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = ca_query_tag_prop(hServer, nTagID, &calcTagQuery);

if (nRet != RD_SUCCESS)

{

printf("query calc tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("query calc tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

calcTagQuery.nTagID, calcTagQuery.szTagName, calcTagQuery.szDescriptor);

//delete tag

nRet = ca_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

printf("delete calc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("delete calc tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参考：

ca_add_tag

ca_query_tagid

ca_query_tag_name

ca_delete_tag

ca_modify_tag_prop

ca_query_tag_prop


计算点管理接口

Navigation: »No topics above this level«

计算点管理接口

 Return to chapter overview

计算点管理接口

Glossary Item Box

《计算点管理接口》主要接口包括：

?ca_add_tag

?ca_query_tagid

?ca_query_tag_name

?ca_delete_tag

?ca_modify_tag_prop

?ca_query_tag_prop

©2015. All Rights Reserved.


集群冗余

Navigation: »No topics above this level«

集群冗余

 Return to chapter overview

集群冗余

Glossary Item Box

©2015. All Rights Reserved.


com_convert_bstr_2_time

Navigation: »No topics above this level«

com_convert_bstr_2_time

 Return to chapter overview

com_convert_bstr_2_time

Glossary Item Box

函数

STDMETHOD (com_convert_bstr_2_time)(

BSTRbsTime,

VARIANT* nSec,

VARIANT* nMsec,

LONG* nRetErr

);

参数

[in]BSTR bsTime, 时间字符串

[out]VARIANT* nSec, 时间秒，类型是LONG

[in]VARIANT* nMsec, 时间毫秒，类型是LONG

[out,retval]LONG* nRetErr，返回值

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

把字符串类型的时间转为数字。所有用到服务器句柄的输入输出参数都是以数字类型的时间来传递的，因此需要将普通的字符串类型的时间如“1981-04-23 19:32:09.683”和1379310469这样的的数字时间进行互相转换。

举例

!MISSING PHRASE 'COPYCODE'!

Set objArray= CreateObject("hdCOMInterface.hdCOMClass.1")

Dim nSec,nMsec,bsTime,ret

bsTime="2013-09-16 13:47:49"

ret = objArray.com_convert_bstr_2_time (bsTime,nSec,nMsec)

Msgbox "errcode is:" &ret

Msgbox "bsTime is:" &bsTime

Msgbox "nSec is:" &nSec

Msgbox "nMsec is:" &nMsec

Set objArray= nothing

?参见：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


com_convert_time_2_bstr

Navigation: »No topics above this level«

com_convert_time_2_bstr

 Return to chapter overview

com_convert_time_2_bstr

Glossary Item Box

函数

STDMETHOD (com_convert_time_2_bstr)(

LONGnSec,

LONGnMsec,

VARIANT* bsTime,

LONG* nRetErr

);

参数

[in]LONG nSec, 秒

[in]LONG nMsec,毫秒

[out]VARIANT* bsTime,时间字符串，类型是BSTR

[out,retval]LONG* nRetErr，返回值

返回值

查询成功，返回RD_SUCCESS，不是所有的都成功返回EC_HD_API_QUERY_SNAPSHOTS_FAILED。查询失败返回其它错误码，见error_code.h。

说明

把数字类型的时间转为字符串。所有用到服务器句柄的输入输出参数都是以数字类型的时间来传递的，因此需要将普通的字符串类型的时间如“1981-04-23 19:32:09.683”和1379310469这样的的数字时间进行互相转换。

举例

!MISSING PHRASE 'COPYCODE'!

Set objArray= CreateObject("hdCOMInterface.hdCOMClass.1")

Dim nSec,nMsec,bsTime,ret

nSec=1379310469

nMsec=123

ret = objArray.com_convert_time_2_bstr (nSec,nMsec,bsTime)

Msgbox "errcode is:" &ret

Msgbox "nSec is:" &nSec

Msgbox "nMsec is:" &nMsec

Msgbox "bsTime is:" &bsTime

Set objArray= nothing

?参见：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


分组客户端配置

Navigation: »No topics above this level«

分组客户端配置

 Return to chapter overview

分组客户端配置

Glossary Item Box

分组客户端配置用来设置本地客户端需要访问的分组服务所在机器的地址。

点击分组管理--分组客户端配置，进入浏览界面，如下图：

界面显示分组服务端的IP和端口号。界面上右击，弹出菜单，点击刷新，刷新该界面。

若要修改IP/端口号，点击修改按钮，进入修改界面：

单击确定，进入确定提示界面：

单击确定，完成修改，界面显示新的服务端信息。

关于刷新：

进行分组客户端配置后，若正在进行变量分组配置，须刷新变量分组配置。

进行分组客户端配置后，若正在进行关联数据源信息浏览，须刷新关联数据源信息。


ConfigCenter配置中心优化

Navigation: »No topics above this level«

ConfigCenter配置中心优化

 Return to chapter overview

·sqlapi++接口替换为sqlite

·部分消息的处理直接从缓存获取

·sql语句优化

·主备配置不一致问题

·增加可缓存项

·Configcenter权限缓存

·权限视图v_resource_tag优化

sqlapi++接口替换为sqlite

1.封装SqliteCommand类，取代原来的SACommand类, 在调用处可以直接替换。

代码替换示例：

SqliteCommand代码：

封装Execute, 如果是select语句，则调用sqlite3_prepare， 否则启动事务并且调用sqlite3_exec.

支持事务的提交和回滚

2.封装SqliteException，可直接替换原有的SAExecption.

3.对于大数据，多个字段大数据查询需要重新封装Copy函数代替原来的SqlapiCopier中的函数以提高查询效率。

例如SqliteHandler::Copy函数代SqliteCopier::copy函数

static void copy(C3PtTag& dst, C3Mask& mask, SqliteCommand& src) throw (SqliteException);

void SqliteHandler::Copy(C3PtTag& dst, C3Mask& mask,SqliteCommand& cmd) throw (SqliteException)

部分消息的处理直接从缓存获取

1.在进程启动初始化的时候，将数据库的表保存到缓存。

2.在添加或则删除更改数据库的时候，将数据库更改的内容更新到缓存。

3.部分消息处理，启动单独的线程，从缓存读取数据。

sql语句优化

1.用select count(id)之类的代码代替select count(*)

2.尽量少用select(*)

主备配置不一致问题

不需要的代码清理

♦ imv配置

♦ 部分cccmd

增加可缓存项

♦ 用户、连接登录信息

♦ name2id

♦ tagversion

Configcenter权限缓存

优化带权限的查询，不再使用v_resource_tag视图，条件查点保持原来使用SQL筛选出点，然后通过configcenter的权限缓存，判断符合条件的点，用户是否有权限查看。

Configcenter权限缓存参照SecurityServer修改，在configcenter同样实现SecurityServer功能，只是把netmgr对数据权限判断改成对配置权限判断，并根据需求修改权限判断接口。ConfigCenter收到权限修改时同样对权限缓存进行更新。

权限视图v_resource_tag优化

由于v_resource_tag文件过大，导致查询效率非常低。采用分级查询的方式，可以提高查询效率。

·条件查询带有权限的点数

1.根据userid在t_usergroup查找groupid

select groupid from t_usergroup where userid=16 and deleted=0

2.根据groupid在t_groupresourcegroup 查找resourcegroupid

select resourcegroupid from t_groupresourcegroup where groupid IN (15) and deleted=0

3.在t_resourcegroup根据accesstype过滤resourcegroupid

select id from t_resourcegroup where id IN (26) and deleted=0 and accesstype in(5,7)

4.根据resourcegroupid查找所有tagid集合tagidVec

select tagid from t_tagresourcegroup where deleted = 0 and (resourcegroupid=26)

5.根据tagid的范围在v_tag表中条件查询所有tagid集合allTagidsVec

select id from v_tag where id>=213542 and id<=216539 and deleted=0 and tagclass = 0

6.获取两个tagid集合的交集，其大小就是查询的点数。

std::set_intersection(tagidVec.begin(), tagidVec.end(),

allTagidsVec.begin(), allTagidsVec.end(),

std::back_inserter(common));

count=common.size();

·条件查询带有权限的点属性

1.根据userid在t_usergroup查找groupid

select groupid from t_usergroup where userid=16 and deleted=0

2.根据groupid在t_groupresourcegroup 查找resourcegroupid

select resourcegroupid from t_groupresourcegroup where groupid IN (15) and deleted=0

3.在t_resourcegroup根据accesstype过滤resourcegroupid

select id from t_resourcegroup where id IN (26) and deleted=0 and accesstype in(5,7)

7.根据resourcegroupid查找所有tagid集合tagidVec

select tagid from t_tagresourcegroup where deleted = 0 and (resourcegroupid=26)

8.根据start_id,limit等条件查询点的内容，如果发现点不在tagidVec中则不做处理，如果在则添加到返回的vector里面。vector的size达到limit，则结束本次查询。

select id , name , archiving , changedate , changer , compdev , compmaxtime , comptype , creationdate , creator , recaccess , recnormalgroup , recownergroup , description , digitalset , engunits , excmaxtime , excdev , tagtype , tagaccess , tagnormalgroup , tagownergroup , scan , span , minvalue , tagclass , tagstatus , param1 , param2 , param3 , param4 , param5 , opcrelease , imvparam , strparam1 , strparam2 , instrumentpoint , instrumentpointtype , collectorname , collectorid , devicename , deviceid , scangroupname , scangroupid , byteorder from v_tag where id >= 213542 and deleted=0 and tagclass != 1 and tagclass != 2 and tagclass != 3 and tagclass != 4 order by id asc


重新登录

Navigation: »No topics above this level«

重新登录

 Return to chapter overview

连接信息

功能明细 > 数据展示 > 电子表格 > 服务器连接管理器 > 连接信息

Glossary Item Box

使用不同的用户名连接服务器???/text>

在“客户端”中可看到这个服务器的连接用户名为admin

在该对话框右侧点击重新登陆

弹出“用户登录”窗口输入新的用户名和密码

点击确定，可看到“连接信息”页面的"连接用户变为user

点击“重新登录”后的“用户登录”界中，输入的用户名和密码是在“系统管理平台”中的“权限”→“用户与组”→“用户已经添加”的用户

API接口为：int32 sdkdialog_connect_info(SDKServerInfo *pSrvInfo);

??015. All Rights Reserved.


新建转储规则

Navigation: »No topics above this level«

新建转储规则

 Return to chapter overview

新建转储规则

Glossary Item Box

本节介绍“新建转储规则”的转储配置以及注意事项。

1.输入转储规则名，记录起始时间，记录间隔，执行起始时间，执行周期；

?记录起始时间和执行起始时间可以设置的最小时间点为1970-01-01 00：00：00，最大时间点为2038-1-19 03:14:06。

2. 点击“置为当前时间” 起始时间会置为当前时间；

3. 点击添加Tag，弹出Tag搜索界面，选择Tag后导入到Tag显示列表上；

?Tag显示列表显示了Tag的iHyperDB源、Tag名、Tag类型、Tag描述信息。

4.选中列表中的Tag,点击删除Tag，可以删除规则中的Tag；

5.点击确定，新建规则成功，点击取消，取消新建规则操作。

?若对应的表为窄表，新建规则成功后，会弹出匹配宽表字段的界面，用户需要进行字段匹配。

1. 规则中添加的Tag点数的最大上限为100；

2. 若转储方向为从关系数据库到实时数据库，则转储不关心记录间隔，记录间隔设置会变灰。


新建转储表

Navigation: »No topics above this level«

新建转储表

 Return to chapter overview

新建转储表

Glossary Item Box

本节介绍在关系数据库中“新建转储表”的转储配置以及注意事项：

表名和字段名均不得为关系数据库关键字。

1. 输入表名；

2. 选择或输入字段名，字段类型，字段长度，点击"+"按钮；字段类型包括int、 smallint、 real、 varchar、 datetime；

3. 表框中显示已经添加的字段信息；

4. 选择表框中需要删除的字段信息，点击"-"按钮，表框中删除了该字段信息；

5. 点击确定，新建表成功，回到添加表界面；字段信息和表名信息必须遵从关系数据库的规则设置，若由于字段信息 表名信息等错误导致创建表失败，则弹出提示信息。

6. 添加表界面中显示的“数据库中存在表”列表框中包含了刚新建的表。


信任

Navigation: »No topics above this level«

信任

 Return to chapter overview

信任

Glossary Item Box

《信任》中的主要接口包括：

?sc_add_trust

?sc_delete_trust

?sc_query_all_trusts

某一些客户端的访问无须使用用户帐号登陆，即可拥有特定的权限。通过将IP范围段与用户之间进行关联来实现这个功能，添加信任时，可以设置起始IP和终止IP，使其对应一位用户。

数据定义

/** iHyperDB 权限管理: 信任 */

typedef struct _HDSecTrust

{

char szTrustName[HD_LEN_SEC_TRUST_NAME];

char szStartIp[HD_LEN_SEC_IP_ADDRESS];

char szEndIp[HD_LEN_SEC_IP_ADDRESS];

char szUserName[HD_LEN_SEC_USER_NAME];

}HDSecTrust;

注意：

1.创建信任时所有信息均可以自行指定，但是最大长度有相应的限制，具体HD_LEN_SEC_TRUST_NAME、HD_LEN_SEC_IP_ADDRESS、HD_LEN_SEC_USER_NAME指定。

2.不同的信任之间在IP指定时不能有交集。

3.对应的用户必须是服务器已有用户。


ct_add_collector

Navigation: »No topics above this level«

ct_add_collector

 Return to chapter overview

ct_add_collector

Glossary Item Box

函数

添加一个采集器

int32 ct_add_collector(

HDHANDLE hServer,

HDCollector *pCollector

);

参数

hServer

[in] 服务器句柄。

pCollector

[in] 采集器结构体指针。

返回值

用户登录成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

说明

举例

collector

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

HDHANDLE hIter = NULL;

int32 nTimeOut = 3;

uint32 nCollectorID = 0;

HDCollector hdCollectors[3];

HDCollector hdCollector;

int32 i = 0;

int32 nCollectorNum = 2;

for (i = 0; i < nCollectorNum; ++i)

{

 memset(&hdCollectors[i], 0, sizeof(HDCollector));

}

memset(&hdCollector, 0, sizeof(HDCollector));

for (i = 0; i < nCollectorNum; ++i)

{

 sprintf(hdCollectors[i].szName, "collector%d", i);

 hdCollectors[i].nType = COLLECTOR_TYPE_OPC;

 sprintf(hdCollectors[i].szDescription, "name: %s, type: %d", hdCollectors[i].szName, hdCollectors[i].nType);

 strncpy(hdCollectors[i].szExtParam, "***", 3);

}

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

// add collector

for (i = 0; i < nCollectorNum; ++i)

{

 nRet = ct_add_collector(hServer, &hdCollectors[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add collector[name:%s] failed, error code [%d]!\n", hdCollectors[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add collector[name:%s] successful!\n", hdCollectors[i].szName);

}

//query collector id by name, query collector, modify collector

for (i = 0; i < nCollectorNum; ++i)

{

 nRet = ct_query_collector_id_by_name(hServer, hdCollectors[i].szName, &nCollectorID);

 if (nRet != RD_SUCCESS)

 {

  printf("query collector id  by name[%s] failed, error code [%d]!\n", hdCollectors[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query collector id  by name[%s] successful, collector id  [%d].\n", hdCollectors[i].szName, nCollectorID);

 nRet = ct_query_collector(hServer, nCollectorID, &hdCollectors[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query collector [id:%d] failed, error code [%d]!\n", nCollectorID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query collector [id:%d] successful.\n", nCollectorID);

 nRet = ct_modify_collector(hServer, nCollectorID, &hdCollectors[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify collector [id:%d] failed, error code [%d]!\n", nCollectorID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify collector [id:%d] successful.\n", nCollectorID);

}

//query all collector

nRet = ct_query_all_collectors(hServer, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all collectors failed,  error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query all collectors successful!\n");

while (true)

{

 memset(&hdCollector, 0, sizeof(HDCollector));

 nRet = ut_get_item_step(hIter, &hdCollector);

 if (RD_SUCCESS == nRet)

 {

  printf("Query one collector [name:%s] successful!\n", hdCollector.szName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query all collector complete!\n");

  break;

 }

 else

 {

  printf("query collector failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

// delete collector

for (i = 0; i < nCollectorNum; ++i)

{

 nRet = ct_delete_collector(hServer, hdCollectors[i].nID);

 if (nRet != RD_SUCCESS)

 {

  printf("delete collector failed,  error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete collector [id:%d] successful.\n",  hdCollectors[i].nID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

?ct_add_collector

?ct_delete_collector

?ct_query_all_collectors

?ct_query_collector

?ct_query_collector_id_by_name

?ct_modify_collector

©2015. All Rights Reserved.


ct_add_device

Navigation: »No topics above this level«

ct_add_device

 Return to chapter overview

ct_add_device

Glossary Item Box

函数

添加一个设备

int32 ct_add_device(

HDHANDLE hServer,

HDDevice *pDevice

);

参数

hServer

[in] 服务器句柄。

pDevice

[in] 新增设备。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

device

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

HDHANDLE hIter = NULL;

int32 nTimeOut = 3;

int32 nTryTime = 3;

uint32 nCollectorID = 0;

uint32 nDeviceID = 0;

HDCollector hdCollector;

HDDevice hdDevice;

HDDevice hdDevices[3];

int32 i = 0;

int32 nDeviceNum = 3;

memset(&hdCollector, 0, sizeof(HDCollector));

memset(&hdDevice, 0, sizeof(HDDevice));

for (i = 0; i < 3; ++i)

{

 memset(&hdDevices[i], 0, sizeof(HDDevice));

}

strncpy(hdCollector.szName, "collector", strlen("collector"));

hdCollector.nType = COLLECTOR_TYPE_OPC;

sprintf(hdCollector.szDescription, "name: %s, type: %d", hdCollector.szName, hdCollector.nType);

strncpy(hdCollector.szExtParam, "***", 3);

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add collector

nRet = ct_add_collector(hServer, &hdCollector);

if (nRet != RD_SUCCESS)

{

 printf("add collector[name:%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add collector[name:%s] successful!\n", hdCollector.szName);

//query collector id

nRet = ct_query_collector_id_by_name(hServer, hdCollector.szName, &nCollectorID);

if (nRet != RD_SUCCESS)

{

 printf("query collector id  by name[%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query collector id  by name[%s] successful, collector id  [%d].\n", hdCollector.szName, nCollectorID);

// add device

for (i = 0; i < nDeviceNum; ++i)

{

 sprintf(hdDevices[i].szName, "device%d", i);

 hdDevices[i].nPort = nPort;

 hdDevices[i].nTimeout = nTimeOut;

 hdDevices[i].nCollectorID = nCollectorID;

 hdDevices[i].nTryTime = nTryTime;

 sprintf(hdDevices[i].szAddr, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdDevices[i].szDescription, "name: %s, collector id: %d", hdDevices[i].szName, hdDevices[i].nCollectorID);

 strncpy(hdDevices[i].szExtParam, "***", 3);

}

for (i = 0; i < nDeviceNum; ++i)

{

 nRet = ct_add_device(hServer, &hdDevices[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add device[name:%s] failed, error code [%d]!\n", hdDevices[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add device[name:%s] successful!\n", hdDevices[i].szName);

}

//query device id , query device, modify device

for (i = 0; i < nDeviceNum; ++i)

{

 nRet = ct_query_device_id_by_name(hServer, nCollectorID, hdDevices[i].szName, &nDeviceID);

 if (nRet != RD_SUCCESS)

 {

  printf("query device id  by name[%s] failed, error code [%d]!\n", hdDevices[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query device id  by name[%s] successful, device id  [%d].\n", hdDevices[i].szName, nDeviceID);

 nRet = ct_query_device(hServer, nDeviceID, &hdDevices[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query device [id:%d] failed, error code [%d]!\n", nDeviceID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query device [id:%d] successful.\n", nDeviceID);

 nRet = ct_modify_device(hServer, nDeviceID, &hdDevices[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify device [id:%d] failed, error code [%d]!\n", nDeviceID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify device [id:%d] successful.\n", nDeviceID);

}

//query devices belong to the collector

nRet = ct_query_devices_of_collector(hServer, nCollectorID, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all device of collector[id: %d] failed,  error code [%d]!\n", nCollectorID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query all device of collector[id: %d] successful!\n", nCollectorID);

while (true)

{

 memset(&hdDevice, 0, sizeof(HDDevice));

 nRet = ut_get_item_step(hIter, &hdDevice);

 if (RD_SUCCESS == nRet)

 {

  printf("Query one device [name:%s] successful!\n", hdCollector.szName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query all device complete!\n");

  break;

 }

 else

 {

  printf("query device failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//delete device

for (i = 0; i < 3; ++i)

{

 nRet = ct_delete_device(hServer, hdDevices[i].nID);

 if (nRet != RD_SUCCESS)

 {

  printf("delete device failed,  error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete device [id:%d] successful.\n",  hdDevices[i].nID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}


ct_add_scan_group

Navigation: »No topics above this level«

ct_add_scan_group

 Return to chapter overview

ct_add_scan_group

Glossary Item Box

函数

添加一个扫描组

int32 ct_add_scan_group(

HDHANDLE hServer,

HDScanGroup *pScanGroup

);

参数

hServer

[in] 服务器句柄。

pScanGroup

[in] 扫描组。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

scan_group

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

HDHANDLE hIter = NULL;

int32 nTimeOut = 3;

int32 nTryTime = 3;

uint32 nCollectorID = 0;

uint32 nDeviceID = 0;

uint32 nScanGroupID = 0;

HDCollector hdCollector;

HDDevice hdDevice;

HDScanGroup hdScanGroup;

HDScanGroup hdScanGroups[3];

int32 i = 0;

int32 nScanGroupNum = 3;

memset(&hdCollector, 0, sizeof(HDCollector));

memset(&hdDevice, 0, sizeof(HDDevice));

memset(&hdScanGroup, 0, sizeof(HDScanGroup));

for (i = 0; i < 3; ++i)

{

 memset(&hdScanGroups[i], 0, sizeof(HDScanGroup));

}

strncpy(hdCollector.szName, "collector", strlen("collector"));

hdCollector.nType = COLLECTOR_TYPE_OPC;

sprintf(hdCollector.szDescription, "name: %s, type: %d", hdCollector.szName, hdCollector.nType);

strncpy(hdCollector.szExtParam, "***", 3);

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add collector

nRet = ct_add_collector(hServer, &hdCollector);

if (nRet != RD_SUCCESS)

{

 printf("add collector[name:%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add collector[name:%s] successful!\n", hdCollector.szName);

//query collector id

nRet = ct_query_collector_id_by_name(hServer, hdCollector.szName, &nCollectorID);

if (nRet != RD_SUCCESS)

{

 printf("query collector id  by name[%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query collector id  by name[%s] successful, collector id  [%d].\n", hdCollector.szName, nCollectorID);

//add device

strncpy(hdDevice.szName, "device", strlen("device"));

hdDevice.nPort = nPort;

hdDevice.nTimeout = nTimeOut;

hdDevice.nCollectorID = nCollectorID;

hdDevice.nTryTime = nTryTime;

sprintf(hdDevice.szAddr, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdDevice.szDescription, "name: %s, collector id: %d", hdDevice.szName, hdDevice.nCollectorID);

strncpy(hdDevice.szExtParam, "***", 3);

nRet = ct_add_device(hServer, &hdDevice);

if (nRet != RD_SUCCESS)

{

 printf("add device[name:%s] failed, error code [%d]!\n", hdDevice.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add device[name:%s] successful!\n", hdDevice.szName);

//query device id

nRet = ct_query_device_id_by_name(hServer, nCollectorID, hdDevice.szName, &nDeviceID);

if (nRet != RD_SUCCESS)

{

 printf("query device id  by name[%s] failed, error code [%d]!\n", hdDevice.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query device id  by name[%s] successful, device id  [%d].\n", hdDevice.szName, nDeviceID);

//add scan group

for (i = 0; i < nScanGroupNum; ++i)

{

 sprintf(hdScanGroups[i].szName, "scan_group%d", i);

 hdScanGroups[i].nDeviceID = nDeviceID;

 hdScanGroups[i].nPeriod = 10;

 hdScanGroups[i].nPhase = 3;

 hdScanGroups[i].nScanType = 0;

 hdScanGroups[i].nDataAddr = 10000;

 hdScanGroups[i].nDataLen = 100;

 sprintf(hdScanGroups[i].szDescrption, "name: %s, device id: %d", hdScanGroups[i].szName, hdScanGroups[i].nDeviceID);

 strncpy(hdScanGroups[i].szExtParam, "***", 3);

}

for (i = 0; i < nScanGroupNum; ++i)

{

 nRet = ct_add_scan_group(hServer, &hdScanGroups[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add scan group[name:%s] failed, error code [%d]!\n", hdScanGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add scan group[name:%s] successful!\n", hdScanGroups[i].szName);

}

//query scan group id, query scan group, modify scan group

for (i = 0; i < nScanGroupNum; ++i)

{

 nRet = ct_query_scan_group_id_by_name(hServer, nDeviceID, hdScanGroups[i].szName, &nScanGroupID);

 if (nRet != RD_SUCCESS)

 {

  printf("query scan group id  by name[%s] failed, error code [%d]!\n", hdScanGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query scan group id  by name[%s] successful, scan group id  [%d].\n", hdScanGroups[i].szName, nScanGroupID);

 nRet = ct_query_scan_group(hServer, nScanGroupID, &hdScanGroups[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query scan group [id:%d] failed, error code [%d]!\n", nScanGroupID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query scan group [id:%d] successful.\n", nScanGroupID);

 nRet = ct_modify_scan_group(hServer, nScanGroupID, &hdScanGroups[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify scan group [id:%d] failed, error code [%d]!\n", nScanGroupID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify scan group [id:%d] successful.\n", nScanGroupID);

}

// query scan group of device

nRet = ct_query_scan_groups_of_device(hServer, nDeviceID, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all scan group of device[id: %d] failed,  error code [%d]!\n", nDeviceID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query all scan group of device[id: %d] successful!\n", nDeviceID);

while (true)

{

 memset(&hdScanGroup, 0, sizeof(HDScanGroup));

 nRet = ut_get_item_step(hIter, &hdScanGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("Query one scan group [name:%s] successful!\n", hdScanGroup.szName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query all scan group complete!\n");

  break;

 }

 else

 {

  printf("query scan group failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//delete scan group

for (i = 0; i < nScanGroupNum; ++i)

{

 nRet = ct_delete_scan_group(hServer, hdScanGroups[i].nID);

 if (nRet != RD_SUCCESS)

 {

  printf("delete scan group failed,  error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete scan group [id:%d] successful.\n",  hdScanGroups[i].nID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}


ct_delete_collector

Navigation: »No topics above this level«

ct_delete_collector

 Return to chapter overview

ct_delete_collector

Glossary Item Box

函数

删除一个采集器

int32 ct_delete_collector(

HDHANDLE hServer,

uint32 nCollectorID

);

参数

hServer

[in] 服务器句柄

nCollectorID

[in] 采集器ID

返回值

删除成功，返回RD_SUCESS， 删除失败，返回其他错误码，见error_code.h

举例

collector

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

HDHANDLE hIter = NULL;

int32 nTimeOut = 3;

uint32 nCollectorID = 0;

HDCollector hdCollectors[3];

HDCollector hdCollector;

int32 i = 0;

int32 nCollectorNum = 2;

for (i = 0; i < nCollectorNum; ++i)

{

 memset(&hdCollectors[i], 0, sizeof(HDCollector));

}

memset(&hdCollector, 0, sizeof(HDCollector));

for (i = 0; i < nCollectorNum; ++i)

{

 sprintf(hdCollectors[i].szName, "collector%d", i);

 hdCollectors[i].nType = COLLECTOR_TYPE_OPC;

 sprintf(hdCollectors[i].szDescription, "name: %s, type: %d", hdCollectors[i].szName, hdCollectors[i].nType);

 strncpy(hdCollectors[i].szExtParam, "***", 3);

}

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

// add collector

for (i = 0; i < nCollectorNum; ++i)

{

 nRet = ct_add_collector(hServer, &hdCollectors[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add collector[name:%s] failed, error code [%d]!\n", hdCollectors[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add collector[name:%s] successful!\n", hdCollectors[i].szName);

}

//query collector id by name, query collector, modify collector

for (i = 0; i < nCollectorNum; ++i)

{

 nRet = ct_query_collector_id_by_name(hServer, hdCollectors[i].szName, &nCollectorID);

 if (nRet != RD_SUCCESS)

 {

  printf("query collector id  by name[%s] failed, error code [%d]!\n", hdCollectors[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query collector id  by name[%s] successful, collector id  [%d].\n", hdCollectors[i].szName, nCollectorID);

 nRet = ct_query_collector(hServer, nCollectorID, &hdCollectors[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query collector [id:%d] failed, error code [%d]!\n", nCollectorID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query collector [id:%d] successful.\n", nCollectorID);

 nRet = ct_modify_collector(hServer, nCollectorID, &hdCollectors[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify collector [id:%d] failed, error code [%d]!\n", nCollectorID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify collector [id:%d] successful.\n", nCollectorID);

}

//query all collector

nRet = ct_query_all_collectors(hServer, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all collectors failed,  error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query all collectors successful!\n");

while (true)

{

 memset(&hdCollector, 0, sizeof(HDCollector));

 nRet = ut_get_item_step(hIter, &hdCollector);

 if (RD_SUCCESS == nRet)

 {

  printf("Query one collector [name:%s] successful!\n", hdCollector.szName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query all collector complete!\n");

  break;

 }

 else

 {

  printf("query collector failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

// delete collector

for (i = 0; i < nCollectorNum; ++i)

{

 nRet = ct_delete_collector(hServer, hdCollectors[i].nID);

 if (nRet != RD_SUCCESS)

 {

  printf("delete collector failed,  error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete collector [id:%d] successful.\n",  hdCollectors[i].nID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

ct_add_collector

ct_delete_collector

ct_query_all_collectors

ct_query_collector

ct_query_collector_id_by_name

ct_modify_collector


ct_delete_device

Navigation: »No topics above this level«

ct_delete_device

 Return to chapter overview

ct_delete_device

Glossary Item Box

函数

删除一个设备

int32 ct_delete_device(

HDHANDLE hServer,

uint32 nDeviceID

);

参数

hServer

[in] 服务器句柄。

nDeviceID

[in] 设备ID。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

device

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

HDHANDLE hIter = NULL;

int32 nTimeOut = 3;

int32 nTryTime = 3;

uint32 nCollectorID = 0;

uint32 nDeviceID = 0;

HDCollector hdCollector;

HDDevice hdDevice;

HDDevice hdDevices[3];

int32 i = 0;

int32 nDeviceNum = 3;

memset(&hdCollector, 0, sizeof(HDCollector));

memset(&hdDevice, 0, sizeof(HDDevice));

for (i = 0; i < 3; ++i)

{

 memset(&hdDevices[i], 0, sizeof(HDDevice));

}

strncpy(hdCollector.szName, "collector", strlen("collector"));

hdCollector.nType = COLLECTOR_TYPE_OPC;

sprintf(hdCollector.szDescription, "name: %s, type: %d", hdCollector.szName, hdCollector.nType);

strncpy(hdCollector.szExtParam, "***", 3);

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add collector

nRet = ct_add_collector(hServer, &hdCollector);

if (nRet != RD_SUCCESS)

{

 printf("add collector[name:%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add collector[name:%s] successful!\n", hdCollector.szName);

//query collector id

nRet = ct_query_collector_id_by_name(hServer, hdCollector.szName, &nCollectorID);

if (nRet != RD_SUCCESS)

{

 printf("query collector id  by name[%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query collector id  by name[%s] successful, collector id  [%d].\n", hdCollector.szName, nCollectorID);

// add device

for (i = 0; i < nDeviceNum; ++i)

{

 sprintf(hdDevices[i].szName, "device%d", i);

 hdDevices[i].nPort = nPort;

 hdDevices[i].nTimeout = nTimeOut;

 hdDevices[i].nCollectorID = nCollectorID;

 hdDevices[i].nTryTime = nTryTime;

 sprintf(hdDevices[i].szAddr, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdDevices[i].szDescription, "name: %s, collector id: %d", hdDevices[i].szName, hdDevices[i].nCollectorID);

 strncpy(hdDevices[i].szExtParam, "***", 3);

}

for (i = 0; i < nDeviceNum; ++i)

{

 nRet = ct_add_device(hServer, &hdDevices[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add device[name:%s] failed, error code [%d]!\n", hdDevices[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add device[name:%s] successful!\n", hdDevices[i].szName);

}

//query device id , query device, modify device

for (i = 0; i < nDeviceNum; ++i)

{

 nRet = ct_query_device_id_by_name(hServer, nCollectorID, hdDevices[i].szName, &nDeviceID);

 if (nRet != RD_SUCCESS)

 {

  printf("query device id  by name[%s] failed, error code [%d]!\n", hdDevices[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query device id  by name[%s] successful, device id  [%d].\n", hdDevices[i].szName, nDeviceID);

 nRet = ct_query_device(hServer, nDeviceID, &hdDevices[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query device [id:%d] failed, error code [%d]!\n", nDeviceID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query device [id:%d] successful.\n", nDeviceID);

 nRet = ct_modify_device(hServer, nDeviceID, &hdDevices[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify device [id:%d] failed, error code [%d]!\n", nDeviceID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify device [id:%d] successful.\n", nDeviceID);

}

//query devices belong to the collector

nRet = ct_query_devices_of_collector(hServer, nCollectorID, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all device of collector[id: %d] failed,  error code [%d]!\n", nCollectorID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query all device of collector[id: %d] successful!\n", nCollectorID);

while (true)

{

 memset(&hdDevice, 0, sizeof(HDDevice));

 nRet = ut_get_item_step(hIter, &hdDevice);

 if (RD_SUCCESS == nRet)

 {

  printf("Query one device [name:%s] successful!\n", hdCollector.szName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query all device complete!\n");

  break;

 }

 else

 {

  printf("query device failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//delete device

for (i = 0; i < 3; ++i)

{

 nRet = ct_delete_device(hServer, hdDevices[i].nID);

 if (nRet != RD_SUCCESS)

 {

  printf("delete device failed,  error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete device [id:%d] successful.\n",  hdDevices[i].nID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}


ct_delete_scan_group

Navigation: »No topics above this level«

ct_delete_scan_group

 Return to chapter overview

ct_delete_scan_group

Glossary Item Box

函数

删除一个扫描组

int32 ct_delete_scan_group(

HDHANDLE hServer,

uint32 nScanGroupID

);

参数

hServer

[in] 服务器句柄。

nScanGroupID

[in] 扫描组ID。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

scan_group

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

HDHANDLE hIter = NULL;

int32 nTimeOut = 3;

int32 nTryTime = 3;

uint32 nCollectorID = 0;

uint32 nDeviceID = 0;

uint32 nScanGroupID = 0;

HDCollector hdCollector;

HDDevice hdDevice;

HDScanGroup hdScanGroup;

HDScanGroup hdScanGroups[3];

int32 i = 0;

int32 nScanGroupNum = 3;

memset(&hdCollector, 0, sizeof(HDCollector));

memset(&hdDevice, 0, sizeof(HDDevice));

memset(&hdScanGroup, 0, sizeof(HDScanGroup));

for (i = 0; i < 3; ++i)

{

 memset(&hdScanGroups[i], 0, sizeof(HDScanGroup));

}

strncpy(hdCollector.szName, "collector", strlen("collector"));

hdCollector.nType = COLLECTOR_TYPE_OPC;

sprintf(hdCollector.szDescription, "name: %s, type: %d", hdCollector.szName, hdCollector.nType);

strncpy(hdCollector.szExtParam, "***", 3);

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add collector

nRet = ct_add_collector(hServer, &hdCollector);

if (nRet != RD_SUCCESS)

{

 printf("add collector[name:%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add collector[name:%s] successful!\n", hdCollector.szName);

//query collector id

nRet = ct_query_collector_id_by_name(hServer, hdCollector.szName, &nCollectorID);

if (nRet != RD_SUCCESS)

{

 printf("query collector id  by name[%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query collector id  by name[%s] successful, collector id  [%d].\n", hdCollector.szName, nCollectorID);

//add device

strncpy(hdDevice.szName, "device", strlen("device"));

hdDevice.nPort = nPort;

hdDevice.nTimeout = nTimeOut;

hdDevice.nCollectorID = nCollectorID;

hdDevice.nTryTime = nTryTime;

sprintf(hdDevice.szAddr, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdDevice.szDescription, "name: %s, collector id: %d", hdDevice.szName, hdDevice.nCollectorID);

strncpy(hdDevice.szExtParam, "***", 3);

nRet = ct_add_device(hServer, &hdDevice);

if (nRet != RD_SUCCESS)

{

 printf("add device[name:%s] failed, error code [%d]!\n", hdDevice.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add device[name:%s] successful!\n", hdDevice.szName);

//query device id

nRet = ct_query_device_id_by_name(hServer, nCollectorID, hdDevice.szName, &nDeviceID);

if (nRet != RD_SUCCESS)

{

 printf("query device id  by name[%s] failed, error code [%d]!\n", hdDevice.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query device id  by name[%s] successful, device id  [%d].\n", hdDevice.szName, nDeviceID);

//add scan group

for (i = 0; i < nScanGroupNum; ++i)

{

 sprintf(hdScanGroups[i].szName, "scan_group%d", i);

 hdScanGroups[i].nDeviceID = nDeviceID;

 hdScanGroups[i].nPeriod = 10;

 hdScanGroups[i].nPhase = 3;

 hdScanGroups[i].nScanType = 0;

 hdScanGroups[i].nDataAddr = 10000;

 hdScanGroups[i].nDataLen = 100;

 sprintf(hdScanGroups[i].szDescrption, "name: %s, device id: %d", hdScanGroups[i].szName, hdScanGroups[i].nDeviceID);

 strncpy(hdScanGroups[i].szExtParam, "***", 3);

}

for (i = 0; i < nScanGroupNum; ++i)

{

 nRet = ct_add_scan_group(hServer, &hdScanGroups[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add scan group[name:%s] failed, error code [%d]!\n", hdScanGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add scan group[name:%s] successful!\n", hdScanGroups[i].szName);

}

//query scan group id, query scan group, modify scan group

for (i = 0; i < nScanGroupNum; ++i)

{

 nRet = ct_query_scan_group_id_by_name(hServer, nDeviceID, hdScanGroups[i].szName, &nScanGroupID);

 if (nRet != RD_SUCCESS)

 {

  printf("query scan group id  by name[%s] failed, error code [%d]!\n", hdScanGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query scan group id  by name[%s] successful, scan group id  [%d].\n", hdScanGroups[i].szName, nScanGroupID);

 nRet = ct_query_scan_group(hServer, nScanGroupID, &hdScanGroups[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query scan group [id:%d] failed, error code [%d]!\n", nScanGroupID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query scan group [id:%d] successful.\n", nScanGroupID);

 nRet = ct_modify_scan_group(hServer, nScanGroupID, &hdScanGroups[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify scan group [id:%d] failed, error code [%d]!\n", nScanGroupID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify scan group [id:%d] successful.\n", nScanGroupID);

}

// query scan group of device

nRet = ct_query_scan_groups_of_device(hServer, nDeviceID, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all scan group of device[id: %d] failed,  error code [%d]!\n", nDeviceID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query all scan group of device[id: %d] successful!\n", nDeviceID);

while (true)

{

 memset(&hdScanGroup, 0, sizeof(HDScanGroup));

 nRet = ut_get_item_step(hIter, &hdScanGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("Query one scan group [name:%s] successful!\n", hdScanGroup.szName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query all scan group complete!\n");

  break;

 }

 else

 {

  printf("query scan group failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//delete scan group

for (i = 0; i < nScanGroupNum; ++i)

{

 nRet = ct_delete_scan_group(hServer, hdScanGroups[i].nID);

 if (nRet != RD_SUCCESS)

 {

  printf("delete scan group failed,  error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete scan group [id:%d] successful.\n",  hdScanGroups[i].nID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}


ct_modify_collector

Navigation: »No topics above this level«

ct_modify_collector

 Return to chapter overview

ct_modify_collector

Glossary Item Box

函数

修改采集器的属性

int32 ct_modify_collector(

HDHANDLE hServer,

uint32 nCollectorID,

HDCollector *pCollector

);

参数

hServer

[in] 服务器句柄。

nCollectorID

[in] 采集器ID。

pCollector

[in] 采集器

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

collector

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

HDHANDLE hIter = NULL;

int32 nTimeOut = 3;

uint32 nCollectorID = 0;

HDCollector hdCollectors[3];

HDCollector hdCollector;

int32 i = 0;

int32 nCollectorNum = 2;

for (i = 0; i < nCollectorNum; ++i)

{

 memset(&hdCollectors[i], 0, sizeof(HDCollector));

}

memset(&hdCollector, 0, sizeof(HDCollector));

for (i = 0; i < nCollectorNum; ++i)

{

 sprintf(hdCollectors[i].szName, "collector%d", i);

 hdCollectors[i].nType = COLLECTOR_TYPE_OPC;

 sprintf(hdCollectors[i].szDescription, "name: %s, type: %d", hdCollectors[i].szName, hdCollectors[i].nType);

 strncpy(hdCollectors[i].szExtParam, "***", 3);

}

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

// add collector

for (i = 0; i < nCollectorNum; ++i)

{

 nRet = ct_add_collector(hServer, &hdCollectors[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add collector[name:%s] failed, error code [%d]!\n", hdCollectors[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add collector[name:%s] successful!\n", hdCollectors[i].szName);

}

//query collector id by name, query collector, modify collector

for (i = 0; i < nCollectorNum; ++i)

{

 nRet = ct_query_collector_id_by_name(hServer, hdCollectors[i].szName, &nCollectorID);

 if (nRet != RD_SUCCESS)

 {

  printf("query collector id  by name[%s] failed, error code [%d]!\n", hdCollectors[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query collector id  by name[%s] successful, collector id  [%d].\n", hdCollectors[i].szName, nCollectorID);

 nRet = ct_query_collector(hServer, nCollectorID, &hdCollectors[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query collector [id:%d] failed, error code [%d]!\n", nCollectorID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query collector [id:%d] successful.\n", nCollectorID);

 nRet = ct_modify_collector(hServer, nCollectorID, &hdCollectors[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify collector [id:%d] failed, error code [%d]!\n", nCollectorID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify collector [id:%d] successful.\n", nCollectorID);

}

//query all collector

nRet = ct_query_all_collectors(hServer, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all collectors failed,  error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query all collectors successful!\n");

while (true)

{

 memset(&hdCollector, 0, sizeof(HDCollector));

 nRet = ut_get_item_step(hIter, &hdCollector);

 if (RD_SUCCESS == nRet)

 {

  printf("Query one collector [name:%s] successful!\n", hdCollector.szName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query all collector complete!\n");

  break;

 }

 else

 {

  printf("query collector failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

// delete collector

for (i = 0; i < nCollectorNum; ++i)

{

 nRet = ct_delete_collector(hServer, hdCollectors[i].nID);

 if (nRet != RD_SUCCESS)

 {

  printf("delete collector failed,  error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete collector [id:%d] successful.\n",  hdCollectors[i].nID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

ct_add_collector

ct_delete_collector

ct_query_all_collectors

ct_query_collector

ct_query_collector_id_by_name

ct_modify_collector


ct_modify_device

Navigation: »No topics above this level«

ct_modify_device

 Return to chapter overview

ct_modify_device

Glossary Item Box

函数

修改一个设备

int32 ct_modify_device(

HDHANDLE hServer,

uint32 nDeviceID,

HDDevice *pDevice

);

参数

hServer

[in] 服务器句柄。

nDeviceID

[in] 设备的ID。

pDevice

[in] 设备。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

device

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

HDHANDLE hIter = NULL;

int32 nTimeOut = 3;

int32 nTryTime = 3;

uint32 nCollectorID = 0;

uint32 nDeviceID = 0;

HDCollector hdCollector;

HDDevice hdDevice;

HDDevice hdDevices[3];

int32 i = 0;

int32 nDeviceNum = 3;

memset(&hdCollector, 0, sizeof(HDCollector));

memset(&hdDevice, 0, sizeof(HDDevice));

for (i = 0; i < 3; ++i)

{

 memset(&hdDevices[i], 0, sizeof(HDDevice));

}

strncpy(hdCollector.szName, "collector", strlen("collector"));

hdCollector.nType = COLLECTOR_TYPE_OPC;

sprintf(hdCollector.szDescription, "name: %s, type: %d", hdCollector.szName, hdCollector.nType);

strncpy(hdCollector.szExtParam, "***", 3);

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add collector

nRet = ct_add_collector(hServer, &hdCollector);

if (nRet != RD_SUCCESS)

{

 printf("add collector[name:%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add collector[name:%s] successful!\n", hdCollector.szName);

//query collector id

nRet = ct_query_collector_id_by_name(hServer, hdCollector.szName, &nCollectorID);

if (nRet != RD_SUCCESS)

{

 printf("query collector id  by name[%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query collector id  by name[%s] successful, collector id  [%d].\n", hdCollector.szName, nCollectorID);

// add device

for (i = 0; i < nDeviceNum; ++i)

{

 sprintf(hdDevices[i].szName, "device%d", i);

 hdDevices[i].nPort = nPort;

 hdDevices[i].nTimeout = nTimeOut;

 hdDevices[i].nCollectorID = nCollectorID;

 hdDevices[i].nTryTime = nTryTime;

 sprintf(hdDevices[i].szAddr, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdDevices[i].szDescription, "name: %s, collector id: %d", hdDevices[i].szName, hdDevices[i].nCollectorID);

 strncpy(hdDevices[i].szExtParam, "***", 3);

}

for (i = 0; i < nDeviceNum; ++i)

{

 nRet = ct_add_device(hServer, &hdDevices[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add device[name:%s] failed, error code [%d]!\n", hdDevices[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add device[name:%s] successful!\n", hdDevices[i].szName);

}

//query device id , query device, modify device

for (i = 0; i < nDeviceNum; ++i)

{

 nRet = ct_query_device_id_by_name(hServer, nCollectorID, hdDevices[i].szName, &nDeviceID);

 if (nRet != RD_SUCCESS)

 {

  printf("query device id  by name[%s] failed, error code [%d]!\n", hdDevices[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query device id  by name[%s] successful, device id  [%d].\n", hdDevices[i].szName, nDeviceID);

 nRet = ct_query_device(hServer, nDeviceID, &hdDevices[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query device [id:%d] failed, error code [%d]!\n", nDeviceID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query device [id:%d] successful.\n", nDeviceID);

 nRet = ct_modify_device(hServer, nDeviceID, &hdDevices[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify device [id:%d] failed, error code [%d]!\n", nDeviceID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify device [id:%d] successful.\n", nDeviceID);

}

//query devices belong to the collector

nRet = ct_query_devices_of_collector(hServer, nCollectorID, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all device of collector[id: %d] failed,  error code [%d]!\n", nCollectorID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query all device of collector[id: %d] successful!\n", nCollectorID);

while (true)

{

 memset(&hdDevice, 0, sizeof(HDDevice));

 nRet = ut_get_item_step(hIter, &hdDevice);

 if (RD_SUCCESS == nRet)

 {

  printf("Query one device [name:%s] successful!\n", hdCollector.szName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query all device complete!\n");

  break;

 }

 else

 {

  printf("query device failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//delete device

for (i = 0; i < 3; ++i)

{

 nRet = ct_delete_device(hServer, hdDevices[i].nID);

 if (nRet != RD_SUCCESS)

 {

  printf("delete device failed,  error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete device [id:%d] successful.\n",  hdDevices[i].nID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}


ct_modify_scan_group

Navigation: »No topics above this level«

ct_modify_scan_group

 Return to chapter overview

ct_modify_scan_group

Glossary Item Box

函数

修改一个扫描组

int32 ct_modify_scan_group(

HDHANDLE hServer,

uint32 nScanGroupID,

HDScanGroup *pScanGroup

);

参数

hServer

[in] 服务器句柄。

nScanGroupID

[in] 扫描组的ID。

pScanGroup

[in] 扫描组

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

scan_group

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

HDHANDLE hIter = NULL;

int32 nTimeOut = 3;

int32 nTryTime = 3;

uint32 nCollectorID = 0;

uint32 nDeviceID = 0;

uint32 nScanGroupID = 0;

HDCollector hdCollector;

HDDevice hdDevice;

HDScanGroup hdScanGroup;

HDScanGroup hdScanGroups[3];

int32 i = 0;

int32 nScanGroupNum = 3;

memset(&hdCollector, 0, sizeof(HDCollector));

memset(&hdDevice, 0, sizeof(HDDevice));

memset(&hdScanGroup, 0, sizeof(HDScanGroup));

for (i = 0; i < 3; ++i)

{

 memset(&hdScanGroups[i], 0, sizeof(HDScanGroup));

}

strncpy(hdCollector.szName, "collector", strlen("collector"));

hdCollector.nType = COLLECTOR_TYPE_OPC;

sprintf(hdCollector.szDescription, "name: %s, type: %d", hdCollector.szName, hdCollector.nType);

strncpy(hdCollector.szExtParam, "***", 3);

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add collector

nRet = ct_add_collector(hServer, &hdCollector);

if (nRet != RD_SUCCESS)

{

 printf("add collector[name:%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add collector[name:%s] successful!\n", hdCollector.szName);

//query collector id

nRet = ct_query_collector_id_by_name(hServer, hdCollector.szName, &nCollectorID);

if (nRet != RD_SUCCESS)

{

 printf("query collector id  by name[%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query collector id  by name[%s] successful, collector id  [%d].\n", hdCollector.szName, nCollectorID);

//add device

strncpy(hdDevice.szName, "device", strlen("device"));

hdDevice.nPort = nPort;

hdDevice.nTimeout = nTimeOut;

hdDevice.nCollectorID = nCollectorID;

hdDevice.nTryTime = nTryTime;

sprintf(hdDevice.szAddr, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdDevice.szDescription, "name: %s, collector id: %d", hdDevice.szName, hdDevice.nCollectorID);

strncpy(hdDevice.szExtParam, "***", 3);

nRet = ct_add_device(hServer, &hdDevice);

if (nRet != RD_SUCCESS)

{

 printf("add device[name:%s] failed, error code [%d]!\n", hdDevice.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add device[name:%s] successful!\n", hdDevice.szName);

//query device id

nRet = ct_query_device_id_by_name(hServer, nCollectorID, hdDevice.szName, &nDeviceID);

if (nRet != RD_SUCCESS)

{

 printf("query device id  by name[%s] failed, error code [%d]!\n", hdDevice.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query device id  by name[%s] successful, device id  [%d].\n", hdDevice.szName, nDeviceID);

//add scan group

for (i = 0; i < nScanGroupNum; ++i)

{

 sprintf(hdScanGroups[i].szName, "scan_group%d", i);

 hdScanGroups[i].nDeviceID = nDeviceID;

 hdScanGroups[i].nPeriod = 10;

 hdScanGroups[i].nPhase = 3;

 hdScanGroups[i].nScanType = 0;

 hdScanGroups[i].nDataAddr = 10000;

 hdScanGroups[i].nDataLen = 100;

 sprintf(hdScanGroups[i].szDescrption, "name: %s, device id: %d", hdScanGroups[i].szName, hdScanGroups[i].nDeviceID);

 strncpy(hdScanGroups[i].szExtParam, "***", 3);

}

for (i = 0; i < nScanGroupNum; ++i)

{

 nRet = ct_add_scan_group(hServer, &hdScanGroups[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add scan group[name:%s] failed, error code [%d]!\n", hdScanGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add scan group[name:%s] successful!\n", hdScanGroups[i].szName);

}

//query scan group id, query scan group, modify scan group

for (i = 0; i < nScanGroupNum; ++i)

{

 nRet = ct_query_scan_group_id_by_name(hServer, nDeviceID, hdScanGroups[i].szName, &nScanGroupID);

 if (nRet != RD_SUCCESS)

 {

  printf("query scan group id  by name[%s] failed, error code [%d]!\n", hdScanGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query scan group id  by name[%s] successful, scan group id  [%d].\n", hdScanGroups[i].szName, nScanGroupID);

 nRet = ct_query_scan_group(hServer, nScanGroupID, &hdScanGroups[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query scan group [id:%d] failed, error code [%d]!\n", nScanGroupID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query scan group [id:%d] successful.\n", nScanGroupID);

 nRet = ct_modify_scan_group(hServer, nScanGroupID, &hdScanGroups[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify scan group [id:%d] failed, error code [%d]!\n", nScanGroupID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify scan group [id:%d] successful.\n", nScanGroupID);

}

// query scan group of device

nRet = ct_query_scan_groups_of_device(hServer, nDeviceID, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all scan group of device[id: %d] failed,  error code [%d]!\n", nDeviceID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query all scan group of device[id: %d] successful!\n", nDeviceID);

while (true)

{

 memset(&hdScanGroup, 0, sizeof(HDScanGroup));

 nRet = ut_get_item_step(hIter, &hdScanGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("Query one scan group [name:%s] successful!\n", hdScanGroup.szName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query all scan group complete!\n");

  break;

 }

 else

 {

  printf("query scan group failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//delete scan group

for (i = 0; i < nScanGroupNum; ++i)

{

 nRet = ct_delete_scan_group(hServer, hdScanGroups[i].nID);

 if (nRet != RD_SUCCESS)

 {

  printf("delete scan group failed,  error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete scan group [id:%d] successful.\n",  hdScanGroups[i].nID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}


ct_query_all_collectors

Navigation: »No topics above this level«

ct_query_all_collectors

 Return to chapter overview

ct_query_all_collectors

Glossary Item Box

函数

查询所有的采集器

int32 ct_query_all_collectors(

HDHANDLE hServer,

HDHANDLE* pIter

);

参数

hServer

[in] 服务器句柄。

pIter

[in] 查询迭代器。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

collector

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

HDHANDLE hIter = NULL;

int32 nTimeOut = 3;

uint32 nCollectorID = 0;

HDCollector hdCollectors[3];

HDCollector hdCollector;

int32 i = 0;

int32 nCollectorNum = 2;

for (i = 0; i < nCollectorNum; ++i)

{

 memset(&hdCollectors[i], 0, sizeof(HDCollector));

}

memset(&hdCollector, 0, sizeof(HDCollector));

for (i = 0; i < nCollectorNum; ++i)

{

 sprintf(hdCollectors[i].szName, "collector%d", i);

 hdCollectors[i].nType = COLLECTOR_TYPE_OPC;

 sprintf(hdCollectors[i].szDescription, "name: %s, type: %d", hdCollectors[i].szName, hdCollectors[i].nType);

 strncpy(hdCollectors[i].szExtParam, "***", 3);

}

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

// add collector

for (i = 0; i < nCollectorNum; ++i)

{

 nRet = ct_add_collector(hServer, &hdCollectors[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add collector[name:%s] failed, error code [%d]!\n", hdCollectors[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add collector[name:%s] successful!\n", hdCollectors[i].szName);

}

//query collector id by name, query collector, modify collector

for (i = 0; i < nCollectorNum; ++i)

{

 nRet = ct_query_collector_id_by_name(hServer, hdCollectors[i].szName, &nCollectorID);

 if (nRet != RD_SUCCESS)

 {

  printf("query collector id  by name[%s] failed, error code [%d]!\n", hdCollectors[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query collector id  by name[%s] successful, collector id  [%d].\n", hdCollectors[i].szName, nCollectorID);

 nRet = ct_query_collector(hServer, nCollectorID, &hdCollectors[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query collector [id:%d] failed, error code [%d]!\n", nCollectorID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query collector [id:%d] successful.\n", nCollectorID);

 nRet = ct_modify_collector(hServer, nCollectorID, &hdCollectors[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify collector [id:%d] failed, error code [%d]!\n", nCollectorID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify collector [id:%d] successful.\n", nCollectorID);

}

//query all collector

nRet = ct_query_all_collectors(hServer, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all collectors failed,  error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query all collectors successful!\n");

while (true)

{

 memset(&hdCollector, 0, sizeof(HDCollector));

 nRet = ut_get_item_step(hIter, &hdCollector);

 if (RD_SUCCESS == nRet)

 {

  printf("Query one collector [name:%s] successful!\n", hdCollector.szName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query all collector complete!\n");

  break;

 }

 else

 {

  printf("query collector failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

// delete collector

for (i = 0; i < nCollectorNum; ++i)

{

 nRet = ct_delete_collector(hServer, hdCollectors[i].nID);

 if (nRet != RD_SUCCESS)

 {

  printf("delete collector failed,  error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete collector [id:%d] successful.\n",  hdCollectors[i].nID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

ct_add_collector

ct_delete_collector

ct_query_all_collectors

ct_query_collector

ct_query_collector_id_by_name

ct_modify_collector


ct_query_collector

Navigation: »No topics above this level«

ct_query_collector

 Return to chapter overview

ct_query_collector

Glossary Item Box

函数

查询一个采集器

int32 ct_query_collector(

HDHANDLE hServer,

uint32 nCollectorID,

HDCollector *pCollector

);

参数

hServer

[in] 服务器句柄。

nCollectorID

[in] 采集器ID

pCollector

[out] 查询到的采集器

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

collector

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

HDHANDLE hIter = NULL;

int32 nTimeOut = 3;

uint32 nCollectorID = 0;

HDCollector hdCollectors[3];

HDCollector hdCollector;

int32 i = 0;

int32 nCollectorNum = 2;

for (i = 0; i < nCollectorNum; ++i)

{

 memset(&hdCollectors[i], 0, sizeof(HDCollector));

}

memset(&hdCollector, 0, sizeof(HDCollector));

for (i = 0; i < nCollectorNum; ++i)

{

 sprintf(hdCollectors[i].szName, "collector%d", i);

 hdCollectors[i].nType = COLLECTOR_TYPE_OPC;

 sprintf(hdCollectors[i].szDescription, "name: %s, type: %d", hdCollectors[i].szName, hdCollectors[i].nType);

 strncpy(hdCollectors[i].szExtParam, "***", 3);

}

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

// add collector

for (i = 0; i < nCollectorNum; ++i)

{

 nRet = ct_add_collector(hServer, &hdCollectors[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add collector[name:%s] failed, error code [%d]!\n", hdCollectors[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add collector[name:%s] successful!\n", hdCollectors[i].szName);

}

//query collector id by name, query collector, modify collector

for (i = 0; i < nCollectorNum; ++i)

{

 nRet = ct_query_collector_id_by_name(hServer, hdCollectors[i].szName, &nCollectorID);

 if (nRet != RD_SUCCESS)

 {

  printf("query collector id  by name[%s] failed, error code [%d]!\n", hdCollectors[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query collector id  by name[%s] successful, collector id  [%d].\n", hdCollectors[i].szName, nCollectorID);

 nRet = ct_query_collector(hServer, nCollectorID, &hdCollectors[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query collector [id:%d] failed, error code [%d]!\n", nCollectorID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query collector [id:%d] successful.\n", nCollectorID);

 nRet = ct_modify_collector(hServer, nCollectorID, &hdCollectors[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify collector [id:%d] failed, error code [%d]!\n", nCollectorID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify collector [id:%d] successful.\n", nCollectorID);

}

//query all collector

nRet = ct_query_all_collectors(hServer, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all collectors failed,  error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query all collectors successful!\n");

while (true)

{

 memset(&hdCollector, 0, sizeof(HDCollector));

 nRet = ut_get_item_step(hIter, &hdCollector);

 if (RD_SUCCESS == nRet)

 {

  printf("Query one collector [name:%s] successful!\n", hdCollector.szName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query all collector complete!\n");

  break;

 }

 else

 {

  printf("query collector failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

// delete collector

for (i = 0; i < nCollectorNum; ++i)

{

 nRet = ct_delete_collector(hServer, hdCollectors[i].nID);

 if (nRet != RD_SUCCESS)

 {

  printf("delete collector failed,  error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete collector [id:%d] successful.\n",  hdCollectors[i].nID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

ct_add_collector

ct_delete_collector

ct_query_all_collectors

ct_query_collector

ct_query_collector_id_by_name

ct_modify_collector


ct_query_collector_id_by_name

Navigation: »No topics above this level«

ct_query_collector_id_by_name

 Return to chapter overview

ct_query_collector_id_by_name

Glossary Item Box

函数

通过采集器的名字查询采集器的ID

int32 ct_query_collector_id_by_name(

HDHANDLE hServer,

const char* szCollectorName,

uint32* pnCollectorID

);

参数

hServer

[in] 服务器句柄。

szCollectorName

[in] 采集器名字。

pnCollectorID

[out] 查询到的采集器ID

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

collector

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

HDHANDLE hIter = NULL;

int32 nTimeOut = 3;

uint32 nCollectorID = 0;

HDCollector hdCollectors[3];

HDCollector hdCollector;

int32 i = 0;

int32 nCollectorNum = 2;

for (i = 0; i < nCollectorNum; ++i)

{

 memset(&hdCollectors[i], 0, sizeof(HDCollector));

}

memset(&hdCollector, 0, sizeof(HDCollector));

for (i = 0; i < nCollectorNum; ++i)

{

 sprintf(hdCollectors[i].szName, "collector%d", i);

 hdCollectors[i].nType = COLLECTOR_TYPE_OPC;

 sprintf(hdCollectors[i].szDescription, "name: %s, type: %d", hdCollectors[i].szName, hdCollectors[i].nType);

 strncpy(hdCollectors[i].szExtParam, "***", 3);

}

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

// add collector

for (i = 0; i < nCollectorNum; ++i)

{

 nRet = ct_add_collector(hServer, &hdCollectors[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add collector[name:%s] failed, error code [%d]!\n", hdCollectors[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add collector[name:%s] successful!\n", hdCollectors[i].szName);

}

//query collector id by name, query collector, modify collector

for (i = 0; i < nCollectorNum; ++i)

{

 nRet = ct_query_collector_id_by_name(hServer, hdCollectors[i].szName, &nCollectorID);

 if (nRet != RD_SUCCESS)

 {

  printf("query collector id  by name[%s] failed, error code [%d]!\n", hdCollectors[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query collector id  by name[%s] successful, collector id  [%d].\n", hdCollectors[i].szName, nCollectorID);

 nRet = ct_query_collector(hServer, nCollectorID, &hdCollectors[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query collector [id:%d] failed, error code [%d]!\n", nCollectorID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query collector [id:%d] successful.\n", nCollectorID);

 nRet = ct_modify_collector(hServer, nCollectorID, &hdCollectors[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify collector [id:%d] failed, error code [%d]!\n", nCollectorID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify collector [id:%d] successful.\n", nCollectorID);

}

//query all collector

nRet = ct_query_all_collectors(hServer, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all collectors failed,  error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query all collectors successful!\n");

while (true)

{

 memset(&hdCollector, 0, sizeof(HDCollector));

 nRet = ut_get_item_step(hIter, &hdCollector);

 if (RD_SUCCESS == nRet)

 {

  printf("Query one collector [name:%s] successful!\n", hdCollector.szName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query all collector complete!\n");

  break;

 }

 else

 {

  printf("query collector failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

// delete collector

for (i = 0; i < nCollectorNum; ++i)

{

 nRet = ct_delete_collector(hServer, hdCollectors[i].nID);

 if (nRet != RD_SUCCESS)

 {

  printf("delete collector failed,  error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete collector [id:%d] successful.\n",  hdCollectors[i].nID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

ct_add_collector

ct_delete_collector

ct_query_all_collectors

ct_query_collector

ct_query_collector_id_by_name

ct_modify_collector


ct_query_collector_status

Navigation: »No topics above this level«

ct_query_collector_status

 Return to chapter overview

ct_query_collector_status

Glossary Item Box

函数

查询指定采集器状态

int32 ct_query_collector_status(HDHANDLE hServer, uint32 nCollectorIDs[], int32 nNum, HDCtStatusInfo statusInfo[], int32 nErrCodes[])

参数

hServer

[in] 服务器句柄

nCollectorID

[in] 采集器ID

nNum

[in] 采集器个数

statusInfo[]

[out] 状态信息

nErrCodes[]

[out] 错误码

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

举例

ct_query_collector_status

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

uint32 nCollectorIDs[3];

int32 nCollectorNum = 3;

HDCtStatusInfo statusInfos[3];

int32 nErrCodes[3];

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

memset(statusInfos, 0, sizeof(statusInfos));

memset(nErrCodes, 0, sizeof(nErrCodes));

for(int32 i = 1; i <=3; ++i)

{

 nCollectorIDs[i-1] = i;

}

// Update status

nRet = ct_query_collector_status(hServer, nCollectorIDs, nCollectorNum, statusInfos, nErrCodes);

if(nRet != RD_SUCCESS && nRet != EC_HD_API_CT_QUERY_STATUS_INFO_FAILED)

{

 printf("Failed to update collector status, error code[%d]!\n", nRet);

return -1;

}

else

{

for(int32 i = 0; i < nCollectorNum; ++i )

 {

  if(RD_SUCCESS == nErrCodes[i])

  {

   printf("Collector %d's status[%d]\n", nCollectorIDs[i], statusInfos[i].nStatusValue);

  }

  else

  {

   printf("Collector %d's status failed !\n", nCollectorIDs[i]);

  }

 }

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

ct_add_collector

ct_delete_collector

ct_query_all_collectors

ct_query_collector

ct_query_collector_id_by_name

ct_modify_collector


ct_query_collector_status_rec

Navigation: »No topics above this level«

ct_query_collector_status_rec

 Return to chapter overview

ct_query_collector_status_rec

Glossary Item Box

函数

查询采集器指定区间状态点记录

int32 ct_query_collector_status_rec(HDHANDLE hServer, uint32 nCollectorID, const HDTime* pStartTime, const HDTime* pEndTime, int32* pRecNum, HDRecord records[])

参数

hServer

[in] 服务器句柄

nCollectorID

[in] 采集器ID

pStartTime

[in] 开始时间

pEndTime

[in] 结束时间

pRecNum

[in/out] 查询的记录条数

records[]

[out] 记录

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

举例

ct_query_collector_status_rec

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

uint32 nCollectorID = 1;

HDTime startTime;

HDTime endTime;

HDRecord records[1000];

int32 nMaxRecNum = 1000;

int32 nTimeOut = 3;

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

startTime.nSec = 0;

startTime.nMsec = 0;

endTime.nSec = 86400;

endTime.nMsec = 0;

memset(records, 0, sizeof(records));

// Update status

nRet = ct_query_collector_status_rec(hServer, nCollectorID, &startTime, &endTime, &nMaxRecNum, records);

if(nRet != RD_SUCCESS && nRet != EC_HD_API_CT_QUERY_STATUS_INFO_FAILED)

{

 printf("Failed to query collector status rec, error code[%d]!\n", nRet);

return -1;

}

else

{

for(int32 i = 0; i < nMaxRecNum; ++i )

 {

  printf("Collector %d's status[%d] , nActiveTag[%d]\n", nCollectorID, records[i].nQuality, records[i].value.nInt32);

 }

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

ct_add_collector

ct_delete_collector

ct_query_all_collectors

ct_query_collector

ct_query_collector_id_by_name

ct_modify_collector


ct_query_device

Navigation: »No topics above this level«

ct_query_device

 Return to chapter overview

ct_query_device

Glossary Item Box

函数

查询一个设备

int32 ct_query_device(

HDHANDLE hServer,

uint32 nDeviceID,

HDDevice *pDevice

);

参数

hServer

[in] 服务器句柄。

nDeviceID

[in] 设备ID。

pDevice

[out] 设备。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

device

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

HDHANDLE hIter = NULL;

int32 nTimeOut = 3;

int32 nTryTime = 3;

uint32 nCollectorID = 0;

uint32 nDeviceID = 0;

HDCollector hdCollector;

HDDevice hdDevice;

HDDevice hdDevices[3];

int32 i = 0;

int32 nDeviceNum = 3;

memset(&hdCollector, 0, sizeof(HDCollector));

memset(&hdDevice, 0, sizeof(HDDevice));

for (i = 0; i < 3; ++i)

{

 memset(&hdDevices[i], 0, sizeof(HDDevice));

}

strncpy(hdCollector.szName, "collector", strlen("collector"));

hdCollector.nType = COLLECTOR_TYPE_OPC;

sprintf(hdCollector.szDescription, "name: %s, type: %d", hdCollector.szName, hdCollector.nType);

strncpy(hdCollector.szExtParam, "***", 3);

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add collector

nRet = ct_add_collector(hServer, &hdCollector);

if (nRet != RD_SUCCESS)

{

 printf("add collector[name:%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add collector[name:%s] successful!\n", hdCollector.szName);

//query collector id

nRet = ct_query_collector_id_by_name(hServer, hdCollector.szName, &nCollectorID);

if (nRet != RD_SUCCESS)

{

 printf("query collector id  by name[%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query collector id  by name[%s] successful, collector id  [%d].\n", hdCollector.szName, nCollectorID);

// add device

for (i = 0; i < nDeviceNum; ++i)

{

 sprintf(hdDevices[i].szName, "device%d", i);

 hdDevices[i].nPort = nPort;

 hdDevices[i].nTimeout = nTimeOut;

 hdDevices[i].nCollectorID = nCollectorID;

 hdDevices[i].nTryTime = nTryTime;

 sprintf(hdDevices[i].szAddr, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdDevices[i].szDescription, "name: %s, collector id: %d", hdDevices[i].szName, hdDevices[i].nCollectorID);

 strncpy(hdDevices[i].szExtParam, "***", 3);

}

for (i = 0; i < nDeviceNum; ++i)

{

 nRet = ct_add_device(hServer, &hdDevices[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add device[name:%s] failed, error code [%d]!\n", hdDevices[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add device[name:%s] successful!\n", hdDevices[i].szName);

}

//query device id , query device, modify device

for (i = 0; i < nDeviceNum; ++i)

{

 nRet = ct_query_device_id_by_name(hServer, nCollectorID, hdDevices[i].szName, &nDeviceID);

 if (nRet != RD_SUCCESS)

 {

  printf("query device id  by name[%s] failed, error code [%d]!\n", hdDevices[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query device id  by name[%s] successful, device id  [%d].\n", hdDevices[i].szName, nDeviceID);

 nRet = ct_query_device(hServer, nDeviceID, &hdDevices[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query device [id:%d] failed, error code [%d]!\n", nDeviceID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query device [id:%d] successful.\n", nDeviceID);

 nRet = ct_modify_device(hServer, nDeviceID, &hdDevices[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify device [id:%d] failed, error code [%d]!\n", nDeviceID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify device [id:%d] successful.\n", nDeviceID);

}

//query devices belong to the collector

nRet = ct_query_devices_of_collector(hServer, nCollectorID, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all device of collector[id: %d] failed,  error code [%d]!\n", nCollectorID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query all device of collector[id: %d] successful!\n", nCollectorID);

while (true)

{

 memset(&hdDevice, 0, sizeof(HDDevice));

 nRet = ut_get_item_step(hIter, &hdDevice);

 if (RD_SUCCESS == nRet)

 {

  printf("Query one device [name:%s] successful!\n", hdCollector.szName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query all device complete!\n");

  break;

 }

 else

 {

  printf("query device failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//delete device

for (i = 0; i < 3; ++i)

{

 nRet = ct_delete_device(hServer, hdDevices[i].nID);

 if (nRet != RD_SUCCESS)

 {

  printf("delete device failed,  error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete device [id:%d] successful.\n",  hdDevices[i].nID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}


ct_query_device_id_by_name

Navigation: »No topics above this level«

ct_query_device_id_by_name

 Return to chapter overview

ct_query_device_id_by_name

Glossary Item Box

函数

通过设备的名字查询设备的ID

int32 ct_query_device_id_by_name(

HDHANDLE hServer,

uint32 nCollectorID,

const char* szDeviceName,

uint32* pnDeviceID

);

参数

hServer

[in] 服务器句柄。

nCollectorID

[in] 设备所在采集器的ID。

szDeviceName

[in] 设备名称。

pnDeviceID

[out] 设备ID

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

device

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

HDHANDLE hIter = NULL;

int32 nTimeOut = 3;

int32 nTryTime = 3;

uint32 nCollectorID = 0;

uint32 nDeviceID = 0;

HDCollector hdCollector;

HDDevice hdDevice;

HDDevice hdDevices[3];

int32 i = 0;

int32 nDeviceNum = 3;

memset(&hdCollector, 0, sizeof(HDCollector));

memset(&hdDevice, 0, sizeof(HDDevice));

for (i = 0; i < 3; ++i)

{

 memset(&hdDevices[i], 0, sizeof(HDDevice));

}

strncpy(hdCollector.szName, "collector", strlen("collector"));

hdCollector.nType = COLLECTOR_TYPE_OPC;

sprintf(hdCollector.szDescription, "name: %s, type: %d", hdCollector.szName, hdCollector.nType);

strncpy(hdCollector.szExtParam, "***", 3);

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add collector

nRet = ct_add_collector(hServer, &hdCollector);

if (nRet != RD_SUCCESS)

{

 printf("add collector[name:%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add collector[name:%s] successful!\n", hdCollector.szName);

//query collector id

nRet = ct_query_collector_id_by_name(hServer, hdCollector.szName, &nCollectorID);

if (nRet != RD_SUCCESS)

{

 printf("query collector id  by name[%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query collector id  by name[%s] successful, collector id  [%d].\n", hdCollector.szName, nCollectorID);

// add device

for (i = 0; i < nDeviceNum; ++i)

{

 sprintf(hdDevices[i].szName, "device%d", i);

 hdDevices[i].nPort = nPort;

 hdDevices[i].nTimeout = nTimeOut;

 hdDevices[i].nCollectorID = nCollectorID;

 hdDevices[i].nTryTime = nTryTime;

 sprintf(hdDevices[i].szAddr, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdDevices[i].szDescription, "name: %s, collector id: %d", hdDevices[i].szName, hdDevices[i].nCollectorID);

 strncpy(hdDevices[i].szExtParam, "***", 3);

}

for (i = 0; i < nDeviceNum; ++i)

{

 nRet = ct_add_device(hServer, &hdDevices[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add device[name:%s] failed, error code [%d]!\n", hdDevices[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add device[name:%s] successful!\n", hdDevices[i].szName);

}

//query device id , query device, modify device

for (i = 0; i < nDeviceNum; ++i)

{

 nRet = ct_query_device_id_by_name(hServer, nCollectorID, hdDevices[i].szName, &nDeviceID);

 if (nRet != RD_SUCCESS)

 {

  printf("query device id  by name[%s] failed, error code [%d]!\n", hdDevices[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query device id  by name[%s] successful, device id  [%d].\n", hdDevices[i].szName, nDeviceID);

 nRet = ct_query_device(hServer, nDeviceID, &hdDevices[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query device [id:%d] failed, error code [%d]!\n", nDeviceID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query device [id:%d] successful.\n", nDeviceID);

 nRet = ct_modify_device(hServer, nDeviceID, &hdDevices[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify device [id:%d] failed, error code [%d]!\n", nDeviceID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify device [id:%d] successful.\n", nDeviceID);

}

//query devices belong to the collector

nRet = ct_query_devices_of_collector(hServer, nCollectorID, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all device of collector[id: %d] failed,  error code [%d]!\n", nCollectorID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query all device of collector[id: %d] successful!\n", nCollectorID);

while (true)

{

 memset(&hdDevice, 0, sizeof(HDDevice));

 nRet = ut_get_item_step(hIter, &hdDevice);

 if (RD_SUCCESS == nRet)

 {

  printf("Query one device [name:%s] successful!\n", hdCollector.szName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query all device complete!\n");

  break;

 }

 else

 {

  printf("query device failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//delete device

for (i = 0; i < 3; ++i)

{

 nRet = ct_delete_device(hServer, hdDevices[i].nID);

 if (nRet != RD_SUCCESS)

 {

  printf("delete device failed,  error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete device [id:%d] successful.\n",  hdDevices[i].nID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}


ct_query_devices_of_collector

Navigation: »No topics above this level«

ct_query_devices_of_collector

 Return to chapter overview

ct_query_devices_of_collector

Glossary Item Box

函数

查询一个采集器下所有的设备

int32 ct_query_devices_of_collector(

HDHANDLE hServer,

uint32 nCollectorID,

HDHANDLE *pIter

);

参数

hServer

[in] 服务器句柄。

nCollectorID

[in] 设备所在采集器的ID。

pIter

[in] 查询迭代器。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

device

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

HDHANDLE hIter = NULL;

int32 nTimeOut = 3;

int32 nTryTime = 3;

uint32 nCollectorID = 0;

uint32 nDeviceID = 0;

HDCollector hdCollector;

HDDevice hdDevice;

HDDevice hdDevices[3];

int32 i = 0;

int32 nDeviceNum = 3;

memset(&hdCollector, 0, sizeof(HDCollector));

memset(&hdDevice, 0, sizeof(HDDevice));

for (i = 0; i < 3; ++i)

{

 memset(&hdDevices[i], 0, sizeof(HDDevice));

}

strncpy(hdCollector.szName, "collector", strlen("collector"));

hdCollector.nType = COLLECTOR_TYPE_OPC;

sprintf(hdCollector.szDescription, "name: %s, type: %d", hdCollector.szName, hdCollector.nType);

strncpy(hdCollector.szExtParam, "***", 3);

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add collector

nRet = ct_add_collector(hServer, &hdCollector);

if (nRet != RD_SUCCESS)

{

 printf("add collector[name:%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add collector[name:%s] successful!\n", hdCollector.szName);

//query collector id

nRet = ct_query_collector_id_by_name(hServer, hdCollector.szName, &nCollectorID);

if (nRet != RD_SUCCESS)

{

 printf("query collector id  by name[%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query collector id  by name[%s] successful, collector id  [%d].\n", hdCollector.szName, nCollectorID);

// add device

for (i = 0; i < nDeviceNum; ++i)

{

 sprintf(hdDevices[i].szName, "device%d", i);

 hdDevices[i].nPort = nPort;

 hdDevices[i].nTimeout = nTimeOut;

 hdDevices[i].nCollectorID = nCollectorID;

 hdDevices[i].nTryTime = nTryTime;

 sprintf(hdDevices[i].szAddr, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdDevices[i].szDescription, "name: %s, collector id: %d", hdDevices[i].szName, hdDevices[i].nCollectorID);

 strncpy(hdDevices[i].szExtParam, "***", 3);

}

for (i = 0; i < nDeviceNum; ++i)

{

 nRet = ct_add_device(hServer, &hdDevices[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add device[name:%s] failed, error code [%d]!\n", hdDevices[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add device[name:%s] successful!\n", hdDevices[i].szName);

}

//query device id , query device, modify device

for (i = 0; i < nDeviceNum; ++i)

{

 nRet = ct_query_device_id_by_name(hServer, nCollectorID, hdDevices[i].szName, &nDeviceID);

 if (nRet != RD_SUCCESS)

 {

  printf("query device id  by name[%s] failed, error code [%d]!\n", hdDevices[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query device id  by name[%s] successful, device id  [%d].\n", hdDevices[i].szName, nDeviceID);

 nRet = ct_query_device(hServer, nDeviceID, &hdDevices[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query device [id:%d] failed, error code [%d]!\n", nDeviceID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query device [id:%d] successful.\n", nDeviceID);

 nRet = ct_modify_device(hServer, nDeviceID, &hdDevices[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify device [id:%d] failed, error code [%d]!\n", nDeviceID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify device [id:%d] successful.\n", nDeviceID);

}

//query devices belong to the collector

nRet = ct_query_devices_of_collector(hServer, nCollectorID, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all device of collector[id: %d] failed,  error code [%d]!\n", nCollectorID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query all device of collector[id: %d] successful!\n", nCollectorID);

while (true)

{

 memset(&hdDevice, 0, sizeof(HDDevice));

 nRet = ut_get_item_step(hIter, &hdDevice);

 if (RD_SUCCESS == nRet)

 {

  printf("Query one device [name:%s] successful!\n", hdCollector.szName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query all device complete!\n");

  break;

 }

 else

 {

  printf("query device failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//delete device

for (i = 0; i < 3; ++i)

{

 nRet = ct_delete_device(hServer, hdDevices[i].nID);

 if (nRet != RD_SUCCESS)

 {

  printf("delete device failed,  error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete device [id:%d] successful.\n",  hdDevices[i].nID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}


ct_query_device_status

Navigation: »No topics above this level«

ct_query_device_status

 Return to chapter overview

ct_query_device_status

Glossary Item Box

函数

查询指定设备状态

int32 ct_query_device_status(HDHANDLE hServer, uint32 nDeviceIDs[], int32 nNum, HDCtStatusInfo statusInfo[], int32 nErrCodes[])

参数

hServer

[in] 服务器句柄

nDeviceID

[in] 设备的ID

nNum

[in] 采集器个数

statusInfo[]

[out] 状态信息

nErrCodes

[out] 错误码

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

ct_query_device_status

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

uint32 nDeviceIDs[3];

int32 nDeviceNum = 3;

HDCtStatusInfo statusInfos[3];

int32 nErrCodes[3];

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

memset(statusInfos, 0, sizeof(statusInfos));

memset(nErrCodes, 0, sizeof(nErrCodes));

for(int32 i = 1; i <=3; ++i)

{

 nDeviceIDs[i-1] = i;

}

// Update status

nRet = ct_query_device_status(hServer, nDeviceIDs, nDeviceNum, statusInfos, nErrCodes);

if(nRet != RD_SUCCESS && nRet != EC_HD_API_CT_QUERY_STATUS_INFO_FAILED)

{

 printf("Failed to update device status, error code[%d]!\n", nRet);

 return -1;

}

else

{

 for(int32 i = 0; i < nDeviceNum; ++i )

 {

  if(RD_SUCCESS == nErrCodes[i])

  {

   printf("Device %d's status[%d]\n", nDeviceIDs[i], statusInfos[i].nStatusValue);

  }

  else

  {

   printf("Device %d's status failed !\n", nDeviceIDs[i]);

  }

 }

}

//disconnect

nt_disconnect(hServer);

return 0;

}


ct_query_device_status_rec

Navigation: »No topics above this level«

ct_query_device_status_rec

 Return to chapter overview

ct_query_device_status_rec

Glossary Item Box

函数

查询设备指定区间状态点记录

int32 ct_query_device_status_rec(HDHANDLE hServer, uint32 nDeviceID, const HDTime* pStartTime, const HDTime* pEndTime, int32* pRecNum, HDRecord records[])

参数

hServer

[in] 服务器句柄

nDeviceID

[in] 设备的ID

pStartTime

[in] 开始时间

pEndTime

[out] 结束时间

pRecNum

[in/out] 查询的记录条数

records

[out] 记录

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

ct_query_device_status_rec

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

uint32 nDeviceID = 1;

HDTime startTime;

HDTime endTime;

HDRecord records[1000];

int32 nMaxRecNum = 1000;

int32 nTimeOut = 3;

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

startTime.nSec = 0;

startTime.nMsec = 0;

endTime.nSec = 86400;

endTime.nMsec = 0;

memset(records, 0, sizeof(records));

// Update status

nRet = ct_query_collector_status_rec(hServer, nDeviceID, &startTime, &endTime, &nMaxRecNum, records);

if(nRet != RD_SUCCESS && nRet != EC_HD_API_CT_QUERY_STATUS_INFO_FAILED)

{

 printf("Failed to query collector status rec, error code[%d]!\n", nRet);

 return -1;

}

else

{

 for(int32 i = 0; i < nMaxRecNum; ++i )

 {

  printf("Collector %d's status[%d] , nActiveTag[%d]\n", nDeviceID, records[i].nQuality, records[i].value.nInt32);

 }

}

//disconnect

nt_disconnect(hServer);

return 0;

}


ct_query_scan_group

Navigation: »No topics above this level«

ct_query_scan_group

 Return to chapter overview

ct_query_scan_group

Glossary Item Box

函数

查询一个扫描组

int32 ct_query_scan_group(

HDHANDLE hServer,

uint32 nScanGroupID,

HDScanGroup *pScanGroup

);

参数

hServer

[in] 服务器句柄。

nScanGroupID

[in] 扫描组ID。

pScanGroup

[out] 扫描组

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

scan_group

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

HDHANDLE hIter = NULL;

int32 nTimeOut = 3;

int32 nTryTime = 3;

uint32 nCollectorID = 0;

uint32 nDeviceID = 0;

uint32 nScanGroupID = 0;

HDCollector hdCollector;

HDDevice hdDevice;

HDScanGroup hdScanGroup;

HDScanGroup hdScanGroups[3];

int32 i = 0;

int32 nScanGroupNum = 3;

memset(&hdCollector, 0, sizeof(HDCollector));

memset(&hdDevice, 0, sizeof(HDDevice));

memset(&hdScanGroup, 0, sizeof(HDScanGroup));

for (i = 0; i < 3; ++i)

{

 memset(&hdScanGroups[i], 0, sizeof(HDScanGroup));

}

strncpy(hdCollector.szName, "collector", strlen("collector"));

hdCollector.nType = COLLECTOR_TYPE_OPC;

sprintf(hdCollector.szDescription, "name: %s, type: %d", hdCollector.szName, hdCollector.nType);

strncpy(hdCollector.szExtParam, "***", 3);

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add collector

nRet = ct_add_collector(hServer, &hdCollector);

if (nRet != RD_SUCCESS)

{

 printf("add collector[name:%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add collector[name:%s] successful!\n", hdCollector.szName);

//query collector id

nRet = ct_query_collector_id_by_name(hServer, hdCollector.szName, &nCollectorID);

if (nRet != RD_SUCCESS)

{

 printf("query collector id  by name[%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query collector id  by name[%s] successful, collector id  [%d].\n", hdCollector.szName, nCollectorID);

//add device

strncpy(hdDevice.szName, "device", strlen("device"));

hdDevice.nPort = nPort;

hdDevice.nTimeout = nTimeOut;

hdDevice.nCollectorID = nCollectorID;

hdDevice.nTryTime = nTryTime;

sprintf(hdDevice.szAddr, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdDevice.szDescription, "name: %s, collector id: %d", hdDevice.szName, hdDevice.nCollectorID);

strncpy(hdDevice.szExtParam, "***", 3);

nRet = ct_add_device(hServer, &hdDevice);

if (nRet != RD_SUCCESS)

{

 printf("add device[name:%s] failed, error code [%d]!\n", hdDevice.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add device[name:%s] successful!\n", hdDevice.szName);

//query device id

nRet = ct_query_device_id_by_name(hServer, nCollectorID, hdDevice.szName, &nDeviceID);

if (nRet != RD_SUCCESS)

{

 printf("query device id  by name[%s] failed, error code [%d]!\n", hdDevice.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query device id  by name[%s] successful, device id  [%d].\n", hdDevice.szName, nDeviceID);

//add scan group

for (i = 0; i < nScanGroupNum; ++i)

{

 sprintf(hdScanGroups[i].szName, "scan_group%d", i);

 hdScanGroups[i].nDeviceID = nDeviceID;

 hdScanGroups[i].nPeriod = 10;

 hdScanGroups[i].nPhase = 3;

 hdScanGroups[i].nScanType = 0;

 hdScanGroups[i].nDataAddr = 10000;

 hdScanGroups[i].nDataLen = 100;

 sprintf(hdScanGroups[i].szDescrption, "name: %s, device id: %d", hdScanGroups[i].szName, hdScanGroups[i].nDeviceID);

 strncpy(hdScanGroups[i].szExtParam, "***", 3);

}

for (i = 0; i < nScanGroupNum; ++i)

{

 nRet = ct_add_scan_group(hServer, &hdScanGroups[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add scan group[name:%s] failed, error code [%d]!\n", hdScanGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add scan group[name:%s] successful!\n", hdScanGroups[i].szName);

}

//query scan group id, query scan group, modify scan group

for (i = 0; i < nScanGroupNum; ++i)

{

 nRet = ct_query_scan_group_id_by_name(hServer, nDeviceID, hdScanGroups[i].szName, &nScanGroupID);

 if (nRet != RD_SUCCESS)

 {

  printf("query scan group id  by name[%s] failed, error code [%d]!\n", hdScanGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query scan group id  by name[%s] successful, scan group id  [%d].\n", hdScanGroups[i].szName, nScanGroupID);

 nRet = ct_query_scan_group(hServer, nScanGroupID, &hdScanGroups[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query scan group [id:%d] failed, error code [%d]!\n", nScanGroupID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query scan group [id:%d] successful.\n", nScanGroupID);

 nRet = ct_modify_scan_group(hServer, nScanGroupID, &hdScanGroups[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify scan group [id:%d] failed, error code [%d]!\n", nScanGroupID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify scan group [id:%d] successful.\n", nScanGroupID);

}

// query scan group of device

nRet = ct_query_scan_groups_of_device(hServer, nDeviceID, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all scan group of device[id: %d] failed,  error code [%d]!\n", nDeviceID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query all scan group of device[id: %d] successful!\n", nDeviceID);

while (true)

{

 memset(&hdScanGroup, 0, sizeof(HDScanGroup));

 nRet = ut_get_item_step(hIter, &hdScanGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("Query one scan group [name:%s] successful!\n", hdScanGroup.szName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query all scan group complete!\n");

  break;

 }

 else

 {

  printf("query scan group failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//delete scan group

for (i = 0; i < nScanGroupNum; ++i)

{

 nRet = ct_delete_scan_group(hServer, hdScanGroups[i].nID);

 if (nRet != RD_SUCCESS)

 {

  printf("delete scan group failed,  error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete scan group [id:%d] successful.\n",  hdScanGroups[i].nID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}


ct_query_scan_group_id_by_name

Navigation: »No topics above this level«

ct_query_scan_group_id_by_name

 Return to chapter overview

ct_query_scan_group_id_by_name

Glossary Item Box

函数

通过扫描组的名字查询扫描组ID

int32 ct_query_scan_group_id_by_name(

HDHANDLE hServer,

uint32 nDeviceID,

const char* szScanGroupName,

uint32* pnScanGroupID

);

参数

hServer

[in] 服务器句柄。

nDeviceID

[in] 扫描组所在设备的ID。

szScanGroupName

[in] 扫描组名称

pnScanGroupID

[out] 扫描组ID

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

scan_group

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

HDHANDLE hIter = NULL;

int32 nTimeOut = 3;

int32 nTryTime = 3;

uint32 nCollectorID = 0;

uint32 nDeviceID = 0;

uint32 nScanGroupID = 0;

HDCollector hdCollector;

HDDevice hdDevice;

HDScanGroup hdScanGroup;

HDScanGroup hdScanGroups[3];

int32 i = 0;

int32 nScanGroupNum = 3;

memset(&hdCollector, 0, sizeof(HDCollector));

memset(&hdDevice, 0, sizeof(HDDevice));

memset(&hdScanGroup, 0, sizeof(HDScanGroup));

for (i = 0; i < 3; ++i)

{

 memset(&hdScanGroups[i], 0, sizeof(HDScanGroup));

}

strncpy(hdCollector.szName, "collector", strlen("collector"));

hdCollector.nType = COLLECTOR_TYPE_OPC;

sprintf(hdCollector.szDescription, "name: %s, type: %d", hdCollector.szName, hdCollector.nType);

strncpy(hdCollector.szExtParam, "***", 3);

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add collector

nRet = ct_add_collector(hServer, &hdCollector);

if (nRet != RD_SUCCESS)

{

 printf("add collector[name:%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add collector[name:%s] successful!\n", hdCollector.szName);

//query collector id

nRet = ct_query_collector_id_by_name(hServer, hdCollector.szName, &nCollectorID);

if (nRet != RD_SUCCESS)

{

 printf("query collector id  by name[%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query collector id  by name[%s] successful, collector id  [%d].\n", hdCollector.szName, nCollectorID);

//add device

strncpy(hdDevice.szName, "device", strlen("device"));

hdDevice.nPort = nPort;

hdDevice.nTimeout = nTimeOut;

hdDevice.nCollectorID = nCollectorID;

hdDevice.nTryTime = nTryTime;

sprintf(hdDevice.szAddr, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdDevice.szDescription, "name: %s, collector id: %d", hdDevice.szName, hdDevice.nCollectorID);

strncpy(hdDevice.szExtParam, "***", 3);

nRet = ct_add_device(hServer, &hdDevice);

if (nRet != RD_SUCCESS)

{

 printf("add device[name:%s] failed, error code [%d]!\n", hdDevice.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add device[name:%s] successful!\n", hdDevice.szName);

//query device id

nRet = ct_query_device_id_by_name(hServer, nCollectorID, hdDevice.szName, &nDeviceID);

if (nRet != RD_SUCCESS)

{

 printf("query device id  by name[%s] failed, error code [%d]!\n", hdDevice.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query device id  by name[%s] successful, device id  [%d].\n", hdDevice.szName, nDeviceID);

//add scan group

for (i = 0; i < nScanGroupNum; ++i)

{

 sprintf(hdScanGroups[i].szName, "scan_group%d", i);

 hdScanGroups[i].nDeviceID = nDeviceID;

 hdScanGroups[i].nPeriod = 10;

 hdScanGroups[i].nPhase = 3;

 hdScanGroups[i].nScanType = 0;

 hdScanGroups[i].nDataAddr = 10000;

 hdScanGroups[i].nDataLen = 100;

 sprintf(hdScanGroups[i].szDescrption, "name: %s, device id: %d", hdScanGroups[i].szName, hdScanGroups[i].nDeviceID);

 strncpy(hdScanGroups[i].szExtParam, "***", 3);

}

for (i = 0; i < nScanGroupNum; ++i)

{

 nRet = ct_add_scan_group(hServer, &hdScanGroups[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add scan group[name:%s] failed, error code [%d]!\n", hdScanGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add scan group[name:%s] successful!\n", hdScanGroups[i].szName);

}

//query scan group id, query scan group, modify scan group

for (i = 0; i < nScanGroupNum; ++i)

{

 nRet = ct_query_scan_group_id_by_name(hServer, nDeviceID, hdScanGroups[i].szName, &nScanGroupID);

 if (nRet != RD_SUCCESS)

 {

  printf("query scan group id  by name[%s] failed, error code [%d]!\n", hdScanGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query scan group id  by name[%s] successful, scan group id  [%d].\n", hdScanGroups[i].szName, nScanGroupID);

 nRet = ct_query_scan_group(hServer, nScanGroupID, &hdScanGroups[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query scan group [id:%d] failed, error code [%d]!\n", nScanGroupID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query scan group [id:%d] successful.\n", nScanGroupID);

 nRet = ct_modify_scan_group(hServer, nScanGroupID, &hdScanGroups[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify scan group [id:%d] failed, error code [%d]!\n", nScanGroupID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify scan group [id:%d] successful.\n", nScanGroupID);

}

// query scan group of device

nRet = ct_query_scan_groups_of_device(hServer, nDeviceID, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all scan group of device[id: %d] failed,  error code [%d]!\n", nDeviceID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query all scan group of device[id: %d] successful!\n", nDeviceID);

while (true)

{

 memset(&hdScanGroup, 0, sizeof(HDScanGroup));

 nRet = ut_get_item_step(hIter, &hdScanGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("Query one scan group [name:%s] successful!\n", hdScanGroup.szName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query all scan group complete!\n");

  break;

 }

 else

 {

  printf("query scan group failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//delete scan group

for (i = 0; i < nScanGroupNum; ++i)

{

 nRet = ct_delete_scan_group(hServer, hdScanGroups[i].nID);

 if (nRet != RD_SUCCESS)

 {

  printf("delete scan group failed,  error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete scan group [id:%d] successful.\n",  hdScanGroups[i].nID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}


ct_query_scan_groups_of_device

Navigation: »No topics above this level«

ct_query_scan_groups_of_device

 Return to chapter overview

ct_query_scan_groups_of_device

Glossary Item Box

函数

查询一个设备下的所有扫描组

int32 ct_query_scan_groups_of_device(

HDHANDLE hServer,

uint32 nDeviceID,

HDHANDLE *pIter

);

参数

hServer

[in] 服务器句柄。

nDeviceID

[in] 扫描组所在设备的ID。

pIter

[in] 查询迭代器

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

scan_group

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

HDHANDLE hIter = NULL;

int32 nTimeOut = 3;

int32 nTryTime = 3;

uint32 nCollectorID = 0;

uint32 nDeviceID = 0;

uint32 nScanGroupID = 0;

HDCollector hdCollector;

HDDevice hdDevice;

HDScanGroup hdScanGroup;

HDScanGroup hdScanGroups[3];

int32 i = 0;

int32 nScanGroupNum = 3;

memset(&hdCollector, 0, sizeof(HDCollector));

memset(&hdDevice, 0, sizeof(HDDevice));

memset(&hdScanGroup, 0, sizeof(HDScanGroup));

for (i = 0; i < 3; ++i)

{

 memset(&hdScanGroups[i], 0, sizeof(HDScanGroup));

}

strncpy(hdCollector.szName, "collector", strlen("collector"));

hdCollector.nType = COLLECTOR_TYPE_OPC;

sprintf(hdCollector.szDescription, "name: %s, type: %d", hdCollector.szName, hdCollector.nType);

strncpy(hdCollector.szExtParam, "***", 3);

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add collector

nRet = ct_add_collector(hServer, &hdCollector);

if (nRet != RD_SUCCESS)

{

 printf("add collector[name:%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add collector[name:%s] successful!\n", hdCollector.szName);

//query collector id

nRet = ct_query_collector_id_by_name(hServer, hdCollector.szName, &nCollectorID);

if (nRet != RD_SUCCESS)

{

 printf("query collector id  by name[%s] failed, error code [%d]!\n", hdCollector.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query collector id  by name[%s] successful, collector id  [%d].\n", hdCollector.szName, nCollectorID);

//add device

strncpy(hdDevice.szName, "device", strlen("device"));

hdDevice.nPort = nPort;

hdDevice.nTimeout = nTimeOut;

hdDevice.nCollectorID = nCollectorID;

hdDevice.nTryTime = nTryTime;

sprintf(hdDevice.szAddr, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdDevice.szDescription, "name: %s, collector id: %d", hdDevice.szName, hdDevice.nCollectorID);

strncpy(hdDevice.szExtParam, "***", 3);

nRet = ct_add_device(hServer, &hdDevice);

if (nRet != RD_SUCCESS)

{

 printf("add device[name:%s] failed, error code [%d]!\n", hdDevice.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add device[name:%s] successful!\n", hdDevice.szName);

//query device id

nRet = ct_query_device_id_by_name(hServer, nCollectorID, hdDevice.szName, &nDeviceID);

if (nRet != RD_SUCCESS)

{

 printf("query device id  by name[%s] failed, error code [%d]!\n", hdDevice.szName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query device id  by name[%s] successful, device id  [%d].\n", hdDevice.szName, nDeviceID);

//add scan group

for (i = 0; i < nScanGroupNum; ++i)

{

 sprintf(hdScanGroups[i].szName, "scan_group%d", i);

 hdScanGroups[i].nDeviceID = nDeviceID;

 hdScanGroups[i].nPeriod = 10;

 hdScanGroups[i].nPhase = 3;

 hdScanGroups[i].nScanType = 0;

 hdScanGroups[i].nDataAddr = 10000;

 hdScanGroups[i].nDataLen = 100;

 sprintf(hdScanGroups[i].szDescrption, "name: %s, device id: %d", hdScanGroups[i].szName, hdScanGroups[i].nDeviceID);

 strncpy(hdScanGroups[i].szExtParam, "***", 3);

}

for (i = 0; i < nScanGroupNum; ++i)

{

 nRet = ct_add_scan_group(hServer, &hdScanGroups[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add scan group[name:%s] failed, error code [%d]!\n", hdScanGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add scan group[name:%s] successful!\n", hdScanGroups[i].szName);

}

//query scan group id, query scan group, modify scan group

for (i = 0; i < nScanGroupNum; ++i)

{

 nRet = ct_query_scan_group_id_by_name(hServer, nDeviceID, hdScanGroups[i].szName, &nScanGroupID);

 if (nRet != RD_SUCCESS)

 {

  printf("query scan group id  by name[%s] failed, error code [%d]!\n", hdScanGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query scan group id  by name[%s] successful, scan group id  [%d].\n", hdScanGroups[i].szName, nScanGroupID);

 nRet = ct_query_scan_group(hServer, nScanGroupID, &hdScanGroups[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query scan group [id:%d] failed, error code [%d]!\n", nScanGroupID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query scan group [id:%d] successful.\n", nScanGroupID);

 nRet = ct_modify_scan_group(hServer, nScanGroupID, &hdScanGroups[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify scan group [id:%d] failed, error code [%d]!\n", nScanGroupID, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify scan group [id:%d] successful.\n", nScanGroupID);

}

// query scan group of device

nRet = ct_query_scan_groups_of_device(hServer, nDeviceID, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all scan group of device[id: %d] failed,  error code [%d]!\n", nDeviceID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query all scan group of device[id: %d] successful!\n", nDeviceID);

while (true)

{

 memset(&hdScanGroup, 0, sizeof(HDScanGroup));

 nRet = ut_get_item_step(hIter, &hdScanGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("Query one scan group [name:%s] successful!\n", hdScanGroup.szName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query all scan group complete!\n");

  break;

 }

 else

 {

  printf("query scan group failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//delete scan group

for (i = 0; i < nScanGroupNum; ++i)

{

 nRet = ct_delete_scan_group(hServer, hdScanGroups[i].nID);

 if (nRet != RD_SUCCESS)

 {

  printf("delete scan group failed,  error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete scan group [id:%d] successful.\n",  hdScanGroups[i].nID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}


ct_query_update_status_inter

Navigation: »No topics above this level«

ct_query_update_status_inter

 Return to chapter overview

ct_query_update_status_inter

Glossary Item Box

函数

查询设备状态更新间隔

int32 ct_query_update_status_inter(HDHANDLE hServer, int32* nInter)

参数

hServer

[in] 服务器句柄

nInter

[out] 更新间隔，单位秒

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

ct_query_update_status_inter

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

int32 nInter = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

// Update status

nRet = ct_query_update_status_inter (hServer,&nInter);

if(nRet != RD_SUCCESS)

{

 printf("Failed to query collector update status inter, error code[%d]!\n", nRet);

 return -1;

}

//disconnect

nt_disconnect(hServer);

return 0;

}


ct_register_collector_change_info

Navigation: »No topics above this level«

ct_register_collector_change_info

 Return to chapter overview

ct_register_collector_change_info

Glossary Item Box

函数

采集器变更通知

void ct_register_collector_change_info(

void (*pFunc)(HDHANDLE, uint32, int8, int8, uint32)

);

参数

(*pFunc)(HDHANDLE, uint32, int8, int8, uint32)

[in] 函数指针。


ct_update_collector_status

Navigation: »No topics above this level«

ct_update_collector_status

 Return to chapter overview

ct_update_collector_status

Glossary Item Box

函数

更新采集器状态

int32 ct_update_collector_status(HDHANDLE hServer, uint32 nCollectorID, uint16 nStatus, int32 nActiveTag);

参数

hServer

[in] 服务器句柄

nCollectorID

[in] 采集器ID

nStatus

[in] 采集器状态

采集器状态有如下取值

DATA_QUALITY_VALUE_CT_BOOTTING // 正在启动

DATA_QUALITY_VALUE_CT_ACTIVE // 活动

DATA_QUALITY_VALUE_CT_SHUTDOWN // 未启动

DATA_QUALITY_VALUE_CT_TIMEOUT // 超时

更新状态为正在启动，会自动检查采集器下的所有点的实时记录是否为停机记录，如果不是，添加一条停机记录。

更新状态为未启动，会自动为采集器下的所有设备添加一条未连接的记录，自动为采集器下的所有点添加一条停机记录

nActiveTag

[in]活动点数

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

举例

ct_update_collector_status

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

uint32 nCollectorID = 1;

int32 nActiveTag = 3;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

// Update status

nRet = ct_update_collector_status(hServer, nCollectorID, DATA_QUALITY_VALUE_CT_BOOTTING, nActiveTag);

if(nRet != RD_SUCCESS)

{

 printf("Failed to update collector status, error code[%d]!\n", nRet);

return -1;

}

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

ct_add_collector

ct_delete_collector

ct_query_all_collectors

ct_query_collector

ct_query_collector_id_by_name

ct_modify_collector


ct_update_device_status

Navigation: »No topics above this level«

ct_update_device_status

 Return to chapter overview

ct_update_device_status

Glossary Item Box

函数

更新设备状态

int32 ct_update_device_status(HDHANDLE hServer, uint32 nDeviceID, uint16 nStatus, int32 nActiveTag)

参数

hServer

[in] 服务器句柄

nDeviceID

[in] 设备的ID

nStatus

[in] 状态

nActiveTag

[in] 活动点个数

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

ct_update_device_status

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

uint32 nDeviceID = 1;

int32 nActiveTag = 3;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

// Update status

nRet = ct_update_device_status(hServer, nDeviceID, DATA_QUALITY_VALUE_DEVICE_CONN, nActiveTag);

if(nRet != RD_SUCCESS)

{

 printf("Failed to update device status, error code[%d]!\n", nRet);

 return -1;

}

//disconnect

nt_disconnect(hServer);

return 0;

}


数据查询

Navigation: »No topics above this level«

数据查询

 Return to chapter overview

数据查询

Glossary Item Box

数据查询主要指查询实时数据库采集到的数据。

主要包括：

系统管理工具查询

SQL查询

excel查询


数据备份

命令行参数说明

Navigation: »No topics above this level«

命令行参数说明

 Return to chapter overview

hdBackupSrv.exe可以命令行运行，参数说明：

-b 执行备份操作

-r 执行恢复操作

-help 显示命令帮助信息

--dir 备份文件的本地保存路径

--server 备份或恢复的实时数据库ip地址

--port 备份或恢复的实时数据库端口号

--user 连接备份或恢复的实时数据库的用户名

--passwd 连接备份或恢复的实时数据库的密码

--starttime 备份或恢复数据的开始时间

--endtime 备份或恢复数据的结束时间

注意：

1.如果没有指定开始时间，则默认从点的第一条记录开始备份；如果结束时间大于备份服务的开始运行时间或没有指定结束时间，则结束时间取备份服务运行时间。

2.一个备份目录只能保存一个实时数据的备份，针对一个备份目录，多次执行备份命令，后一次备份在前一次备份的基础上，备份前一次未备份的时间区间中的数据。例如：第一次备份2012-09-29 08：00至2012-09-29 09：00的数据，第二次备份输入开始时间2012-09-29 07：00：00，结束时间2012-09-29 10：00：00，则第二次备份仅备份7-8点和9-10点的数据，若实时数据库8-9点间有数据删除或新增，不做处理。

3.恢复实时数据库时，需先手动将备份的配置文件拷贝至待恢复的实时数据库，然后启动待恢复的实时数据库，实时数据库必须是空的。


数据库安全

Navigation: »No topics above this level«

数据库安全

 Return to chapter overview

数据库安全

Glossary Item Box

《数据库安全》中包括的接口主要有：

?sc_modify_manage_security

?sc_query_manage_security

安全数据库管理可以对权限管理中组权限和Tag权限进行统一配置，均以为单位设定。

数据结构

/** iHyperDB 权限管理: 安全数据库项:如Tag点、用户组等 */

typedef struct _HDSecItem

{

char szOwnGroupName[HD_LEN_SEC_GROUP_NAME];

char szOperateGroupName[HD_LEN_SEC_GROUP_NAME];

int8 nSecurity;

}HDSecItem;

注意：

1.权限分为“拥有组”、“操作组”、“其他组”三部分。

2.修改安全项时相关信息均可以自行指定，但是最大长度有相应的限制，具体HD_LEN_SEC_GROUP_NAME和权限字段的特点指定。

3.权限有“无”、“只读”、“读写”三种，二进制分别表示为00、01、11。因此权限nSecurity值实际满足一个8位二进制形式的限制。

4.在调用安全数据库管理相关权限时需要用户指定操作类型，目前包含以下四种宏定义的操作。

//global security items

#define GLOBAL_SC_ITEM_MODIFY_TAG 0

#define GLOBAL_SC_ITEM_MODIFY_GROUP 1

#define GLOBAL_SC_ITEM_QUERY_TAG 2

#define GLOBAL_SC_ITEM_QUERY_GROUP 3

©2015. All Rights Reserved.


采集器变更通知

Navigation: »No topics above this level«

采集器变更通知

 Return to chapter overview

采集器变更通知

Glossary Item Box

《采集器变更通知》中的接口主要包括：

ct_register_collector_change_info


采集器

Navigation: »No topics above this level«

采集器

 Return to chapter overview

采集器

Glossary Item Box

《采集器》中的接口主要包括：

?ct_add_collector

?ct_delete_collector

?ct_query_all_collectors

?ct_query_collector

?ct_query_collector_id_by_name

?ct_modify_collector

©2015. All Rights Reserved.


采集器管理接口

Navigation: »No topics above this level«

采集器管理接口

 Return to chapter overview

采集器管理接口

Glossary Item Box

《采集器管理接口》的主要接口分为：

采集器

?ct_add_collector

?ct_delete_collector

?ct_query_all_collectors

?ct_query_collector

?ct_query_collector_id_by_name

?ct_modify_collector

设备接口

?ct_add_device

?ct_delete_device

?ct_query_device

?ct_query_device_id_by_name

?ct_query_devices_of_collector

?ct_modify_device

扫描组

?ct_add_scan_group

?ct_delete_scan_group

?ct_query_scan_group

?ct_query_scan_group_id_by_name

?ct_query_scan_groups_of_device

?ct_modify_scan_group

采集器变更通知

ct_register_collector_change_info


Excel数据上传接口

Navigation: »No topics above this level«

Excel数据上传接口

 Return to chapter overview

Excel的hdSDKSpreadsheet.dll构件中提供了数据上传的接口，用户可以使用该接口手动上传记录数据。需要上传的数据填写在Excel中，可以使用VBA或者其他方式调用数据上传接口，完成数据手动上传。

接口说明如下：

void sdk_spreadsheet_upload_data(int nTagNameStartRow, int nTagNameStartCol, int nCount, int nValueStartRow, int nValueStartCol, int nTimeRow, int nTimeCol);

·输入：Tag名起始行列，记录条数，数据值起始行列，时间戳所在单元格行列号；

·输出：上传记录；

·说明：上传不成功记录的单元格标记为红色字体；

用户可在Tag名，数据值的起始行列处输入该行列的属性，上传数据的起始行列实际从下一行或下一列开始；

上传数据必须按时序数据上传，非时序的数据上传会导致上传失败。


删除Tag点

Navigation: »No topics above this level«

删除Tag点

 Return to chapter overview

删除Tag点

Glossary Item Box

删除普通点时，如果这个点被报警点所监视，那么删除后会使报警点失效。

1. 在“数据源配置”页面Tag点列表中选择一个或多个Tag点后，单击工具栏中的“删除选中的Tag点”按钮，

或者单击选中tag点，右单击，在弹出的菜单中选择“删除服务器上选中的Tag点”，点击后，

弹出对话框

2. 点击确定，在Tag列表中就删掉了需要删除的Tag点，反之，取消。


设备接口

Navigation: »No topics above this level«

设备接口

 Return to chapter overview

设备接口

Glossary Item Box

《设备接口》中的接口主要包括：

?ct_add_device

?ct_delete_device

?ct_query_device

?ct_query_device_id_by_name

?ct_query_devices_of_collector

?ct_modify_device

©2015. All Rights Reserved.


二次开发

Navigation: »No topics above this level«

二次开发

 Return to chapter overview

二次开发

Glossary Item Box

二次开发主要介绍如何在iHyperDB的平台上进行定制化的二次开发，本章节主要介绍了iHyperDB提供的API和SDK，其中API为C接口，SDK包括Python，Java，C++编写的接口。通过二次开发，用户可以实现iHyperDB的行业定制版本。


分类

M

Navigation: »No topics above this level«

M

 Return to chapter overview

iHyperDB使用帮助手册

分类

Send Feedback

Glossary Item Box

A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | 主 | 健 | 关 | 历 | 同 | 实 | 异 | 归 | 扫 | 报 | 插 | 数 | 服 | 查 | 节 | 被 | 设 | 读 | 轮 | 连 | 通 | 采

modbus

Modbus是由Modicon（现为施耐德电器公司的一个品牌）在1979年发明的，是全球第一个真正用于工业现场的总线协议。Modbus采集端作为实时数据库的数据采集客户端之一，支持工业Modbus通信协议，可以从Modbus服务器采集数据并发送到DB服务器。

N

NewGlossaryTerm

O

OPC

OPC(OLE for Process Control)是以Microsoft公司的OLE/COM技术为基础，采用客户/服务器模型制定的一种工业控制领域的开放式标准，主要解决监控程序与其数据源的交互问题。OPC服务器向下对设备数据进行采集，向上与OPC客户应用程序通信完成数据交换。

T

Tag点

对于实时数据库系统而言，数据源（即tag点）是其最基本的存储单元，每个数据源对应实际设备中的一项观测点，观测点在不同时刻的数据值则形成若干条记录。

Tag类型

Tag对应的数据类型，需要与OPC服务器端项的数据类型一致，当类型不一致时，可以发生读取错误，或数据精度损失。

TagID

Tag的内部编号

Tag下载

从服务器下载普通点或者报警点到Excel表格中

Tag上传

用户把点的各种属性在Excel中配好后，上传到实时数据库服务器

Tag查询

在Excel中按照Tag点的各种属性条件从服务器中查询并下载选定的Tag

Tag点

对于实时数据库系统而言，数据源（即tag点）是其最基本的存储单元，每个数据源对应实际设备中的一项观测点，观测点在不同时刻的数据值则形成若干条记录。

主

主动同步配置

指OPC采集端也会根据配置文件中配置的配置同步周期主动向DB服务器问询配置信息，当本地配置与服务器配置不一致时，更新本地配置

健

健康的

test

关

关系数据库

关系数据库，是建立在关系数据库模型基础上的数据库，借助于集合代数等概念和方法来处理数据库中的数据。目前主流的关系数据库有oracle、MySQL、access、db2、sqlserver、sybase等。

历

历史存储记录(时间间隔模式)

一个Tag在起始时间和终止时间区间之内的历史存储记录

历史存储记录(记录条数模式)

一个Tag从某一时刻起指定条数的历史存储记录

历史插值记录（等间隔模式）

一个Tag点在一段区间之内指定时间间隔上的历史插值记录

历史插值记录（等间隔模式）

一个Tag在指定的一个或多个时间点上的历史插值记录

同

同步周期

与DB服务器同步配置的周期。当该周期到来时，OPC采集端向DB服务器请求配置时间戳，当发现本地时间戳与请求的时间戳不同时，更新OPC采集端的配置，并将本地时间戳设置为服务器的时间戳。

实

实时记录

一个或多个Tag点实时的记录

异

异步超时

采用异步读取方式时，当异步读取请求已经发送后，经过该项设置的时间后，检测数据是否已经获取成功，如果获取失败，需要记录日志。值为零时表示不启用。 目前该项功能暂不支持。

归

归档

归档是指将数据从住存储设备中移到成本较低的二级存储设备（DVD-RAM或MO）,来提升系统性能。这种方式能提供数据保护作用和减低对昂贵主存储设备的再度投资。

扫

扫描组

Tag点所属的扫描组。扫描组包含OPC服务器编号、扫描周期、扫描相位、扫描类型等信息。

扫描状态

表示该Tag点是否扫描

报

报警组查看

插

插值记录

根据数据库中已经存在的记录插值计算出的记录。

数

数据源

是提供某种所需要数据的器件或原始媒体。

数据采集(Data Acquision,DAQ)

从传感器和其他设备等模拟和数字被测单元中自动采集非电量或者电量信号，送到上位机中进行分析、处理。被采集的数据是已被转换为电讯号的各种物理量，如温度、水位、风速、压力等，可以是模拟量，也可以是数字量。

数据库网络地址

数据库服务器端的ip地址

数据库网络端口

数据库服务器端的端口号

数据库转储

将iHyperDB中存储的记录数据转储到关系数据库中（Ralation Database，RDB）

服

服务器编号

OPC服务器的编号，由实施人员指定，同一个OPC采集端中不允许该编号重复，数据库中Tag点的nParam1参数与该项对应

查

查看报警组

节

节点名

OPC服务器所在计算机节点名称，可以为主机名或IP地址

被

被动同步配置

指当DB服务器端点信息发生变化时，如新增修改或删除节点，会发送消息到相关的OPC采集端，采集端根据收到的配置变更信息更新本地的节点信息。

设

设备点名

与OPC服务器中的项编号相对应，指定该Tag点对应OPC服务器中的哪个项

读

读取方式

从该OPC服务器读取数据的方式。零为异步，非零为同步

读取位置

从OPC服务器读取数据的位置。零为直接从设备获取数据，此种方式速度慢，非零从OPC服务器的缓存中读取数据，此种方式读取速度快

轮

轮询

在轮询模式下，采集器会每隔一个固定的周期对设备数据进行扫描。

连

连接检测周期

检查与DB服务器端连接的周期。当该周期到来时，OPC采集端向DB服务器请求配置时间戳，如果成功，表明连接正常，如果失败，则测试连接，当连接中断时，进行重连。

通

通知

在通知模式下，采集器将扫描组信息注册到设备，当数据发生变化时，通知采集器扫描读取数据。

采

采集接口名

与配置文件中接口属性配置项中的接口名相对应，指定该Tag点由哪个采集接口进行采集

©2015. All Rights Reserved.


HPUX版本使用说明

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

<HTMLScrapTable Version="6.0">

<HTMLScrap Name="_BREADCRUMBS"><![CDATA[%%replaceinquotes:value=False%%%%filtereditemlist:namespace=link,filter="type=breadcrumbs",Source=Item,scrap=BREADCRUMBITEMS,NoFooter=True,Format="%%filtereditemlist%% > %%ItemTitle%%</td></tr></table>"%%]]></HTMLScrap>

<HTMLScrap Name="_BREADCRUMBITEMS_HEADER"><![CDATA[<table width="100%" id="pagetopbreadcrumbs" cellspacing="0" cellpadding="0"><tr><td>]]></HTMLScrap>

<HTMLScrap Name="_BREADCRUMBITEMS_BODY">%%breadcrumblink%%</HTMLScrap>

<HTMLScrap Name="_BREADCRUMBITEMS_SEPARATOR"><![CDATA[ > ]]></HTMLScrap>

<HTMLScrap Name="_CATEGORISED_LINKS_BODY"><![CDATA[%%replaceinquotes:value=false%%%%ItemName:format="<p><b>%%ItemName%%</b><br />"%%%%filtereditemlist:scrap=LINK,Namespace=Link%%</p>]]></HTMLScrap>

<HTMLScrap Name="_COLLAPSIBLE_HEADER"><![CDATA[<h1 class="heading"><span class="expandcollapse" tabindex="0"><img id="%%idprefix%%Toggle" class="toggle" name="toggleSwitch" src="images/collapse.gif"></img>%%caption%%</span></h1><div id="%%idprefix%%Section" class="section" name="collapseableSection">]]></HTMLScrap>

<HTMLScrap Name="_COMMUNITY_PROPERTIES"><![CDATA[<script type="text/javascript">%%crlf%%var communityBaseUrl="%%communitybaseurl%%";%%crlf%%var communityPhraseLanguage="%%phraselanguage%%";%%crlf%%communityBaseUrl=communityBaseUrl.replace(/^\s+|\s+$/g, '');%%crlf%%if (communityBaseUrl.substring(communityBaseUrl.length,communityBaseUrl.length) != '/') communityBaseUrl = communityBaseUrl + '/';%%crlf%%var communityProjectKey=encodeURIComponent("%%communityprojectkey%%");%%crlf%%</script>%%crlf%%<div id="communityPhrases"><span id="ic_Loading">$$COMMUNITY_LOADING$$</span><span id="ic_SignInToView">$$COMMUNITY_SIGNINTOVIEW$$</span><span id="ic_NoNotes">$$COMMUNITY_NONOTES$$</span><span id="ic_NoComments">$$COMMUNITY_NOCOMMENTS$$</span><span id="ic_ConfirmDelete">$$COMMUNITY_CONFIRMDELETE$$</span>%%crlf%%</div>]]></HTMLScrap>

<HTMLScrap Name="_COMMUNITY_FOOTER"><![CDATA[<div class="fullwidthfooter" id="communityfooter"><script>var communityItemId = "HS-%%communityitemid%%";</script>%%replaceinquotes:value=false%%%%scrap:name=_COMMUNITY_SECTION,contenttype=page%%</div>]]></HTMLScrap>

<HTMLScrap Name="_COMMUNITY_PRIVATECONTENT"><![CDATA[<div class="communityprivatecontainer"><div class="communityprivatecontentcontainer" id="communityprivatecontent|%%itemid%%|%%contenttype%%"></div><div class="communityprivatecontentcommands"><a href="javascript:ic_addPrivateContent('%%contenttype%%')">$$COMMUNITY_ADDNOTE$$</a><div class="communitycreate" id="communityprivatecreate|%%itemid%%|%%contenttype%%"></div></div></div>]]></HTMLScrap>

<HTMLScrap Name="_COMMUNITY_PUBLICCONTENT"><![CDATA[<div class="communitypubliccontainer"><div class="communitypubliccontentcontainer" id="communitypubliccontent|%%itemid%%|%%contenttype%%"></div><div class="communitypubliccontentcommands"><a href="javascript:ic_addPublicContent('%%contenttype%%')">$$COMMUNITY_ADDCOMMENT$$</a><div class="communitycreate" id="communitypubliccreate|%%itemid%%|%%contenttype%%"></div></div></div>]]></HTMLScrap>

<HTMLScrap Name="_COMMUNITY_RATING"><![CDATA[<div class="communityratingcontainer"><div class="communityratingcontentcontainer" id="communitypubliccontent|HS-%%communityitemid%%|##RATING"></div></div>]]></HTMLScrap>

<HTMLScrap Name="_COMMUNITY_MENU"><![CDATA[<div class="dxpopupbubble" id="dxcommunitymenu">%%crlf%%<input id="CommunityShowPrivateCheckbox" type="checkbox" name="communityFilter" onClick="ic_setCommunityFeatureVisibility(this)" />%%crlf%%<label class="communityFilter" for="CommunityShowPrivateCheckbox">$$COMMUNITY_SHOWNOTES$$</label><br />%%crlf%%<input id="CommunityShowPublicCheckbox" type="checkbox" name="communityFilter" onClick="ic_setCommunityFeatureVisibility(this)" />%%crlf%%<label class="communityFilter" for="CommunityShowPublicCheckbox">$$COMMUNITY_SHOWPUBLIC$$</label>%%crlf%%</div>]]></HTMLScrap>

<HTMLScrap Name="_COMMUNITY_DROPDOWN"><![CDATA[<span id="communityFilterToolTip" style="cursor:default;" onclick="showBox('dxcommunitymenu',event,document.getElementById('communityFilterImage'))" onmouseover='document.getElementById("communityFilterImage").src=document.getElementById("dropDownHoverImage").src;' onfocusin='document.getElementById("communityFilterImage").src=document.getElementById("dropDownHoverImage").src;' onmouseout='document.getElementById("communityFilterImage").src=document.getElementById("dropDownImage").src;' onfocusout='document.getElementById("communityFilterImage").src=document.getElementById("dropDownImage").src;'>%%crlf%%<img id="communityFilterImage" src="images/drpdown.gif"/>%%crlf%%<label id="showNoCommunityContentLabel" for="communityFilterImage" style="display: none;">$$COMMUNITY_FEATURES_NONE$$</label><label id="showAllCommunityContentLabel" for="communityFilterImage" style="display: none;">$$COMMUNITY_FEATURES_ALL$$</label><label id="showPrivateCommunityContentLabel" for="communityFilterImage" style="display: none;">$$COMMUNITY_FEATURES_NOTES$$</label><label id="showPublicCommunityContentLabel" for="communityFilterImage" style="display: none;">$$COMMUNITY_FEATURES_PUBLIC$$</label>%%crlf%%</span>]]></HTMLScrap>

<HTMLScrap Name="_COMMUNITY_SECTION"><![CDATA[%%replaceinquotes:value=false%%%%scrap:name=_COMMUNITY_PRIVATECONTENT,itemid="HS-%%communityitemid%%",contenttype="%%contenttype%%"%%%%scrap:name=_COMMUNITY_PUBLICCONTENT,itemid="HS-%%communityitemid%%",contenttype="%%contenttype%%"%%]]></HTMLScrap>

<HTMLScrap Name="_DESIGN_BANNER"><![CDATA[<div id="designbanner" title="Document! X Design Time Information Banner">%%bannercontents%%</div>]]></HTMLScrap>

<HTMLScrap Name="_DESIGN_ITEM"><![CDATA[<a title="Edit this %%itemtype%%" href="designcommand:name=edit,id='%%tcid%%'" style="position: relative; top: 2px; left: 5px"><img src="designtime\edit.gif" border=0/></a>&nbsp;<a title="Delete this %%itemtype%%" href="designcommand:name=delete,id='%%tcid%%'" style="position: relative; top: 2px; left: 5px;"><img src="designtime\delete.gif" border=0/></a>]]></HTMLScrap>

<HTMLScrap Name="_DESIGN_LIST"><![CDATA[<a title="Add a new %%itemtype%%" onclick="event.cancelBubble = true;" href="designcommand:name=addnew,tc=%%tagidentifier%%"><img style="position: relative; top: 2px; left: 5px" src="designtime\new.gif" border=0/></a>]]></HTMLScrap>

<HTMLScrap Name="_DESIGN_SUPPORT"><![CDATA[<link rel="stylesheet" type="text/css" href="designtime/designtime.css"><script src="designtime/designtime.js"></script><div id="hsDesignTimeLoad" onclick="hsDTLoad()" style="visibility: none;"></div><div id="hsDesignTimeSave" onclick="hsDTSave()" style="visibility: none;"></div>]]></HTMLScrap>

<HTMLScrap Name="_GLOSSARYITEMSLIST_BODY"><![CDATA[%%ReplaceInQuotes:Value=True%%<p><a name="%%GlossaryItemTerm%%"></a><strong>%%GlossaryItemTerm%%</strong><br />%%crlf%%%%glossaryitemrawdefinition%%</p>]]></HTMLScrap>

<HTMLScrap Name="_GLOSSARYLETTERSHEADER_BODY">%%GlossaryLetterLink%%</HTMLScrap>

<HTMLScrap Name="_GLOSSARYLETTERSHEADER_SEPARATOR"> | </HTMLScrap>

<HTMLScrap Name="_GLOSSARYLETTERSLIST_BODY"><![CDATA[%%ReplaceInQuotes:Value=True%%<h1><a name="%%GlossaryLetter%%"></a>%%GlossaryLetter%%</h1><BLOCKQUOTE>%%FilteredItemList:Scrap=GLOSSARYITEMSLIST,Namespace=Glossary Item%%</BLOCKQUOTE>]]></HTMLScrap>

<HTMLScrap Name="_GLOSSARYLETTERSLIST_FOOTER"><![CDATA[<p>&nbsp;</p>]]></HTMLScrap>

<HTMLScrap Name="_GLOSSARYREFERENCE"><![CDATA[%%ReplaceInQuotes:Value=True%%<a class="hsglossaryreference" title="Click to show a definition of this term" onclick="javascript:hsShowGlossaryItemBox('%%GlossaryItemTerm:ForScript=True%%','%%GlossaryItemDefinition:ForScript=True%%',event)">%%GlossaryItemReference%%</a>]]></HTMLScrap>

<HTMLScrap Name="_INDEXCONTENT_ENTRY_BODY"><![CDATA[<LI><OBJECT type="text/sitemap">%%crlf%%<param name="Name" value="%%Keyword%%" >%%crlf%%%%ReplaceInQuotes:Value=False%%%%filtereditemlist:namespace=keyword jump,scrap=_INDEXCONTENT_ENTRYJUMP,NoHeader=True,NoFooter=True,blankformat="<param name=""See Also"" value=""%%ItemName%%"">"%%</OBJECT> %%crlf%%%%filtereditemlist:Namespace=Keyword,Scrap=_INDEXCONTENT_ENTRY,NoHeader=True,NoFooter=True,Format="<UL>%%FilteredItemList%%</UL>"%%]]></HTMLScrap>

<HTMLScrap Name="_INDEXCONTENT_ENTRY_V2_BODY"><![CDATA[<Keyword Term = "%%Keyword%%">%%crlf%%%%filtereditemlist:namespace=keyword jump,scrap=INDEXCONTENT_ENTRYJUMP_V2,NoHeader=True,NoFooter=True%% %%ReplaceInQuotes:Value=False%%%%filtereditemlist:Namespace=Keyword,Scrap=_INDEXCONTENT_ENTRY_V2,NoHeader=True,NoFooter=True%%</Keyword>%%crlf%%]]></HTMLScrap>

<HTMLScrap Name="_INDEXCONTENT_ENTRY_V2_F_BODY"><![CDATA[<Keyword Term = "%%Keyword%%">%%crlf%%%%filtereditemlist:namespace=keyword jump,scrap=INDEXCONTENT_ENTRYJUMP_V2,NoHeader=True,NoFooter=True%% %%ReplaceInQuotes:Value=False%%%%filtereditemlist:Namespace=Keyword,Scrap=_INDEXCONTENT_ENTRY_V2,NoHeader=True,NoFooter=True%%</Keyword>%%crlf%%]]></HTMLScrap>

<HTMLScrap Name="_INDEXCONTENT_ENTRY_V2_A_BODY"><![CDATA[<Keyword Term = "%%Keyword%%">%%crlf%%%%filtereditemlist:namespace=keyword jump,scrap=INDEXCONTENT_ENTRYJUMP_V2,NoHeader=True,NoFooter=True%% %%ReplaceInQuotes:Value=False%%%%filtereditemlist:Namespace=Keyword,Scrap=_INDEXCONTENT_ENTRY_V2,NoHeader=True,NoFooter=True%%</Keyword>%%crlf%%]]></HTMLScrap>

<HTMLScrap Name="_INDEXCONTENT_ENTRY_WEB_BODY"><![CDATA[%%ReplaceInQuotes:Value=False%%%%filtereditemlist:namespace=keyword jump,scrap=_INDEXCONTENT_ENTRYJUMP_WEB,NoHeader=True,NoFooter=True,blankformat="%%Keyword%%"%%%%filtereditemlist:Namespace=Keyword,Scrap=_INDEXCONTENT_ENTRY_WEB,NoHeader=True,NoFooter=True,Format="<blockquote>%%FilteredItemList%%</blockquote>",BlankFormat="<br />"%%%%crlf%%]]></HTMLScrap>

<HTMLScrap Name="_INDEXCONTENT_ENTRYJUMP_BODY"><![CDATA[%%ReplaceInQuotes:Value=True%%<param name="Local" value="%%KeywordTarget%%" >%%crlf%%]]></HTMLScrap>

<HTMLScrap Name="_INDEXCONTENT_ENTRYJUMP_V2_BODY"><![CDATA[%%ReplaceInQuotes:Value=True%%<Jump Url = "%%KeywordTarget%%"/>%%crlf%%]]></HTMLScrap>

<HTMLScrap Name="_INDEXCONTENT_ENTRYJUMP_WEB_BODY"><![CDATA[%%ReplaceInQuotes:Value=True%%<a target="webcontent" href="%%KeywordTarget%%">%%Keyword%%</a>]]></HTMLScrap>

<HTMLScrap Name="_INDEXCONTENT_ENTRYJUMP_WEB_SEPARATOR"><![CDATA[<br />%%crlf%%]]></HTMLScrap>

<HTMLScrap Name="_LANGUAGE_LIST_BODY"><![CDATA[<p><a href="" onClick="setLanguageFilter('%%ItemName%%')">%%LanguageCaption%%</a></p>]]></HTMLScrap>

<HTMLScrap Name="_LANGUAGE_LIST_FOOTER"><![CDATA[<p><a href="" onClick="setLanguageFilter('All')">Show All</a></p>]]></HTMLScrap>

<HTMLScrap Name="_LANGUAGE_LIST_HEADER"/>

<HTMLScrap Name="_LINK_BODY"><![CDATA[%%ReplaceInQuotes:Value=True%%<a href="%%linktarget%%">%%linktitle%%</a>%%designitem%%]]></HTMLScrap>

<HTMLScrap Name="_LINK_SEPARATOR"><![CDATA[<br />]]></HTMLScrap>

<HTMLScrap Name="_LINKS_BODY"><![CDATA[<p>%%filtereditemlist:scrap=LINK,Namespace=Link%%</p>]]></HTMLScrap>

<HTMLScrap Name="_FEEDBACK_BASIC"><![CDATA[<div class="fullwidthfooter" id="feedback"><form action="%%FeedbackURL%%" method="post" id="frmUserFeedback" style="display: block"><table class="feedback"><tr><td colspan="11" class="feedbackprompt">How would you rate the usefulness of this content?<input id="fldProject" name="project" type="hidden" value="%%ProjectID%%" /><input id="fldTopic" name="topic" type="hidden" value="%%TopicID%%" /><input id="fldEdition" name="edition" type="hidden" value="%%buildprofilename%%" /></td></tr><tr><td></td><td align="center">1</td><td align="center">2</td><td align="center">3</td><td align="center">4</td><td align="center">5</td><td align="center">6</td><td align="center">7</td><td align="center">8</td><td align="center">9</td><td></td></tr><tr><td class="feedbackcaption">Poor</td><td align="center"><input id="rating1" name="rating" type="radio" value="1" /></td><td align="center"><input id="rating2" name="rating" type="radio" value="2" /></td><td align="center"><input id="rating3" name="rating" type="radio" value="3" /></td><td align="center"><input id="rating4" name="rating" type="radio" value="4" /></td><td align="center"><input id="rating5" name="rating" type="radio" value="5" /></td><td align="center"><input id="rating6" name="rating" type="radio" value="6" /></td><td align="center"><input id="rating7" name="rating" type="radio" value="7" /></td><td align="center"><input id="rating8" name="rating" type="radio" value="8" /></td><td align="center" valign="middle"><input id="rating9" name="rating" type="radio" value="9" /></td><td class="feedbackcaption">Outstanding</td></tr><tr><td colspan="11" style="height: 10px"></td></tr><tr><td colspan="11">Optional: Tell us why you rated the content this way.</td></tr><tr><td colspan="11"><textarea id="txtFeedback" name="feedback" rows="4" cols="40" style="width: 100%"></textarea></td></tr><tr><td colspan="11" align="right"><input id="btnSubmit" name="submit" type="submit" value="Submit" /></td></tr></table></form></div>]]></HTMLScrap>

<HTMLScrap Name="_FEEDBACK_WITH_USER_DETAILS"><![CDATA[<div class="fullwidthfooter" id="feedback"><form action="%%FeedbackURL%%" method="post" id="frmUserFeedback" style="display: block"><table class="feedback"><tr><td colspan="11" class="feedbackprompt">How would you rate the usefulness of this content?<input id="fldProject" name="project" type="hidden" value="%%ProjectID%%" /><input id="fldTopic" name="topic" type="hidden" value="%%TopicID%%" /><input id="fldEdition" name="edition" type="hidden" value="%%buildprofilename%%" /></td></tr><tr><td></td><td align="center">1</td><td align="center">2</td><td align="center">3</td><td align="center">4</td><td align="center">5</td><td align="center">6</td><td align="center">7</td><td align="center">8</td><td align="center">9</td><td></td></tr><tr><td class="feedbackcaption">Poor</td><td align="center"><input id="rating1" name="rating" type="radio" value="1" /></td><td align="center"><input id="rating2" name="rating" type="radio" value="2" /></td><td align="center"><input id="rating3" name="rating" type="radio" value="3" /></td><td align="center"><input id="rating4" name="rating" type="radio" value="4" /></td><td align="center"><input id="rating5" name="rating" type="radio" value="5" /></td><td align="center"><input id="rating6" name="rating" type="radio" value="6" /></td><td align="center"><input id="rating7" name="rating" type="radio" value="7" /></td><td align="center"><input id="rating8" name="rating" type="radio" value="8" /></td><td align="center" valign="middle"><input id="rating9" name="rating" type="radio" value="9" /></td><td class="feedbackcaption">Outstanding</td></tr><tr><td colspan="11" style="height: 10px"></td></tr><tr><td colspan="11">Optional: Tell us why you rated the content this way.</td></tr><tr><td colspan="11"><textarea id="txtFeedback" name="feedback" rows="4" cols="40" style="width: 100%"></textarea></td></tr><tr><td colspan="11">Your Name: <input type="text" name="userName" size="30"></td></tr><tr><td colspan="11">Your email address: <input type="text" name="userEmail" size="30"></td></tr><tr><td colspan="11" align="right"><input id="btnSubmit" name="submit" type="submit" value="Submit" /></td></tr></table></form></div>]]></HTMLScrap>

<HTMLScrap Name="_WEB_TOCNODE_PAGE"><![CDATA[%%ReplaceInQuotes:Value=True%%<li class="tbc" icon="%%icon%%" isnew="%%isnew%%"><a href="%%nodetarget%%"><img class="icon"/><span class="nodetext">%%nodecaption%%</span></a>]]></HTMLScrap>

<HTMLScrap Name="_WEB_TOCNODE_TITLE"><![CDATA[<li class="tbc" icon="%%icon%%"><a href="#" target="lbottom"><img class="icon"/><span class="nodetext">%%nodecaption%%</span></a>]]></HTMLScrap>

<HTMLScrap Name="_XML_TOCNODE_PAGE"><![CDATA[<node url="%%nodetarget%%" isnew="%%isnew%%" icon="%%icon%%">%%nodecaption%%</node>]]></HTMLScrap>

<HTMLScrap Name="_XML_TOCNODE_TITLE"><![CDATA[<node url="" isnew="%%isnew%%" icon="%%icon%%">%%nodecaption%%</node>]]></HTMLScrap>

</HTMLScrapTable>


从单机到双机热备冗余的升级

Navigation: »No topics above this level«

从单机到双机热备冗余的升级

 Return to chapter overview

从单机到双机热备冗余的升级操作方式分以下两种版本：

v3.2-3.5版本升级操作
v3.6以上版本升级操作

实时数据库v3.2-3.5版本升级操作方法

双机热备网络结构说明请参考“iHyperDB常见网络结构”。

对于已经部署并运行的单机（机器为A）项目，升级为双机热备（机器为A和B）步骤如下:

1.打开系统管理工具，连接到A并配置数据节点将A和B作为数据节点主备地址；

2.机器A上所有服务重启；

3.机器A上的实时数据库升级到最新版本；

4.机器B上新安装实时数据库的最新版本，包括配置中心和数据节点；

4.1.机器B安装配置中心，选择“配置中心部署双机冗余服务器”，配置主备配置中心地址，不要勾选“执行PostgreSQL初始配置”，示意图如下：

4.2.机器B上安装数据节点，配置“内存缓存区大小”“硬盘数据文件大小”和“硬盘数据文件个数”，注意这几个参数必须要与机器A上配置的参数完全一致，如果不知道机器A配置的参数可以打开机器A安装目录config/ServerCfg.xml查看；

选择多服务器，分布式节点部署，配置本机IP和配置中心主备地址。

机器B上的配置中心和数据节点都安装完成。

关闭机器A的实时数据库的后台服务。

A机器上打开PostgreSQL客户端将数据库备份成文件**.backup，并将该备份文件拷贝到机器B上。

修改机器A上安装目录下config/ConfigCenter.xml中主备配置中心地址如下

修改机器A上安装目录下config/ServerCfg.xml中主备配置中心的配置项如下

拷贝机器A的安装目录下config/Config.db和config/Alarm.db到机器B的安装目录下的config目录覆盖原文件。

拷贝机器A的安装目录下Data文件夹到机器B的安装目录下覆盖原文件夹。

机器B打开PostgreSQL客户端恢复 A机器上拷贝过来的备份文件

启动机器A和机器B上实时数据库服务，服务端的主备升级完成。

下面是客户端主要功能模块的升级，包括采集器，关系数据库转储，组态运行客户端。

ØOPC采集器，Modbus采集器的升级

1.打开采集器配置工具；

2.连接主备配置中心地址；

3.停止所有采集器；

4.重新保存采集器配置；

5.启动采集器。

Ø关系数据库转储的升级

1.打开系统管理工具；

2.连接到主备配置中心地址；

3.重新启动关系数据库转储服务。

Ø组态的升级

1.打开系统管理工具并连接到主备地址；

2.选中组态-节点管理，修改可访问的实时数据库地址，修改为主备地址；

3.选中全部分发-全选-分发；

4.重启所有组态运行客户端，验证功能。可通过停止主机服务的方式切换主备，验证双机热备是否生效。

实时数据库v3.6版本升级操作方法

对于已经部署并运行的单机（机器为A）项目，升级为双机热备（机器为A和B）步骤如下:

1.此操作步骤是ihd 3.6及其以上版本的升级操作；

2.打开系统管理工具，连接到A并配置数据节点将A和B作为数据节点主备地址；

3.机器A（主）上所有服务重启；

4.机器B（备）完全卸载并重新安装实时数据库的最新版本（与机器A版本一致），包括配置中心和数据节点；

4.1.机器B（备）安装配置中心，选择“配置中心部署双机冗余服务器”，配置主备配置中心地址，示意图如下：

4.2.机器B上安装数据节点，配置“内存缓存区大小”“硬盘数据文件大小”和“硬盘数据文件个数”，注意这几个参数必须要与机器A上配置的参数完全一致，如果不知道机器A配置的参数可以打开机器A安装目录config/ServerCfg.xml查看；

选择多服务器，分布式节点部署，配置本机IP和配置中心主备地址。

机器B上的配置中心和数据节点都安装完成。

关闭机器A的实时数据库的后台服务。

拷贝机器A的安装目录下config/Config.db和configCenter.db到机器B的安装目录下的config目录覆盖原文件。

重启启动机器A和机器B上实时数据库服务，服务端的主备升级完成。


导入已有表

Navigation: »No topics above this level«

导入已有表

 Return to chapter overview

导入已有表

Glossary Item Box

本节介绍从关系数据库中“导入已有表”的转储配置以及注意事项：

1. 选择表的类型，窄表或宽表；

2. 若是宽表，则选择时间戳的映射匹配字段，时间戳对应的匹配字段是必选的，时间戳可匹配字段见添加转储表；

3. 若是窄表，选择Tag名，时间戳，数据质量，数据值字段的映射匹配，

Tag名、时间戳、数据值对应的字段是必选的。

选择数据质量是否匹配，如果不匹配则转储服务不转储数据质量到对应表中。

4. 点击确定，匹配成功。

?字段选择不能重复，若重复，弹出错误提示，匹配不成功；

?匹配的字段要符合数据库转储的匹配原则。


安装英文版iHyperDB

Navigation: »No topics above this level«

安装英文版iHyperDB

 Return to chapter overview

安装英文版iHyperDB

开始使用 > 安装和卸载iHyperDB > 安装英文版iHyperDB

iHyperDB支持英文和简体中文,安装程序exe提供2份，安装后显示对应语言。

安装后提供hdI18N.exe语言切换工具，位于安装目录的executable文件夹内。

注意事项：

1、中文系统使用英文安装程序，可能安装程序的确定按钮是中文。

2、开始菜单，根据安装程序语言版本确定,不能在安装后切换。

3、客户端服务管理界面的描述，根据安装程序语言版本确定,不能在安装后切换。

4、系统点的描述默认为英文，与安装程序语言和切换都无关。

5、Excel里面的函数默认为英文，与安装程序语言和切换都无关。

6、日志文件中的中文在英文系统可能默认显示不了，拷贝到中文系统可以显示。

7、当用户使用IHD的语言切换功能时,首先要切换操作系统的显示语言,以英文win7操作系统为例 在control panel ->change display language->选择tab页 administrative ->change system local 在里面切换语言为chinese(prc)就可以了，如果切换回英文，用户需要将系统的该属性切换回英文english（united states）


IP地址发生变化时如何修改

Navigation: »No topics above this level«

IP地址发生变化时如何修改

 Return to chapter overview

iHD服务器IP地址发生变化时如何修改？

一 单机版

单机版指的是服务器只有一台机器，配置中心和数据节点都安装在该机器。如果该机器IP地址发生变化（例如从168.2.237.54变为192.168.198.1）时按照下面的步骤修改：

1、启动服务端的所有服务。

2、打开系统管理工具，连接到服务器的新地址192.168.198.1。

3、点击系统管理工具 - 数据节点配置-修改。将老的IP地址修改为新的IP地址。

4、重启所有的ihd的程序，包括服务端和客户端，配置生效。

二 非单机版IP地址发生改变时如何修改

服务器操作系统是windows按如下步骤修改：

1、在安装数据节点的服务器上打开“数据节点服务管理工具”

2、 在数据节点服务管理工具的系统参数界面按照实际的环境修改配置中心主机IP、配置中心备机IP、本机IP，保存，保存完成后重启服务。

3、在其它数据节点所在的服务器上重复第1步和第2步，修改实际IP地址并重启服务。

4、按照单机版的前3步依次操作在系统管理工具界面上修改数据节点地址。

5、重启所有的ihd的程序，包括服务端和客户端，配置生效。

服务器为非window系统时按照如下步骤操作：

·

1、在安装配置中心的机器上打开安装目录下的config/ ConfigCenter.xml文件，按照实际情况进行修改。

HostAddr为主机地址。

BackUpAddr为备机地址，没有备机就为空。

ArbiterAddr为网络检测IP地址，如果没有配置主备或者不启用该功能则为空。

2、在安装数据节点的机器上打开安装目录下的config/ SeverCfg.xml文件，按照实际情况进行修改。

bakeip 为配置中心备机地址，按实际情况修改，如果没有备机则为空。

bakeport 为配置中心备机端口，不用修改。

identity 修改为-1。

localhostIP 为本机IP，按实际情况修改。

mainip 为配置中心主机IP，按实际情况修改。

mainport 为配置中心主机端口，不用修改。

3、启动所有的服务。

4、按照单机版的前3步依次操作，在系统管理工具界面上修改数据节点地址。

5、重启所有的ihd的程序，包括服务端和客户端，配置生效。


Java SDK

Navigation: »No topics above this level«

Java SDK

 Return to chapter overview

Java SDK

Glossary Item Box

Java SDK提供了与iHyperDB实时数据库服务进行交互的可以供Java语言直接调用的接口。

详细内容请参考SDK文档。


日志展示

Navigation: »No topics above this level«

日志展示

 Return to chapter overview

日志展示

Glossary Item Box

日志展示系统是一个收集远程服务端日志并将其展示在客户端界面的软件，使开发维护人员可以方便地查看多个远程服务端产生的日志。

1. 检查日志本地配置文件：日志配置文件安装在客户端目录下的Config文件夹下的LogPath.xml，确保该配置文件中的路径"G:\iHyperDB\Config\LogClient.cml"对应本地中的配置文件.

示例中的G:\iHyperDB\Config\LogClient.cml路径对应的是客户端日志，如果需要查看服务端日志，路径可改为G:\iHyperDB\Config\Log.xml

2. 单击快速启动中的日志展示

弹出日志展示对话框

!MISSING PHRASE ' 点击扩大 '!

!MISSING PHRASE ' 点击缩小 '!

2.点击菜单栏中连接菜单，在弹出的添加服务器界面输入ip地址和端口号，点击确定按钮（如下图所示），新添加的服务器显示在左边的服务器列表树中

注意：

1）ip地址必须是xxx.xxx.xxx.xxx的点分制,合法ip地址；

2）端口号必须为5679；

3）服务器名不能和已经添加的服务器名重复。

在服务器列表视图空白处点击鼠标右键，同样可弹出添加服务器对话框。

3. 点击左边的服务器展开列表，

!MISSING PHRASE ' 点击扩大 '!

!MISSING PHRASE ' 点击缩小 '!

选中一个需要查询的模块，选择需要查询的时间，点击查询按钮，系统弹出查询的进度并将查询出的日志显示在日志列表中，如下图所示：

小提示：

1）鼠标左键单击某模块，若日志列表中存在该模块日志，则这些日志记录字体变白，背景色变黑；

2）鼠标左键双击某模块，若该模块日志已被加载，将仅显示该模块日志；

3）鼠标右键单击某模块，弹出右键菜单，可以选择“仅显示此模块日志”和“忽略此模块日志”；

4）使用Ctrl+F5快捷键或者点击工具->刷新菜单，可以依据当前的查询条件从新查询模块日志。

4.点击工具->清空菜单或使用Ctrl+C快捷键，清空日志显示列表

©2015. All Rights Reserved.


匹配宽表字段

Navigation: »No topics above this level«

匹配宽表字段

 Return to chapter overview

匹配宽表字段

Glossary Item Box

本节介绍“匹配宽表字段”的转储配置，包括每个Tag点对应的字段信息，以及注意事项。

1.选择需要匹配的Tag点，以及数据值或数据质量属性，选择需要匹配的关系数据库中的字段；

2.点击下向的箭头，在匹配结果中显示所选择匹配项；

3.在匹配结果中，选择需要删除的匹配项，点击上向箭头，匹配结果中将删除该项；

4.依次匹配完后，点击完成匹配，回到主配置界面;点击取消，取消字段匹配，回到设置规则或新建规则界面；

5.主界面中规则列表会进行更新。


修改Tag点

Navigation: »No topics above this level«

修改Tag点

 Return to chapter overview

修改Tag点

Glossary Item Box

1. 点击数据源配置页面的"修改Tag点"按钮，

弹出Tag属性对话框

此时可对Tag属性的页面进行修改，注意基本页面的Tag名称，Tag类别和Tag类型，数字量集是不可更改的，采集、存储、报警、权限和系统页面是可修改的。

2. 修改完毕，点击确定。

修改Tag点时，是不能修改Tag的名称、类别、类型的，即：只能修改不是灰化的属性。

具体的修改选项，请参考：新增Tag点。


部署单机双网冗余

Navigation: »No topics above this level«

部署单机双网冗余

 Return to chapter overview

示例：

部署环境：1台有双网卡的windows服务器（例如地址为168.2.9.94和168.2.237.54）和1台window客户端机器，客户端机器能同时连接到168.2.9.94和168.2.237.54， 实时数据库安装程序版本3.5.0及以上。网络结构说明请参考“iHyperDB常见网络结构”

1.服务器上安装配置中心，配置中心程序名称为iHyperDB_ServerInstall.exe。

请注意在这一步将主服务器IP和备服务器IP配置分别配置为服务器的2个IP地址168.2.9.94和168.2.237.54,并且不要勾选网络检测IP。

2. 服务器上安装数据节点，数据节点程序名称为iHyperDB_DataNode.exe。

本机IP选择168.2.9.94和168.2.237.54中的其中一个。

安装之后点击安装完成。

3. 客户端机器上安装实时数据库客户端，客户端程序名称为iHyperDB_Client.exe。

勾选excel插件，点击安装完成插件的安装。

4.在服务器上打开数据节点服务管理工具，启动所有服务。数据节点管理工具在开始菜单可以找到。

注意第一次启动hdKernel的启动状态会一直处于正在启动状态，这是因为第5步添加数据节点还没有完成，完成第5步hdKernel的启动就会完成。

5.打开客户端机器上的系统管理工具，连接到服务器的主备2个IP地址，添加数据节点，配置数据节点主备为服务器的2个IP地址168.2.9.94和168.2.237.54。

点击状态，弹出登陆框

输入admin/admin 点击确定

点击系统管理平台的数据节点配置图标

点击数据节点配置的添加按钮，添加一个数据节点，设置数据节点的主机地址和备机地址，点击确定数据节点test添加成功。

点击确定，冗余数据节点添加成功。查看数据节点的hdKernel状态正常（注意第一次启动时需要创建文件，根据配置的文件大小从几十秒到几分钟不等）。

6.单机双网冗余部署完成，其它客户端只要连接服务器时同时连接服务器的2个地址即可实现双网冗余的功能。


如何在采集器配置工具里删除采集器

如何在采集器配置里面删除采集器

Navigation: »No topics above this level«

如何在采集器配置里面删除采集器

 Return to chapter overview

1.在采集器配置工具里面删除采集器的时候，需要先确认采集器的状态，确保状态为停止，选为本地采集器的钩也要去除。

2.返回采集器配置界面，点击采集器列表里面的删除图标，提示窗口选择确认。

3.回到本地采集器配置界面，点击左上角刷新按钮，采集器列表该采集器会被自动删除。


典型案例10-普通点原始值数据转储到PostgreSQL

Navigation: »No topics above this level«

典型案例10-普通点原始值数据转储到PostgreSQL

 Return to chapter overview

准备工作：服务端运行正常，客户端报警查询工具可以查询到报警记录。

配置步骤如下：

1.配置转储环境:

对于PostgreSQL数据库，不需要进行额外的转储环境配置。

2.添加数据库：

i.在系统管理平台中打开任务面板中数据转储，双击关系数据库，打开转储配置界面。

ii.点击添加数据库按钮弹出添加数据库窗口：

其中，数据库类型：目前关系数据库支持MySQL，SQLServer，Oracle，DB2和PostgreSQL五种类型；

对于PostgreSQL，有如下几项填写信息：

ü 连接名称：用户自定义连接名称，不得与已有的连接重名；

ü 数据库名：填写要转到的数据库实例的名称，此处PostgreSQL数据库名称为test；

ü 数据库地址：数据库服务器IP地址；

ü 数据库端口：数据库服务器端口（如果使用默认端口，填写-1，否则填写PostgreSQL数据库配置的实际端口号）；

ü 用户名和密码：分别是PostgreSQL数据库自定义的用户名和密码；

iii.点击测试连接，可以测试能否连接该关系数据库。

iv.添加关系数据库连接界面点击确定，添加数据库完成。


新建备份库

Navigation: »No topics above this level«

新建备份库

 Return to chapter overview

“开始菜单→iHyperDB→客户端应用快捷链接”菜单下的 数据库备份工具，初始界面如下图所示:

·工具栏：从左到右依次是“添加备份库”、“删除备份库”、“启动服务”

·左侧备份库树状展示区：

“备份服务器”，双击显示如图右侧欢迎图片

a.根节点下第一层为备份库名节点，格式为“备份库名 – 备份库模式”，备份库模式分为“自动”和“手动”两种

b.每个备份库节点下有三个子节点，依次是“备份”、“备份配置”、“恢复”,单击其中任何一个树节点，右侧区域显示相应的界面。

1.同一时间仅可运行一个备份或恢复任务;

2.删除备份时,会停止正在运行的备份任务;

3.若某一备份库备份或任务正在执行,则备份配置修改内容,需执行结束后才生效.

4.备份恢复暂时不支持报警点。

单击工具栏的“新建备份库”按钮，或者右键单击备份服务器根节点，右键菜单中选择“新建备份库”，弹出新建对话框：

新建备份库操作步骤如下：

1.选择备份库类型；

2.输入备份库名称，名称自定义；

注意备份库名称中不能包括“-”这个字符！

3.选择备份库路径：可手工输入或者单击浏览按钮选择一个本地路径。如果这个路径不存在则创建之。如果这个路径下已经有其他的备份库在使用则报错。如果这个路径下已有备份数据也会报错；

4.单击确定按钮新建，单击取消按钮取消新建；

5.新建后树节点新增这个备份库的一个节点和三个子节点，新建后有默认参数配置，同时默认选择到参数配置这个页面上。如下图：

6.配置生效时间默认为当前时间，备份数据结束时间也默认为当前时间，起始时间比结束时间早一个小时。

注意建立新的多个备份库的IP地址必须一致

©2015. All Rights Reserved.


New Topic

Navigation: »No topics above this level«

New Topic

 Return to chapter overview

New Topic

Glossary Item Box

©2015. All Rights Reserved.


nt_connect

Navigation: »No topics above this level«

nt_connect

 Return to chapter overview

nt_connect

Glossary Item Box

函数

与服务器建立连接

int32 nt_connect(

const char* szIP,

uint16 nPort,

HDHANDLE* pSrvHandle,

int32 nTimeout

);

参数

szIP

[in] 服务器ip。

nPort

[in] 服务器端口。

pSrvHandle

[out] 服务器句柄。

nTimeout

[in] 连接超时，单位为秒。

返回值

连接成功，返回RD_SUCCESS，获得服务器句柄。失败返回其它错误码，见error_code.h

说明

连接成功后得到服务器句柄，调用nt_disconnect来断开与服务器的连接；nt_connect和nt_disconnect采用引用计算，需要确保成对使用。

举例

nt_connect

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

int32 nConnectStatus = 0;

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("connect to server successful!\n");

nRet = nt_test_connection(hServer, &nConnectStatus, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("test connection failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

if (NETWORK_STATUS_CONNECT == nConnectStatus)

{

 printf("connect status is good!\n");

}

else

{

 printf("connect status is bad!\n");

}

nRet = nt_disconnect(hServer);

if (nRet != RD_SUCCESS)

{

 printf("disconnect to server failed, error code [%d]!\n", nRet);

 return -1;

}

printf("disconnect to server successful!\n");

return 0;

}

参见：

nt_connect

nt_disconnect

nt_test_connection


nt_disconnect

Navigation: »No topics above this level«

nt_disconnect

 Return to chapter overview

nt_disconnect

Glossary Item Box

函数

与服务器断开连接

int32 nt_disconnect(

HDHANDLE hServer

);

参数

hServer

[in] 服务器句柄。

返回值

成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

连接成功后得到服务器句柄，调用nt_disconnect来断开与服务器的；nt_connect和nt_disconnect采用引用计算，需要确保成对使用。

举例

nt_disconnect

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

int32 nConnectStatus = 0;

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("connect to server successful!\n");

nRet = nt_test_connection(hServer, &nConnectStatus, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("test connection failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

if (NETWORK_STATUS_CONNECT == nConnectStatus)

{

 printf("connect status is good!\n");

}

else

{

 printf("connect status is bad!\n");

}

nRet = nt_disconnect(hServer);

if (nRet != RD_SUCCESS)

{

 printf("disconnect to server failed, error code [%d]!\n", nRet);

 return -1;

}

printf("disconnect to server successful!\n");

return 0;

}

参见：

nt_connect

nt_disconnect

nt_test_connection


连接管理接口

Navigation: »No topics above this level«

连接管理接口

 Return to chapter overview

连接管理接口

Glossary Item Box

《连接管理接口》主要内容包括:

?nt_connect

?nt_disconnect

?nt_test_connection

©2015. All Rights Reserved.


nt_test_connection

Navigation: »No topics above this level«

nt_test_connection

Return to chapter overview

nt_test_connection

Glossary Item Box

函数

测试与服务器的连接

int32 nt_test_connection(

HDHANDLE hServer,

int32* pConnStatus,

int32 nTimeout

);

参数

hServer

[in] 服务器句柄。

pConnStatus

[out] 连接状态。

nTimeout

[in] 连接超时，单位为秒。

返回值

测试连接成功，返回RD_SUCCESS，通过传出的参数pConnStatus可以获得服务器的连接状态。失败返回其它错误码，见error_code.h

说明

参数pConnStatus表示的连接状态如下

连接状态 | 含义
NETWORK_STATUS_CONNECT | 网络连接正常
NETWORK_STATUS_NOT_CONNECT | 网络连接断开

举例

nt_test_connection

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

int32 nConnectStatus = 0;

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("connect to server successful!\n");

nRet = nt_test_connection(hServer, &nConnectStatus, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("test connection failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

if (NETWORK_STATUS_CONNECT == nConnectStatus)

{

 printf("connect status is good!\n");

}

else

{

 printf("connect status is bad!\n");

}

nRet = nt_disconnect(hServer);

if (nRet != RD_SUCCESS)

{

 printf("disconnect to server failed, error code [%d]!\n", nRet);

 return -1;

}

printf("disconnect to server successful!\n");

return 0;

}

参见：

nt_connect

nt_disconnect

nt_test_connection


OPCserver中数据的发布

Navigation: »No topics above this level«

OPCserver中数据的发布

 Return to chapter overview

当系统中安装了IHD_OPCServer之后，iHD系统中的配置的点是可以选择配置为“是否发布OPC”的，配置方式有两种。

一 、系统管理工具中配置

当系统中配置好Tag点的基本属性和采集属性后，在系统中，勾选“OPC发布”，就可以配置为发布opc了，如图：

matrikon中的效果如图：

二、在Excel中配置

在excel中下载系统的Tag点，在这个步骤中，请选择“全部属性”，这样，OPC发布的这个属性会出现在excel列表中，如图：

在要编辑的tag点中，“opc发布状态”的属性中，设置为1，然后执行Tag上传的修改。


其它参考

Navigation: »No topics above this level«

其它参考

 Return to chapter overview

其它参考

Glossary Item Box

其它参考文档

产品白皮书

产品介绍

©2015. All Rights Reserved.


配置的备份

Navigation: »No topics above this level«

配置的备份

 Return to chapter overview

iHyperDB的配置备份目前需要手工拷贝配置中心config目录。

tag点配置主要在config文件夹的ConfigCenter.db文件内，执行备份后备份目录下面生成最新的ConfigCenter_xxx.db。


pt_add_digitalset

Navigation: »No topics above this level«

pt_add_digitalset

 Return to chapter overview

pt_add_digitalset

Glossary Item Box

函数

新增一个数字状态集。

int32 pt_add_digitalset(

HDHANDLE hServer,

const char* szDSName

);

参数

hServer

[in] 服务器句柄

szDSName

[in] 数字量状态集名称。

返回值

添加成功，返回RD_SUCCESS，添加失败返回错误码，见error_code.h

说明

建立一个新的数字量状态集时，首先要为它添加一个独一无二的状态集名，以后对该数字量状态集的访问就需要通过状态集名来访问。该接口在服务器中建立一个空的状态集，调用pt_modify_digitalset可以给该状态集填充状态。

举例

pt_add_digitalset

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

const char* szDsName = "color";

int32 nStateNum = 7;

char (*szDsStateNames)[HD_LEN_DIGITAL_SET_NAME] = NULL;

HDHANDLE hIter = NULL;

char szDsStateNameQueried[HD_LEN_DIGITAL_SET_STATE_NAME];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add digitalset

nRet = pt_add_digitalset(hServer, szDsName);

if (nRet != RD_SUCCESS)

{

 printf("add digitalset failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add digitalset[name:%s] successful!\n", szDsName);

//modify digitalset state name

szDsStateNames = new char[nStateNum][HD_LEN_DIGITAL_SET_NAME];

strcpy(szDsStateNames[0], "red");

strcpy(szDsStateNames[1], "orange");

strcpy(szDsStateNames[2], "yellow");

strcpy(szDsStateNames[3], "green");

strcpy(szDsStateNames[4], "blue");

strcpy(szDsStateNames[5], "indigo");

strcpy(szDsStateNames[6], "violet");

nRet = pt_modify_digitalset(hServer, szDsName, szDsStateNames, nStateNum);

if (nRet != RD_SUCCESS)

{

 printf("modify digitalset failed, error code[%d]!\n", nRet);

 delete[] szDsStateNames;

 nt_disconnect(hServer);

return -1;

}

delete[] szDsStateNames;

printf("modify digitalset successful!\n");

//get digital set state name by state id

int32 nStateID = 6;

nRet = pt_query_digitalset_state_name(hServer, szDsName, nStateID, szDsStateNameQueried);

if (nRet != RD_SUCCESS)

{

 printf("get digitalset state name by state id [%d] failed, error code[%d]!\n", nStateID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("get digitalset state name [%s] by state id [%d] successful!\n", szDsStateNameQueried, nStateID);

//query digitalset state names

nRet = pt_query_digitalset_state_names(hServer, szDsName, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query digitalset state names failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, szDsStateNameQueried);

if (RD_SUCCESS == nRet)

 {

  printf("query digitalset state name [%s] successful !\n", szDsStateNameQueried);

 }

else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query digitalset state names complete!\n");

  break;

 }

else

 {

  printf("query digitalset state name failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query digitalset names

char szDsNameQueried[HD_LEN_DIGITAL_SET_NAME];

nRet = pt_query_digitalset_names(hServer, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query digitalset names failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, szDsNameQueried);

if (RD_SUCCESS == nRet)

 {

  printf("query digitalset name [%s] successful !\n", szDsNameQueried);

 }

else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query digitalset names complete!\n");

  break;

 }

else

 {

  printf("query digitalset name failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//delete digitalset

nRet = pt_delete_digitalset(hServer, szDsName);

if (nRet != RD_SUCCESS)

{

 printf("delete digitalset[name: %s] failed, error code[%d]!\n", szDsName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("delete digitalset[name: %s] sccessful!\n", szDsName);

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

pt_add_digitalset

pt_delete_digitalset

pt_modify_digitalset

pt_query_digitalset_names

pt_query_digital_state_names

pt_get_digitalset_state_name


pt_add_tag

Navigation: »No topics above this level«

pt_add_tag

 Return to chapter overview

pt_add_tag

Glossary Item Box

函数

向服务器添加一个普通点

int32 pt_add_tag(

HDHANDLE hServer,

const TagProp* pTagProp,

int64 nPropMask

);

参数

hServer

[in] 服务器句柄。

pTagProp

[in] 指向普通点属性结构体的指针。

nPropMask

[in] 属性掩码。掩码必须包含TagName和TagType。

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

错误码 | 含义
EC_HD_API_INVALID_SERVERID | 服务器句柄为空
EC_HD_API_INVALID_POINTER | pTagProp指针为空
EC_HD_API_INVALID_TAG_ARCHIVEING | pTagProp->bArchiving不为true和false
EC_HD_API_INVALID_TAG_SCAN | pTagProp->bScan不为true和false
EC_HD_API_INVALID_TAG_COMP_DEV | pTagProp->fCompDev小于0
EC_HD_API_INVALID_TAG_COMP_DEV_PERCENT | pTagProp->fCompDevPercent小于0或大于100
EC_HD_API_INVALID_TAG_EXC_MAX | pTagProp->fExcMax小于0
EC_HD_API_INVALID_TAG_EXC_MIN | pTagProp->fExcMin小于0
EC_HD_API_INVALID_TAG_EXC_MAX_MIN | pTagProp->fExcMax 小于 pTagProp->fExcMin
EC_HD_API_INVALID_TAG_SPAN | pTagProp->fSpan小于0
EC_HD_API_INVALID_TAG_COMP_MAX | pTagProp->nCompMax 小于 0
EC_HD_API_INVALID_TAG_COMP_MIN | pTagProp->nCompMin小于0
EC_HD_API_INVALID_TAG_COMP_MAX_MIN | pTagProp->nCompMax 小于pTagProp->nCompMin
EC_HD_API_INVALID_TAG_COMP_TYPE | pTagProp->nCompType大于COMP_TYPE_MAX或Tag类型为string, blob,digital时pTagProp->nCompType为压缩
EC_HD_API_INVALID_TAG_SCAN_PERIOD | pTagProp->nScanPeriod 小于或等于 0
EC_HD_API_INVALID_TAG_TYPE | pTagProp->nTagType 大于 TAG_TYPE_MAX
EC_HD_API_INVALID_TAG_CHANGER | pTagProp->szChanger大于HD_LEN_USER_NAME
EC_HD_API_INVALID_TAG_CREATOR | pTagProp->szCreator大于HD_LEN_USER_NAME
EC_HD_API_INVALID_TAG_DESC | pTagProp->szDescriptor大于HD_LEN_TAG_DESC
EC_HD_API_INVALID_TAG_ENG_UINTS | pTagProp->szEngUnits大于HD_LEN_ENG_UNITS
EC_HD_API_INVALID_TAG_INSTURMENT_POINT | pTagProp->szInstrumentPoint大于HD_LEN_INSTURMENT_POINT
EC_HD_API_INVALID_TAG_INTERFACE_NAME | pTagProp->szInterfaceName大于HD_LEN_INTERFACE_NAME
EC_HD_API_INVALID_TAG_REC_GROUP | pTagProp->szRecGroup大于HD_LEN_USER_NAME
EC_HD_API_INVALID_TAG_REC_OWNER | pTagProp->szRecOwner大于HD_LEN_USER_NAME
EC_HD_API_INVALID_TAG_TAG_GROUP | pTagProp->szTagGroup大于HD_LEN_USER_NAME
EC_HD_API_INVALID_TAG_NAME | pTagProp->szTagName为空或大于HD_LEN_TAG_NAME
EC_HD_API_INVALID_TAG_OWNER | pTagProp->szTagOwner大于HD_LEN_USER_NAME
EC_HD_API_INVALID_MASK_TAG_NAME | nPropMask没有包含TagName
EC_HD_API_INVALID_MASK_TAG_TYPE | nPropMask没有包含TagType
EC_HD_API_INVALID_TIMEOUT | nTimeout小于或等于0
其它 | 见error_code.h

说明

属性掩码可以由单独的 35个属性项掩码组合而成，如TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE表示属性掩码只包含Tag名和Tag类型这两个属性项。TAG_PROP_ALL表示包含所有的属性项。

添加普通点时，点的名称和点的类型必须添加。

属性掩码 | 代表的属性项
TAG_PROP_ALL | 所有属性项
TAG_PROP_TAG_NAME | Tag名
TAG_PROP_ARCHIVING | 归档状态
TAG_PROP_COMP_DEV | 压缩误差
TAG_PROP_COMP_DEV_PERCENT | 压缩误差百分比
TAG_PROP_COMP_MAX | 压缩超时
TAG_PROP_COMP_MIN | 压缩时间精度
TAG_PROP_COMP_TYPE | 压缩类型
TAG_PROP_CHANGE_DATE | Tag修改时间
TAG_PROP_CHANGER | Tag修改者
TAG_PROP_CREATION_DATE | Tag创建日期
TAG_PROP_CREATOR | Tag创建者
TAG_PROP_DESCRIPTOR | Tag描述
TAG_PROP_DIGITAL_SET | 数字量状态集
TAG_PROP_ENG_UNITS | 工程单位
TAG_PROP_EXC_MAX | 报警上限
TAG_PROP_EXC_MIN | 报警下限
TAG_PROP_INSTUMENT_POINT | 设备点名
TAG_PROP_INTERFACE_NAME | 采集接口名
TAG_PROP_REC_ACCESS | 记录访问权限
TAG_PROP_REC_GROUP | 记录权限组
TAG_PROP_REC_OWNER | 记录所有者
TAG_PROP_SCAN | 扫描状态
TAG_PROP_SCAN_PERIOD | 扫描周期
TAG_PROP_SCAN_PHASE | 扫描相位
TAG_PROP_SPAN | 记录取值范围
TAG_PROP_TAG_ACCESS | Tag访问权限
TAG_PROP_TAG_GROUP | Tag权限组
TAG_PROP_TAGID | TagID
TAG_PROP_TAG_OWNER | Tag所有者
TAG_PROP_TAG_TYPE | Tag类型
TAG_PROP_PARAM1 | 保留参数1
TAG_PROP_PARAM2 | 保留参数2
TAG_PROP_PARAM3 | 保留参数3
TAG_PROP_PARAM4 | 保留参数4
TAG_PROP_PARAM5 | 保留参数5

举例

pt_add_tag

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

void tag_change_call_back(HDHANDLE hServer, uint32 nChangeTime, uint8 nTagChangeType, TagProp* pTag)

{

printf("\n receive a tag change message, tag id is %d, tag change type is %d!\n", pTag->nTagID, nTagChangeType);

}

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tagSave;

TagProp tagQuery;

const char* szTagName_1 = "szTagName_1";

const char* szTagName_2 = "szTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

//register tag change call back

pt_register_tag_change_info(tag_change_call_back);

printf("register tag change callback successful!\n");

//add two tag

strcpy(tagSave.szTagName, szTagName_1);

tagSave.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

strcpy(tagSave.szTagName, szTagName_2);

tagSave.nTagType = TAG_TYPE_STRING;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_STRING);

nRet = pt_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query tags by condition failed!\n", tagSave.szTagName);

 nt_disconnect(hServer);

return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &tagQuery);

if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query tag successful, tag name is %s, tag type is %d!\n", tagQuery.szTagName, tagQuery.nTagType);

 }

else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tag complete!");

  break;

 }

else

 {

  printf("query tag failed, error code [%d]!", nRet);

  break;

 }

}

printf("you queried %d tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = pt_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagID);

//query tag type

uint8 nTagType = 0;

nRet = pt_query_tag_type(hServer, nTagID, &nTagType);

if (nRet != RD_SUCCESS)

{

 printf("query tag type failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("query tag type successful, tag id[%d]!\n",  nTagID);

//modify tag desc

strcpy(tagSave.szDescriptor, "tag descriptor is modified");

nRet = pt_modify_tag_prop(hServer, nTagID, &tagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("modify tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = pt_query_tag_prop(hServer, nTagID, &tagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("query tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 tagQuery.nTagID, tagQuery.szTagName, tagQuery.szDescriptor);

//delete tag

nRet = pt_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("delete tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参见：

pt_add_tag

pt_delete_tag

pt_modify_tag_prop

pt_query_tagid

pt_query_tag_type

pt_query_tag_prop

pt_query_tags_cond

pt_register_tag_change_info


pt_add_tags

Navigation: »No topics above this level«

pt_add_tags

 Return to chapter overview

pt_add_tags

Glossary Item Box

函数

向服务器批量添加点

int32 pt_add_tags(HDHANDLE hServer, TagProp tagProps[], int64 nPropMasks[], int32 nTagNum, int32 nTagIDs[], int32 nErrCode[]);

参数

hServer

[in] 服务器句柄。

tagProps

[in] 指向普通点属性结构体数组的指针。

nPropMasks

[in] 属性掩码数组。掩码必须包含TagName和TagType

nTagNum

[in] tag点数。掩码必须包含TagName和TagType

nTagIDs

[out] tag ID数组

nErrCode

[out] 错误码数组

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

错误码 | 含义
EC_HD_API_INVALID_SERVERID | 服务器句柄为空
EC_HD_API_INVALID_POINTER | pTagProp指针为空
EC_HD_API_INVALID_TAG_ARCHIVEING | pTagProp->bArchiving不为true和false
EC_HD_API_INVALID_TAG_SCAN | pTagProp->bScan不为true和false
EC_HD_API_INVALID_TAG_COMP_DEV | pTagProp->fCompDev小于0
EC_HD_API_INVALID_TAG_COMP_DEV_PERCENT | pTagProp->fCompDevPercent小于0或大于100
EC_HD_API_INVALID_TAG_EXC_MAX | pTagProp->fExcMax小于0
EC_HD_API_INVALID_TAG_EXC_MIN | pTagProp->fExcMin小于0
EC_HD_API_INVALID_TAG_EXC_MAX_MIN | pTagProp->fExcMax 小于 pTagProp->fExcMin
EC_HD_API_INVALID_TAG_SPAN | pTagProp->fSpan小于0
EC_HD_API_INVALID_TAG_COMP_MAX | pTagProp->nCompMax 小于 0
EC_HD_API_INVALID_TAG_COMP_MIN | pTagProp->nCompMin小于0
EC_HD_API_INVALID_TAG_COMP_MAX_MIN | pTagProp->nCompMax 小于pTagProp->nCompMin
EC_HD_API_INVALID_TAG_COMP_TYPE | pTagProp->nCompType大于COMP_TYPE_MAX或Tag类型为string, blob,digital时pTagProp->nCompType为压缩
EC_HD_API_INVALID_TAG_SCAN_PERIOD | pTagProp->nScanPeriod 小于或等于 0
EC_HD_API_INVALID_TAG_TYPE | pTagProp->nTagType 大于 TAG_TYPE_MAX
EC_HD_API_INVALID_TAG_CHANGER | pTagProp->szChanger大于HD_LEN_USER_NAME
EC_HD_API_INVALID_TAG_CREATOR | pTagProp->szCreator大于HD_LEN_USER_NAME
EC_HD_API_INVALID_TAG_DESC | pTagProp->szDescriptor大于HD_LEN_TAG_DESC
EC_HD_API_INVALID_TAG_ENG_UINTS | pTagProp->szEngUnits大于HD_LEN_ENG_UNITS
EC_HD_API_INVALID_TAG_INSTURMENT_POINT | pTagProp->szInstrumentPoint大于HD_LEN_INSTURMENT_POINT
EC_HD_API_INVALID_TAG_INTERFACE_NAME | pTagProp->szInterfaceName大于HD_LEN_INTERFACE_NAME
EC_HD_API_INVALID_TAG_REC_GROUP | pTagProp->szRecGroup大于HD_LEN_USER_NAME
EC_HD_API_INVALID_TAG_REC_OWNER | pTagProp->szRecOwner大于HD_LEN_USER_NAME
EC_HD_API_INVALID_TAG_TAG_GROUP | pTagProp->szTagGroup大于HD_LEN_USER_NAME
EC_HD_API_INVALID_TAG_NAME | pTagProp->szTagName为空或大于HD_LEN_TAG_NAME
EC_HD_API_INVALID_TAG_OWNER | pTagProp->szTagOwner大于HD_LEN_USER_NAME
EC_HD_API_INVALID_MASK_TAG_NAME | nPropMask没有包含TagName
EC_HD_API_INVALID_MASK_TAG_TYPE | nPropMask没有包含TagType
EC_HD_API_INVALID_TIMEOUT | nTimeout小于或等于0
其它 | 见error_code.h

说明

属性掩码可以由单独的 35个属性项掩码组合而成，如TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE表示属性掩码只包含Tag名和Tag类型这两个属性项。TAG_PROP_ALL表示包含所有的属性项。

添加普通点时，点的名称和点的类型必须添加。

属性掩码 | 代表的属性项
TAG_PROP_ALL | 所有属性项
TAG_PROP_TAG_NAME | Tag名
TAG_PROP_ARCHIVING | 归档状态
TAG_PROP_COMP_DEV | 压缩误差
TAG_PROP_COMP_DEV_PERCENT | 压缩误差百分比
TAG_PROP_COMP_MAX | 压缩超时
TAG_PROP_COMP_MIN | 压缩时间精度
TAG_PROP_COMP_TYPE | 压缩类型
TAG_PROP_CHANGE_DATE | Tag修改时间
TAG_PROP_CHANGER | Tag修改者
TAG_PROP_CREATION_DATE | Tag创建日期
TAG_PROP_CREATOR | Tag创建者
TAG_PROP_DESCRIPTOR | Tag描述
TAG_PROP_DIGITAL_SET | 数字量状态集
TAG_PROP_ENG_UNITS | 工程单位
TAG_PROP_EXC_MAX | 报警上限
TAG_PROP_EXC_MIN | 报警下限
TAG_PROP_INSTUMENT_POINT | 设备点名
TAG_PROP_INTERFACE_NAME | 采集接口名
TAG_PROP_REC_ACCESS | 记录访问权限
TAG_PROP_REC_GROUP | 记录权限组
TAG_PROP_REC_OWNER | 记录所有者
TAG_PROP_SCAN | 扫描状态
TAG_PROP_SCAN_PERIOD | 扫描周期
TAG_PROP_SCAN_PHASE | 扫描相位
TAG_PROP_SPAN | 记录取值范围
TAG_PROP_TAG_ACCESS | Tag访问权限
TAG_PROP_TAG_GROUP | Tag权限组
TAG_PROP_TAGID | TagID
TAG_PROP_TAG_OWNER | Tag所有者
TAG_PROP_TAG_TYPE | Tag类型
TAG_PROP_PARAM1 | 保留参数1
TAG_PROP_PARAM2 | 保留参数2
TAG_PROP_PARAM3 | 保留参数3
TAG_PROP_PARAM4 | 保留参数4
TAG_PROP_PARAM5 | 保留参数5

举例

pt_add_tags

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tagSave;

TagProp tagQuery;

const char* szTagName_1 = "szTagName_1";

const char* szTagName_2 = "szTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

TagProp tagProps[10];

int64 nPropMasks[10];

int32 nTotalTagNum = 10;

int32 nTagIDs[10];

int32 nErrCode[10];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

//add two tag

strcpy(tagSave.szTagName, szTagName_1);

tagSave.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

strcpy(tagSave.szTagName, szTagName_2);

tagSave.nTagType = TAG_TYPE_STRING;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

// add ten tags

memset(tagProps, 0, sizeof(TagProp) * 10);

memset(nPropMasks, 0, sizeof(int64) * 10);

memset(nTagIDs, 0, sizeof(int32)*10);

memset(nErrCode, 0, sizeof(int32)*10);

// set tagprop

for(int i = 0; i < nTotalTagNum; ++i)

{

 tagProps[i].nTagType = TAG_TYPE_INT32;

 sprintf(tagProps[i].szTagName, "tagfix%d", i);

 nPropMasks[i] = TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE;

}

nRet = pt_add_tags(hServer,tagProps, nPropMasks, nTotalTagNum, nTagIDs, nErrCode);

if(RD_SUCCESS != nRet)

{

 printf("Failed to add tags!nRet = %d\n", nRet);

}

else

{

 printf("call pt_add_tags successfully\n") ;

for(int i = 0; i < nTotalTagNum; ++i)

 {

  printf("nTagIDs(%d), nErrCode(%d)\n", nTagIDs[i], nErrCode[i]);

 }

}

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_STRING);

nRet = pt_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query tags by condition failed!\n", tagSave.szTagName);

 nt_disconnect(hServer);

return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &tagQuery);

if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query tag successful, tag name is %s, tag type is %d!\n", tagQuery.szTagName, tagQuery.nTagType);

 }

else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tag complete!");

  break;

 }

else

 {

  printf("query tag failed, error code [%d]!", nRet);

  break;

 }

}

printf("you have queried %d tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = pt_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagID);

//query tag type

uint8 nTagType = 0;

nRet = pt_query_tag_type(hServer, nTagID, &nTagType);

if (nRet != RD_SUCCESS)

{

 printf("query tag type failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("query tag type successful, tag id[%d]!\n",  nTagID);

//modify tag desc

strcpy(tagSave.szDescriptor, "tag descriptor is modified");

nRet = pt_modify_tag_prop(hServer, nTagID, &tagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("modify tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = pt_query_tag_prop(hServer, nTagID, &tagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("query tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 tagQuery.nTagID, tagQuery.szTagName, tagQuery.szDescriptor);

//delete tag

nRet = pt_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("delete tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参见：

pt_add_tag

pt_delete_tag

pt_modify_tag_prop

pt_query_tagid

pt_query_tag_type

pt_query_tag_prop

pt_query_tags_cond

pt_register_tag_change_info


pt_delete_digitalset

Navigation: »No topics above this level«

pt_delete_digitalset

 Return to chapter overview

pt_delete_digitalset

Glossary Item Box

函数

删除一个数字状态集

int32 pt_delete_digitalset(

HDHANDLE hServer,

const char* szDSName

);

参数

hServer

[in] 服务器句柄。

szDSName

[in] 数字量状态集名称。

返回值

删除成功，返回RD_SUCCESS，删除失败返回错误码，见error_code.h

说明

删除一个数字量状态集。

举例

pt_add_digitalset

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

const char* szDsName = "color";

int32 nStateNum = 7;

char (*szDsStateNames)[HD_LEN_DIGITAL_SET_NAME] = NULL;

HDHANDLE hIter = NULL;

char szDsStateNameQueried[HD_LEN_DIGITAL_SET_STATE_NAME];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add digitalset

nRet = pt_add_digitalset(hServer, szDsName);

if (nRet != RD_SUCCESS)

{

printf("add digitalset failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("add digitalset[name:%s] successful!\n", szDsName);

//modify digitalset state name

szDsStateNames = new char[nStateNum][HD_LEN_DIGITAL_SET_NAME];

strcpy(szDsStateNames[0], "red");

strcpy(szDsStateNames[1], "orange");

strcpy(szDsStateNames[2], "yellow");

strcpy(szDsStateNames[3], "green");

strcpy(szDsStateNames[4], "blue");

strcpy(szDsStateNames[5], "indigo");

strcpy(szDsStateNames[6], "violet");

nRet = pt_modify_digitalset(hServer, szDsName, szDsStateNames, nStateNum);

if (nRet != RD_SUCCESS)

{

printf("modify digitalset failed, error code[%d]!\n", nRet);

delete[] szDsStateNames;

nt_disconnect(hServer);

return -1;

}

delete[] szDsStateNames;

printf("modify digitalset successful!\n");

//get digital set state name by state id

int32 nStateID = 6;

nRet = pt_query_digitalset_state_name(hServer, szDsName, nStateID, szDsStateNameQueried);

if (nRet != RD_SUCCESS)

{

printf("get digitalset state name by state id [%d] failed, error code[%d]!\n", nStateID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("get digitalset state name [%s] by state id [%d] successful!\n", szDsStateNameQueried, nStateID);

//query digitalset state names

nRet = pt_query_digitalset_state_names(hServer, szDsName, &hIter);

if (nRet != RD_SUCCESS)

{

printf("query digitalset state names failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, szDsStateNameQueried);

if (RD_SUCCESS == nRet)

{

printf("query digitalset state name [%s] successful !\n", szDsStateNameQueried);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query digitalset state names complete!\n");

break;

}

else

{

printf("query digitalset state name failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//query digitalset names

char szDsNameQueried[HD_LEN_DIGITAL_SET_NAME];

nRet = pt_query_digitalset_names(hServer, &hIter);

if (nRet != RD_SUCCESS)

{

printf("query digitalset names failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, szDsNameQueried);

if (RD_SUCCESS == nRet)

{

printf("query digitalset name [%s] successful !\n", szDsNameQueried);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query digitalset names complete!\n");

break;

}

else

{

printf("query digitalset name failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//delete digitalset

nRet = pt_delete_digitalset(hServer, szDsName);

if (nRet != RD_SUCCESS)

{

printf("delete digitalset[name: %s] failed, error code[%d]!\n", szDsName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("delete digitalset[name: %s] sccessful!\n", szDsName);

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

pt_add_digitalset

pt_delete_digitalset

pt_modify_digitalset

pt_query_digitalset_names

pt_query_digital_state_names

pt_get_digitalset_state_name


pt_delete_tag

Navigation: »No topics above this level«

pt_delete_tag

 Return to chapter overview

pt_delete_tag

Glossary Item Box

函数

删除一个普通点

int32 pt_delete_tag(

HDHANDLE hServer,

uint32 nTagID

);

参数

hServer

[in] 服务器句柄。

nTagID

[in] 数据源ID，大于零。

返回值

删除成功，返回RD_SUCCESS。删除失败返回错误码，见error_code.h

说明

根据普通点的ID删除一个普通点

举例

pt_delete_tag

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

void tag_change_call_back(HDHANDLE hServer, uint32 nChangeTime, uint8 nTagChangeType, TagProp* pTag)

{

printf("\n receive a tag change message, tag id is %d, tag change type is %d!\n", pTag->nTagID, nTagChangeType);

}

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tagSave;

TagProp tagQuery;

const char* szTagName_1 = "szTagName_1";

const char* szTagName_2 = "szTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

//register tag change call back

pt_register_tag_change_info(tag_change_call_back);

printf("register tag change callback successful!\n");

//add two tag

strcpy(tagSave.szTagName, szTagName_1);

tagSave.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

strcpy(tagSave.szTagName, szTagName_2);

tagSave.nTagType = TAG_TYPE_STRING;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_STRING);

nRet = pt_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query tags by condition failed!\n", tagSave.szTagName);

 nt_disconnect(hServer);

return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &tagQuery);

if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query tag successful, tag name is %s, tag type is %d!\n", tagQuery.szTagName, tagQuery.nTagType);

 }

else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tag complete!");

  break;

 }

else

 {

  printf("query tag failed, error code [%d]!", nRet);

  break;

 }

}

printf("you queried %d tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = pt_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagID);

//query tag type

uint8 nTagType = 0;

nRet = pt_query_tag_type(hServer, nTagID, &nTagType);

if (nRet != RD_SUCCESS)

{

 printf("query tag type failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("query tag type successful, tag id[%d]!\n",  nTagID);

//modify tag desc

strcpy(tagSave.szDescriptor, "tag descriptor is modified");

nRet = pt_modify_tag_prop(hServer, nTagID, &tagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("modify tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = pt_query_tag_prop(hServer, nTagID, &tagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("query tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 tagQuery.nTagID, tagQuery.szTagName, tagQuery.szDescriptor);

//delete tag

nRet = pt_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("delete tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参见：

pt_add_tag

pt_delete_tag

pt_modify_tag_prop

pt_query_tagid

pt_query_tag_type

pt_query_tag_prop

pt_query_tags_cond

pt_register_tag_change_info


pt_get_digitalset_state_name

Navigation: »No topics above this level«

pt_get_digitalset_state_name

 Return to chapter overview

pt_get_digitalset_state_name

Glossary Item Box

函数

根据数字量状态集的状态ID查询状态名称

int32 pt_query_digitalset_state_name(

HDHANDLE hServer,

const char* szDSName,

int32 nStateID,

char* szDSStateName

);

参数

hServer

[in] 服务器句柄。

szDSName

[in] 数字量状态集名称。

nStateID

[in] 数字量状态集的状态ID。

szDSStateName

[out] 查询到的状态名。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

说明

Digital类型的Tag的值的采集和存储都是用数字来表示的，如果将这些数字展示给用户，用户可能不知道它表示什么意思，例如名为“color”状态集包含7种状态依次是：red,oranger,yellow,green,blue,indigo,violet;分别用0，1，2，3，4，5，6来表示。调用该接口可以直观的将这些数字的含义呈现出来。输入3，你将会得到一个名为“green”的状态名。

举例

pt_get_digitalset_state_name

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

const char* szDsName = "color";

int32 nStateNum = 7;

char (*szDsStateNames)[HD_LEN_DIGITAL_SET_NAME] = NULL;

HDHANDLE hIter = NULL;

char szDsStateNameQueried[HD_LEN_DIGITAL_SET_STATE_NAME];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add digitalset

nRet = pt_add_digitalset(hServer, szDsName);

if (nRet != RD_SUCCESS)

{

 printf("add digitalset failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add digitalset[name:%s] successful!\n", szDsName);

//modify digitalset state name

szDsStateNames = new char[nStateNum][HD_LEN_DIGITAL_SET_NAME];

strcpy(szDsStateNames[0], "red");

strcpy(szDsStateNames[1], "orange");

strcpy(szDsStateNames[2], "yellow");

strcpy(szDsStateNames[3], "green");

strcpy(szDsStateNames[4], "blue");

strcpy(szDsStateNames[5], "indigo");

strcpy(szDsStateNames[6], "violet");

nRet = pt_modify_digitalset(hServer, szDsName, szDsStateNames, nStateNum);

if (nRet != RD_SUCCESS)

{

 printf("modify digitalset failed, error code[%d]!\n", nRet);

 delete[] szDsStateNames;

 nt_disconnect(hServer);

return -1;

}

delete[] szDsStateNames;

printf("modify digitalset successful!\n");

//get digital set state name by state id

int32 nStateID = 6;

nRet = pt_query_digitalset_state_name(hServer, szDsName, nStateID, szDsStateNameQueried);

if (nRet != RD_SUCCESS)

{

 printf("get digitalset state name by state id [%d] failed, error code[%d]!\n", nStateID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("get digitalset state name [%s] by state id [%d] successful!\n", szDsStateNameQueried, nStateID);

//query digitalset state names

nRet = pt_query_digitalset_state_names(hServer, szDsName, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query digitalset state names failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, szDsStateNameQueried);

if (RD_SUCCESS == nRet)

 {

  printf("query digitalset state name [%s] successful !\n", szDsStateNameQueried);

 }

else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query digitalset state names complete!\n");

  break;

 }

else

 {

  printf("query digitalset state name failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query digitalset names

char szDsNameQueried[HD_LEN_DIGITAL_SET_NAME];

nRet = pt_query_digitalset_names(hServer, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query digitalset state names failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, szDsNameQueried);

if (RD_SUCCESS == nRet)

 {

  printf("query digitalset name [%s] successful !\n", szDsNameQueried);

 }

else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query digitalset names complete!\n");

  break;

 }

else

 {

  printf("query digitalset name failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//delete digitalset

nRet = pt_delete_digitalset(hServer, szDsName);

if (nRet != RD_SUCCESS)

{

 printf("delete digitalset[name: %s] failed, error code[%d]!\n", szDsName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("delete digitalset[name: %s] sccessful!\n", szDsName);

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

pt_add_digitalset

pt_delete_digitalset

pt_modify_digitalset

pt_query_digitalset_names

pt_query_digital_state_names

pt_get_digitalset_state_name


数据源管理接口

Navigation: »No topics above this level«

数据源管理接口

 Return to chapter overview

数据源管理接口

Glossary Item Box

《数据源管理接口》主要内容包括：

?pt_add_tag

?pt_delete_tag

?pt_modify_tag_prop

?pt_query_tagid

?pt_query_tag_prop

?pt_query_tag_type

?pt_query_tags_cond

?pt_register_tag_change_info

©2015. All Rights Reserved.


Digitalset管理接口

Navigation: »No topics above this level«

Digitalset管理接口

 Return to chapter overview

Digitalset管理接口

Glossary Item Box

《Digitalset管理接口》的主要内容包括：

?pt_add_digitalset

?pt_delete_digitalset

?pt_get_digitalset_state_name

?pt_modify_digitalset

?pt_query_digitalset_names

?pt_query_digital_state_names

©2015. All Rights Reserved.


pt_modify_digitalset

Navigation: »No topics above this level«

pt_modify_digitalset

 Return to chapter overview

pt_modify_digitalset

Glossary Item Box

函数

修改指定数字状态集的所有状态名

int32 pt_modify_digitalset(

HDHANDLE hServer,

const char* szDSName,

char szDSStateNames[][HD_LEN_DIGITAL_SET_STATE_NAME],

int32 nStateNum

);

参数

hServer

[in] 服务器句柄。

szDSName

[in] 数字量状态集名称。

szDSStateNames

[in] 数字量状态集状态名

nStateNum

[in] 状态名数目

返回值

修改成功，返回RD_SUCCESS，修改失败返回错误码，见error_code.h

说明

调用该接口会在服务器将原来的状态名全部删除并修改为新的状态名。

举例

pt_add_digitalset

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

const char* szDsName = "color";

int32 nStateNum = 7;

char (*szDsStateNames)[HD_LEN_DIGITAL_SET_NAME] = NULL;

HDHANDLE hIter = NULL;

char szDsStateNameQueried[HD_LEN_DIGITAL_SET_STATE_NAME];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add digitalset

nRet = pt_add_digitalset(hServer, szDsName);

if (nRet != RD_SUCCESS)

{

printf("add digitalset failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("add digitalset[name:%s] successful!\n", szDsName);

//modify digitalset state name

szDsStateNames = new char[nStateNum][HD_LEN_DIGITAL_SET_NAME];

strcpy(szDsStateNames[0], "red");

strcpy(szDsStateNames[1], "orange");

strcpy(szDsStateNames[2], "yellow");

strcpy(szDsStateNames[3], "green");

strcpy(szDsStateNames[4], "blue");

strcpy(szDsStateNames[5], "indigo");

strcpy(szDsStateNames[6], "violet");

nRet = pt_modify_digitalset(hServer, szDsName, szDsStateNames, nStateNum);

if (nRet != RD_SUCCESS)

{

printf("modify digitalset failed, error code[%d]!\n", nRet);

delete[] szDsStateNames;

nt_disconnect(hServer);

return -1;

}

delete[] szDsStateNames;

printf("modify digitalset successful!\n");

//get digital set state name by state id

int32 nStateID = 6;

nRet = pt_query_digitalset_state_name(hServer, szDsName, nStateID, szDsStateNameQueried);

if (nRet != RD_SUCCESS)

{

printf("get digitalset state name by state id [%d] failed, error code[%d]!\n", nStateID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("get digitalset state name [%s] by state id [%d] successful!\n", szDsStateNameQueried, nStateID);

//query digitalset state names

nRet = pt_query_digitalset_state_names(hServer, szDsName, &hIter);

if (nRet != RD_SUCCESS)

{

printf("query digitalset state names failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, szDsStateNameQueried);

if (RD_SUCCESS == nRet)

{

printf("query digitalset state name [%s] successful !\n", szDsStateNameQueried);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query digitalset state names complete!\n");

break;

}

else

{

printf("query digitalset state name failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//query digitalset names

char szDsNameQueried[HD_LEN_DIGITAL_SET_NAME];

nRet = pt_query_digitalset_names(hServer, &hIter);

if (nRet != RD_SUCCESS)

{

printf("query digitalset names failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, szDsNameQueried);

if (RD_SUCCESS == nRet)

{

printf("query digitalset name [%s] successful !\n", szDsNameQueried);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query digitalset names complete!\n");

break;

}

else

{

printf("query digitalset name failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//delete digitalset

nRet = pt_delete_digitalset(hServer, szDsName);

if (nRet != RD_SUCCESS)

{

printf("delete digitalset[name: %s] failed, error code[%d]!\n", szDsName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("delete digitalset[name: %s] sccessful!\n", szDsName);

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

pt_add_digitalset

pt_delete_digitalset

pt_modify_digitalset

pt_query_digitalset_names

pt_query_digital_state_names

pt_get_digitalset_state_name


pt_modify_tag_prop

Navigation: »No topics above this level«

pt_modify_tag_prop

 Return to chapter overview

pt_modify_tag_prop

Glossary Item Box

函数

修改普通点的属性

int32 pt_modify_tag_prop(

HDHANDLE hServer,

uint32 nTagID,

const TagProp* pTagProp,

int64 nPropMask

);

参数

hServer

[in] 服务器句柄。

nTagID

[in] 普通点ID。

pTagProp

[in] 指向普通点属性结构体的指针。

nPropMask

[in] 修改普通点属性的掩码。

返回值

修改成功，返回RD_SUCCESS。修改失败则返回错误码，见error_code.h。

说明

修改一个Tag的属性，修改的属性项由属性掩码决定。属性掩码的说明见pt_add_tag。

举例

pt_modify_tag_prop

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

void tag_change_call_back(HDHANDLE hServer, uint32 nChangeTime, uint8 nTagChangeType, TagProp* pTag)

{

printf("\n receive a tag change message, tag id is %d, tag change type is %d!\n", pTag->nTagID, nTagChangeType);

}

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tagSave;

TagProp tagQuery;

const char* szTagName_1 = "szTagName_1";

const char* szTagName_2 = "szTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

//register tag change call back

pt_register_tag_change_info(tag_change_call_back);

printf("register tag change callback successful!\n");

//add two tag

strcpy(tagSave.szTagName, szTagName_1);

tagSave.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

strcpy(tagSave.szTagName, szTagName_2);

tagSave.nTagType = TAG_TYPE_STRING;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_STRING);

nRet = pt_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query tags by condition failed!\n", tagSave.szTagName);

 nt_disconnect(hServer);

return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &tagQuery);

if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query tag successful, tag name is %s, tag type is %d!\n", tagQuery.szTagName, tagQuery.nTagType);

 }

else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tag complete!");

  break;

 }

else

 {

  printf("query tag failed, error code [%d]!", nRet);

  break;

 }

}

printf("you queried %d tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = pt_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagID);

//query tag type

uint8 nTagType = 0;

nRet = pt_query_tag_type(hServer, nTagID, &nTagType);

if (nRet != RD_SUCCESS)

{

 printf("query tag type failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("query tag type successful, tag id[%d]!\n",  nTagID);

//modify tag desc

strcpy(tagSave.szDescriptor, "tag descriptor is modified");

nRet = pt_modify_tag_prop(hServer, nTagID, &tagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("modify tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = pt_query_tag_prop(hServer, nTagID, &tagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("query tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 tagQuery.nTagID, tagQuery.szTagName, tagQuery.szDescriptor);

//delete tag

nRet = pt_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("delete tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参见：

pt_add_tag

pt_delete_tag

pt_modify_tag_prop

pt_query_tagid

pt_query_tag_type

pt_query_tag_prop

pt_query_tags_cond

pt_register_tag_change_info


pt_query_digitalset_names

Navigation: »No topics above this level«

pt_query_digitalset_names

 Return to chapter overview

pt_query_digitalset_names

Glossary Item Box

函数

查询所有数字状态集的名称。

int32 pt_query_digitalset_names(

HDHANDLE hServer,

HDHANDLE* pHIter

);

参数

hServer

[in] 服务器句柄。

pHIter

[out] 查询迭代器。

返回值

查询成功，返回RD_SUCCESS和查询迭代器。查询失败返回其它错误码，见error_code.h。

说明

调用该接口成功后会获得一个查询迭代器的句柄，然后调用ut_get_item_step接口，传入迭代器句柄和分配的空间(char[HD_LEN_DIGITAL_SET_NAME])，返回RD_SUCCESS就可以获得第一个数字量状态集的名称，再调用ut_get_item_step返回RD_SUCCESS就可以获得第二个数字量状态集的名称。如此循环的查询直到调用ut_get_item_step返回错误码为EC_HD_API_QUERY_END表明所有的数字量状态集都查询完毕了。查询完毕后调用ut_free_iterator方法来释放迭代器。

举例

pt_add_digitalset

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

const char* szDsName = "color";

int32 nStateNum = 7;

char (*szDsStateNames)[HD_LEN_DIGITAL_SET_NAME] = NULL;

HDHANDLE hIter = NULL;

char szDsStateNameQueried[HD_LEN_DIGITAL_SET_STATE_NAME];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add digitalset

nRet = pt_add_digitalset(hServer, szDsName);

if (nRet != RD_SUCCESS)

{

printf("add digitalset failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("add digitalset[name:%s] successful!\n", szDsName);

//modify digitalset state name

szDsStateNames = new char[nStateNum][HD_LEN_DIGITAL_SET_NAME];

strcpy(szDsStateNames[0], "red");

strcpy(szDsStateNames[1], "orange");

strcpy(szDsStateNames[2], "yellow");

strcpy(szDsStateNames[3], "green");

strcpy(szDsStateNames[4], "blue");

strcpy(szDsStateNames[5], "indigo");

strcpy(szDsStateNames[6], "violet");

nRet = pt_modify_digitalset(hServer, szDsName, szDsStateNames, nStateNum);

if (nRet != RD_SUCCESS)

{

printf("modify digitalset failed, error code[%d]!\n", nRet);

delete[] szDsStateNames;

nt_disconnect(hServer);

return -1;

}

delete[] szDsStateNames;

printf("modify digitalset successful!\n");

//get digital set state name by state id

int32 nStateID = 6;

nRet = pt_query_digitalset_state_name(hServer, szDsName, nStateID, szDsStateNameQueried);

if (nRet != RD_SUCCESS)

{

printf("get digitalset state name by state id [%d] failed, error code[%d]!\n", nStateID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("get digitalset state name [%s] by state id [%d] successful!\n", szDsStateNameQueried, nStateID);

//query digitalset state names

nRet = pt_query_digitalset_state_names(hServer, szDsName, &hIter);

if (nRet != RD_SUCCESS)

{

printf("query digitalset state names failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, szDsStateNameQueried);

if (RD_SUCCESS == nRet)

{

printf("query digitalset state name [%s] successful !\n", szDsStateNameQueried);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query digitalset state names complete!\n");

break;

}

else

{

printf("query digitalset state name failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//query digitalset names

char szDsNameQueried[HD_LEN_DIGITAL_SET_NAME];

nRet = pt_query_digitalset_names(hServer, &hIter);

if (nRet != RD_SUCCESS)

{

printf("query digitalset names failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, szDsNameQueried);

if (RD_SUCCESS == nRet)

{

printf("query digitalset name [%s] successful !\n", szDsNameQueried);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query digitalset names complete!\n");

break;

}

else

{

printf("query digitalset name failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//delete digitalset

nRet = pt_delete_digitalset(hServer, szDsName);

if (nRet != RD_SUCCESS)

{

printf("delete digitalset[name: %s] failed, error code[%d]!\n", szDsName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("delete digitalset[name: %s] sccessful!\n", szDsName);

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

pt_add_digitalset

pt_delete_digitalset

pt_modify_digitalset

pt_query_digitalset_names

pt_query_digital_state_names

pt_get_digitalset_state_name


pt_query_digital_state_names

Navigation: »No topics above this level«

pt_query_digital_state_names

 Return to chapter overview

pt_query_digital_state_names

Glossary Item Box

函数

查询指定数字状态集的状态名

int32 pt_query_digitalset_state_names(

HDHANDLE hServer,

const char* szDSName,

HDHANDLE* pHIter

);

参数

hServer

[in] 服务器句柄。

szDSName

[in] 数字量状态集名称。

pHIter

[out] 查询迭代器。

返回值

查询成功，返回RD_SUCCESS和查询迭代器。查询失败返回其它错误码，见error_code.h。

说明

调用成功后会获得一个查询迭代器的句柄，然后调用ut_get_item_step，传入迭代器句柄和分配的空间(char[HD_LEN_DIGITAL_SET_STATE_NAME])，返回RD_SUCCESS就可以获得第一个状态名，再调用ut_get_item_step返回RD_SUCCESS就可以获得第二个状态名。如此循环的查询直到调用ut_get_item_step返回错误码为EC_HD_API_QUERY_END表明所有的状态名都查询完毕了。查询完毕后调用ut_free_iterator方法来释放迭代器。

举例

pt_add_digitalset

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

const char* szDsName = "color";

int32 nStateNum = 7;

char (*szDsStateNames)[HD_LEN_DIGITAL_SET_NAME] = NULL;

HDHANDLE hIter = NULL;

char szDsStateNameQueried[HD_LEN_DIGITAL_SET_STATE_NAME];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add digitalset

nRet = pt_add_digitalset(hServer, szDsName);

if (nRet != RD_SUCCESS)

{

printf("add digitalset failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("add digitalset[name:%s] successful!\n", szDsName);

//modify digitalset state name

szDsStateNames = new char[nStateNum][HD_LEN_DIGITAL_SET_NAME];

strcpy(szDsStateNames[0], "red");

strcpy(szDsStateNames[1], "orange");

strcpy(szDsStateNames[2], "yellow");

strcpy(szDsStateNames[3], "green");

strcpy(szDsStateNames[4], "blue");

strcpy(szDsStateNames[5], "indigo");

strcpy(szDsStateNames[6], "violet");

nRet = pt_modify_digitalset(hServer, szDsName, szDsStateNames, nStateNum);

if (nRet != RD_SUCCESS)

{

printf("modify digitalset failed, error code[%d]!\n", nRet);

delete[] szDsStateNames;

nt_disconnect(hServer);

return -1;

}

delete[] szDsStateNames;

printf("modify digitalset successful!\n");

//get digital set state name by state id

int32 nStateID = 6;

nRet = pt_query_digitalset_state_name(hServer, szDsName, nStateID, szDsStateNameQueried);

if (nRet != RD_SUCCESS)

{

printf("get digitalset state name by state id [%d] failed, error code[%d]!\n", nStateID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("get digitalset state name [%s] by state id [%d] successful!\n", szDsStateNameQueried, nStateID);

//query digitalset state names

nRet = pt_query_digitalset_state_names(hServer, szDsName, &hIter);

if (nRet != RD_SUCCESS)

{

printf("query digitalset state names failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, szDsStateNameQueried);

if (RD_SUCCESS == nRet)

{

printf("query digitalset state name [%s] successful !\n", szDsStateNameQueried);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query digitalset state names complete!\n");

break;

}

else

{

printf("query digitalset state name failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//query digitalset names

char szDsNameQueried[HD_LEN_DIGITAL_SET_NAME];

nRet = pt_query_digitalset_names(hServer, &hIter);

if (nRet != RD_SUCCESS)

{

printf("query digitalset names failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, szDsNameQueried);

if (RD_SUCCESS == nRet)

{

printf("query digitalset name [%s] successful !\n", szDsNameQueried);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query digitalset names complete!\n");

break;

}

else

{

printf("query digitalset name failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//delete digitalset

nRet = pt_delete_digitalset(hServer, szDsName);

if (nRet != RD_SUCCESS)

{

printf("delete digitalset[name: %s] failed, error code[%d]!\n", szDsName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("delete digitalset[name: %s] sccessful!\n", szDsName);

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

pt_add_digitalset

pt_delete_digitalset

pt_modify_digitalset

pt_query_digitalset_names

pt_query_digital_state_names

pt_get_digitalset_state_name


pt_query_tagid

Navigation: »No topics above this level«

pt_query_tagid

 Return to chapter overview

pt_query_tagid

Glossary Item Box

函数

根据普通点名称查询ID

int32 pt_query_tagid(

HDHANDLE hServer,

const char* szTagName,

uint32* pTagID

);

参数

hServer

[in] 服务器句柄。

szTagName

[in] 普通点名称。

pTagID

[out] 普通点ID。

返回值

查询成功，返回RD_SUCCESS。查询失败返回错误码，见error_code.h。

说明

通过普通点的名字查询ID。

举例

pt_query_tagid

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

void tag_change_call_back(HDHANDLE hServer, uint32 nChangeTime, uint8 nTagChangeType, TagProp* pTag)

{

printf("\n receive a tag change message, tag id is %d, tag change type is %d!\n", pTag->nTagID, nTagChangeType);

}

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tagSave;

TagProp tagQuery;

const char* szTagName_1 = "szTagName_1";

const char* szTagName_2 = "szTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

//register tag change call back

pt_register_tag_change_info(tag_change_call_back);

printf("register tag change callback successful!\n");

//add two tag

strcpy(tagSave.szTagName, szTagName_1);

tagSave.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

strcpy(tagSave.szTagName, szTagName_2);

tagSave.nTagType = TAG_TYPE_STRING;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_STRING);

nRet = pt_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query tags by condition failed!\n", tagSave.szTagName);

 nt_disconnect(hServer);

return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &tagQuery);

if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query tag successful, tag name is %s, tag type is %d!\n", tagQuery.szTagName, tagQuery.nTagType);

 }

else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tag complete!");

  break;

 }

else

 {

  printf("query tag failed, error code [%d]!", nRet);

  break;

 }

}

printf("you queried %d tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = pt_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagID);

//query tag type

uint8 nTagType = 0;

nRet = pt_query_tag_type(hServer, nTagID, &nTagType);

if (nRet != RD_SUCCESS)

{

 printf("query tag type failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("query tag type successful, tag id[%d]!\n",  nTagID);

//modify tag desc

strcpy(tagSave.szDescriptor, "tag descriptor is modified");

nRet = pt_modify_tag_prop(hServer, nTagID, &tagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("modify tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = pt_query_tag_prop(hServer, nTagID, &tagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("query tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 tagQuery.nTagID, tagQuery.szTagName, tagQuery.szDescriptor);

//delete tag

nRet = pt_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("delete tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参见:

pt_add_tag

pt_delete_tag

pt_modify_tag_prop

pt_query_tagid

pt_query_tag_type

pt_query_tag_prop

pt_query_tags_cond

pt_register_tag_change_info


pt_query_tag_prop

Navigation: »No topics above this level«

pt_query_tag_prop

 Return to chapter overview

pt_query_tag_prop

Glossary Item Box

函数

查询普通点属性

int32 pt_query_tag_prop(

HDHANDLE hServer,

uint32 nTagID,

TagProp* pTagProp

);

参数

hServer

[in] 服务器句柄。

nTagID

[in] Tag点ID。

pTagProp

[out] 指向TagProp结构体的指针。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

说明

该接口根据普通点ID查询该普通点的所有属性。

举例

pt_query_tag_prop

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

void tag_change_call_back(HDHANDLE hServer, uint32 nChangeTime, uint8 nTagChangeType, TagProp* pTag)

{

printf("\n receive a tag change message, tag id is %d, tag change type is %d!\n", pTag->nTagID, nTagChangeType);

}

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tagSave;

TagProp tagQuery;

const char* szTagName_1 = "szTagName_1";

const char* szTagName_2 = "szTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

//register tag change call back

pt_register_tag_change_info(tag_change_call_back);

printf("register tag change callback successful!\n");

//add two tag

strcpy(tagSave.szTagName, szTagName_1);

tagSave.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

strcpy(tagSave.szTagName, szTagName_2);

tagSave.nTagType = TAG_TYPE_STRING;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_STRING);

nRet = pt_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query tags by condition failed!\n", tagSave.szTagName);

 nt_disconnect(hServer);

return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &tagQuery);

if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query tag successful, tag name is %s, tag type is %d!\n", tagQuery.szTagName, tagQuery.nTagType);

 }

else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tag complete!");

  break;

 }

else

 {

  printf("query tag failed, error code [%d]!", nRet);

  break;

 }

}

printf("you queried %d tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = pt_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagID);

//query tag type

uint8 nTagType = 0;

nRet = pt_query_tag_type(hServer, nTagID, &nTagType);

if (nRet != RD_SUCCESS)

{

 printf("query tag type failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("query tag type successful, tag id[%d]!\n",  nTagID);

//modify tag desc

strcpy(tagSave.szDescriptor, "tag descriptor is modified");

nRet = pt_modify_tag_prop(hServer, nTagID, &tagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("modify tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = pt_query_tag_prop(hServer, nTagID, &tagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("query tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 tagQuery.nTagID, tagQuery.szTagName, tagQuery.szDescriptor);

//delete tag

nRet = pt_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("delete tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参见:

pt_add_tag

pt_delete_tag

pt_modify_tag_prop

pt_query_tagid

pt_query_tag_type

pt_query_tag_prop

pt_query_tags_cond

pt_register_tag_change_info


pt_query_tags_cond

Navigation: »No topics above this level«

pt_query_tags_cond

 Return to chapter overview

pt_query_tags_cond

Glossary Item Box

函数

根据查询条件查询满足条件的普通点

int32 pt_query_tags_cond(

HDHANDLE hServer,

QueryTagPropItem pQueryItem[],

int32 nQueryItemNum,

int64 nPropMask,

HDHANDLE* pHIter

);

参数

hServer

[in] 服务器句柄。

pQueryItems

[in] 查询条件数组。

nQueryItemNum

[in] 查询条件个数。

nPropMask

[in] 返回报警点掩码，表明返回哪些报警点的属性。

pHIter

[out] 查询迭代器。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

说明

? 调用该接口成功后会获得一个查询迭代器的句柄，然后调用ut_get_item_step接口，传入迭代器句柄和分配的空间(TagProp*)，返回RD_SUCCESS就可以获得第一个报警点的属性，再调用ut_get_item_step返回RD_SUCCESS就可以获得第二个报警点的属性。如此循环的查询直到调用ut_get_item_step返回错误码为EC_HD_API_QUERY_END表明所有的报警点的ID都查询完毕了。查询完毕后调用ut_free_iterator方法来释放迭代器。

?查询条件：

QueryTagPropItem

!MISSING PHRASE 'COPYCODE'!

typedef struct _QueryTagPropItem

{

  uint8 nPropItemID;

  uint8 nRelation;

  char szValue[LENGTH_QUERY_ITEM_VALUE];

}QueryTagPropItem;

?nPropItemID:属性项ID，标识该查询条件针对的某一个具体的属性。

nPropItemID | 代表的Tag属性项
TAG_COL_TAG_NAME | szTagName
TAG_COL_ARCHIVING | bArchiving
TAG_COL_COMP_DEV | fCompDev
TAG_COL_COMP_DEV_PERCENT | fCompDevPercent
TAG_COL_COMP_MAX | nCompMax
TAG_COL_COMP_MIN | nCompMin
TAG_COL_COMP_TYPE | nCompType
TAG_COL_CHANGE_DATE | nChangeDate
TAG_COL_CHANGER | szChanger
TAG_COL_CREATION_DATE | nCreationDate
TAG_COL_CREATOR | szCreator
TAG_COL_DESCRIPTOR | szDescriptor
TAG_COL_DIGITAL_SET | nDigitalSet
TAG_COL_ENG_UNITS | szEngUnits
TAG_COL_EXC_MAX | fExcMax
TAG_COL_EXC_MIN | fExcMin
TAG_COL_INSTRUMENT_POINT | szInstrumentPoint
TAG_COL_INTERFACE_NAME | szInterfaceName
TAG_COL_REC_ACCESS | nRecAccess
TAG_COL_REC_GROUP | szRecGroup
TAG_COL_REC_OWNER | szRecOwner
TAG_COL_SCAN | bScan
TAG_COL_SCAN_PERIOD | nScanPeriod
TAG_COL_SCAN_PHASE | nScanPhase
TAG_COL_SPAN | fSpan
TAG_COL_TAG_ACCESS | nTagAccess
TAG_COL_TAG_GROUP | szTagGroup
TAG_COL_TAGID | nTagID
TAG_COL_TAG_OWNER | szTagOwner
TAG_COL_TAG_TYPE | nTagType
TAG_COL_PARAM1 | nParam1
TAG_COL_PARAM2 | nParam2
TAG_COL_PARAM3 | nParam3
TAG_COL_PARAM4 | nParam4
TAG_COL_PARAM5 | nParam5

?nRelation:属性项查询关系。

nRelation | 含义
RELATION_EQUAL | =
RELATION_NON_EQUAL | <>
RELATION_GREAT | >
RELATION_LESS | <
RELATION_GREAT_AND_EQUAL | >=
RELATION_LESS_AND_EQUAL | <=
RELATION_LIKE | 模糊查询，“*”表示多字符模糊查询 ，“？”表示单字符模糊查询

?szValue：属性项的值，用字符串表示。

例如查询条件Tag name 以“上海”开头且 TagID小于1000的条件为：

查询条件

!MISSING PHRASE 'COPYCODE'!

QueryTagPropItem pQueryItem[2];

pQueryItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryItem[0].szValue, "上海*");//Tag name 以”上海“开头

pQueryItem[1].nPropItemID = TAG_COL_TAGID;

pQueryItem[1].nRelation = RELATION_LESS;

strcpy(pQueryItem[1].szValue, "1000");//TagID 小于1000

举例

am_query_tags_cond

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

void tag_change_call_back(HDHANDLE hServer, uint32 nChangeTime, uint8 nTagChangeType, TagProp* pTag)

{

printf("\n receive a tag change message, tag id is %d, tag change type is %d!\n", pTag->nTagID, nTagChangeType);

}

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tagSave;

TagProp tagQuery;

const char* szTagName_1 = "szTagName_1";

const char* szTagName_2 = "szTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//register tag change call back

pt_register_tag_change_info(tag_change_call_back);

printf("register tag change callback successful!\n");

//add two tag

strcpy(tagSave.szTagName, szTagName_1);

tagSave.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

strcpy(tagSave.szTagName, szTagName_2);

tagSave.nTagType = TAG_TYPE_STRING;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_STRING);

nRet = pt_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query tags by condition failed!\n", tagSave.szTagName);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &tagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query tag successful, tag name is %s, tag type is %d!\n", tagQuery.szTagName, tagQuery.nTagType);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tag complete!");

  break;

 }

 else

 {

  printf("query tag failed, error code [%d]!", nRet);

  break;

 }

}

printf("you queried %d tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = pt_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagID);

//query tag type

uint8 nTagType = 0;

nRet = pt_query_tag_type(hServer, nTagID, &nTagType);

if (nRet != RD_SUCCESS)

{

 printf("query tag type failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag type successful, tag id[%d]!\n",  nTagID);

//modify tag desc

strcpy(tagSave.szDescriptor, "tag descriptor is modified");

nRet = pt_modify_tag_prop(hServer, nTagID, &tagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = pt_query_tag_prop(hServer, nTagID, &tagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 tagQuery.nTagID, tagQuery.szTagName, tagQuery.szDescriptor);

//delete tag

nRet = pt_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参见：

pt_add_tag

pt_delete_tag

pt_modify_tag_prop

pt_query_tagid

pt_query_tag_type

pt_query_tag_prop

pt_query_tags_cond

pt_register_tag_change_info


pt_query_tag_type

Navigation: »No topics above this level«

pt_query_tag_type

 Return to chapter overview

pt_query_tag_type

Glossary Item Box

函数

查询普通点的类型

int32 pt_query_tag_type(

HDHANDLE hServer,

uint32 nTagID,

uint8* pTagType

);

参数

hServer

[in] 服务器句柄。

nTagID

[in] TagID。

pTagType

[out] 普通点的类型。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h

说明

该接口通过ID获取普通点的类型。

举例

pt_query_tag_type

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

void tag_change_call_back(HDHANDLE hServer, uint32 nChangeTime, uint8 nTagChangeType, TagProp* pTag)

{

printf("\n receive a tag change message, tag id is %d, tag change type is %d!\n", pTag->nTagID, nTagChangeType);

}

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tagSave;

TagProp tagQuery;

const char* szTagName_1 = "szTagName_1";

const char* szTagName_2 = "szTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//register tag change call back

pt_register_tag_change_info(tag_change_call_back);

printf("register tag change callback successful!\n");

//add two tag

strcpy(tagSave.szTagName, szTagName_1);

tagSave.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

strcpy(tagSave.szTagName, szTagName_2);

tagSave.nTagType = TAG_TYPE_STRING;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_STRING);

nRet = pt_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query tags by condition failed!\n", tagSave.szTagName);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &tagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query tag successful, tag name is %s, tag type is %d!\n", tagQuery.szTagName, tagQuery.nTagType);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tag complete!");

  break;

 }

 else

 {

  printf("query tag failed, error code [%d]!", nRet);

  break;

 }

}

printf("you queried %d tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = pt_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagID);

//query tag type

uint8 nTagType = 0;

nRet = pt_query_tag_type(hServer, nTagID, &nTagType);

if (nRet != RD_SUCCESS)

{

 printf("query tag type failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag type successful, tag id[%d]!\n",  nTagID);

//modify tag desc

strcpy(tagSave.szDescriptor, "tag descriptor is modified");

nRet = pt_modify_tag_prop(hServer, nTagID, &tagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = pt_query_tag_prop(hServer, nTagID, &tagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 tagQuery.nTagID, tagQuery.szTagName, tagQuery.szDescriptor);

//delete tag

nRet = pt_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参见：

pt_add_tag

pt_delete_tag

pt_modify_tag_prop

pt_query_tagid

pt_query_tag_type

pt_query_tag_prop

pt_query_tags_cond

pt_register_tag_change_info


pt_register_tag_change_info

查看其它

Navigation: »No topics above this level«

查看其它

 Return to chapter overview

pt_register_tag_change_info

Glossary Item Box

函数

注册普通点的变更通知，当服务器的普通点变更时客户端收到变更通知(增加，删除，修改)并执行该回调函数

void pt_register_tag_change_info(

void (*pFunc)(HDHANDLE, uint32, uint8, TagProp*)

);

参数

pFunc

[in] 普通点变更时的回调函数，参数依次为服务器句柄，变更时间，变更类型，普通点属性

返回值

无

说明

iHyperDB支持普通点的在线变更，当普通点被变更时客户端会接收到相应的通知以保持实时性。

点的变更类型 | 含义
TAG_CHANGE_TYPE_ADD | 新增点
TAG_CHANGE_TYPE_MODIFY | 修改点
TAG_CHANGE_TYPE_DELETE | 删除点

在回调函数中不能调用其它的iHyperDB的API。

举例

pt_register_tag_change_info

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

void tag_change_call_back(HDHANDLE hServer, uint32 nChangeTime, uint8 nTagChangeType, TagProp* pTag)

{

printf("\n receive a tag change message, tag id is %d, tag change type is %d!\n", pTag->nTagID, nTagChangeType);

}

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tagSave;

TagProp tagQuery;

const char* szTagName_1 = "szTagName_1";

const char* szTagName_2 = "szTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//register tag change call back

pt_register_tag_change_info(tag_change_call_back);

printf("register tag change callback successful!\n");

//add two tag

strcpy(tagSave.szTagName, szTagName_1);

tagSave.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

strcpy(tagSave.szTagName, szTagName_2);

tagSave.nTagType = TAG_TYPE_STRING;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_STRING);

nRet = pt_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query tags by condition failed!\n", tagSave.szTagName);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &tagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query tag successful, tag name is %s, tag type is %d!\n", tagQuery.szTagName, tagQuery.nTagType);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tag complete!");

  break;

 }

 else

 {

  printf("query tag failed, error code [%d]!", nRet);

  break;

 }

}

printf("you queried %d tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = pt_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagID);

//query tag type

uint8 nTagType = 0;

nRet = pt_query_tag_type(hServer, nTagID, &nTagType);

if (nRet != RD_SUCCESS)

{

 printf("query tag type failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag type successful, tag id[%d]!\n",  nTagID);

//modify tag desc

strcpy(tagSave.szDescriptor, "tag descriptor is modified");

nRet = pt_modify_tag_prop(hServer, nTagID, &tagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = pt_query_tag_prop(hServer, nTagID, &tagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 tagQuery.nTagID, tagQuery.szTagName, tagQuery.szDescriptor);

//delete tag

nRet = pt_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参见：

pt_add_tag

pt_delete_tag

pt_modify_tag_prop

pt_query_tagid

pt_query_tag_type

pt_query_tag_prop

pt_query_tags_cond

pt_register_tag_change_info

pt_add_tag

pt_add_tag


双机热备

Navigation: »No topics above this level«

双机热备

 Return to chapter overview

双机热备

Glossary Item Box

©2015. All Rights Reserved.


快速入门

Navigation: »No topics above this level«

快速入门

 Return to chapter overview

©2015. All Rights Reserved.


数据转储

Navigation: »No topics above this level«

数据转储

 Return to chapter overview

数据转储

Glossary Item Box

数据库转储的作用是将iHyperDB中存储的记录数据转储到关系数据库中（Relational Database，RDB），便于利用关系数据库的数据关联性分析，提供有效的数据分析和统计，实现数据的有效利用和价值利用。

详细内容请参考：数据转储。


冗余配置

Navigation: »No topics above this level«

冗余配置

 Return to chapter overview

冗余配置

Glossary Item Box

服务端的冗余进程hdRedundancy.exe启动时读取服务端的配置文件ServerCfg.xml。服务端的其它模块如hdKernel.exe和hdNetMgr.exe也公用此配置文件。

冗余配置项：

配置项 | 备注
GlobalCfg->EnableRedundancy | 表明是启用冗余，0为不启用，非0为启用
HostAddr->IP | 配置的主机IP
HostAddr->Port | 配置的主机端口
BackUpAddr->IP | 配置的备机IP
BackUpAddr->Port | 配置的备机端口
LocalGateWay->IP | 本机网关IP

注意事项：

1、两台冗余机的主备机IP和端口信息必须完全一样。

2、主机和备机不能配置为同一台计算机。

3、主备IP地址不能配置为"127.0.0.1-127.255.255.255"的IP。

4、运行冗余程序的用户需要有administrator的权限。

5、主备机互为信任。


冗余概述

Navigation: »No topics above this level«

冗余概述

 Return to chapter overview

冗余概述

Glossary Item Box

iHyperDB的冗余系统为双机冗余，即在iHyperDB的服务端部署配置相同的两台服务器，如果其中的一台服务器停止工作，整个实时数据库系统仍然可以正常工作，并不会影响用户的使用。对于同一个用户程序而言，2台冗余服务器服务器不能同时连接。如果服务器正在同步，普通点的添加修改和删除就会失败。


S_BI_HD_03 新增snapShot值

Navigation: »No topics above this level«

S_BI_HD_03 新增snapShot值

 Return to chapter overview

· 接口说明:

当前版本：0.1

接口描述：添加tag点的snapshot值

接口服务ID：S_BI_HD_03

请求服务名：BIHDDataHandle

请求方法：addSnapShots

· 请求参数示例

HTTP请求：[POST] /service/S_BI_HD_03

HTTP请求体如下：

{

"__sys__": {

"msg": "",

"msgKey": "",

"detailMsg": "",

"status": 0

},

"__version__": "2.0",

"__blocks__": {},

"dsTags": {

"236test": {

"clientId": "1662527075199957",

"secret": "4CA22F930ABCEC5882F444FA93856B17",

"tags": [

{

"tagName": "tag10087",

"records": [

{

"value": "1",

"recordTime": "2024-01-03T00:12:00.000",

"quality": 192

}

]

},

{

"tagName": "ihd_opc_opcua_tag_5",

"records": [

{

"value": "1",

"recordTime": "2024-01-03T00:12:00.000",

"quality": 192

}

]

},

{

"tagName": "tag10086",

"records": [

{

"value": "1",

"recordTime": "2024-02-03T00:12:00.000",

"quality": 192

},

{

"value": "1",

"recordTime": "2024-02-03T00:17:00.000",

"quality": 192

}

]

}

]

}

}

}

请求参数含义解析:

层级名称 | 键（Key） | 键（Key）描述
dsTags | 236test | 数据源名称
+236test | clientId | 客户端id
 | secret | 密钥
 | tags | tag点信息列表
++tags | tagName | tag点名称
 | records | 快照信息
+++records | value | 快照值
 | recordTime | 快照时间
 | quality | 快照质量

· 调用返回示例

{

"successList": [

{

"dsName": "236test",

"successTags": [

{

"errorCode": 0,

"recordNum": 0,

"records": [],

"tagId": 354604,

"tagName": "tag10086",

"tagType": 1

}

]

}

],

"__sys__": {

"msg": "",

"traceId": "0aa19a822173690743926700000010",

"detailMsg": "",

"msgKey": "",

"status": 2

},

"__version__": "2.0",

"failList": [

{

"noAuthTags": [

"ihd_opc_opcua_tag_5"

],

"dsName": "236test",

"notExistTags": [

"tag10087"

],

"requestFailedTags": {

"msg": "点存在且有权限，但调用服务异常！",

"tagList": [

{

"tagName": "tag10086",

"errorMsg": "存储数据时间乱序 "

}

]

}

}

],

"__blocks__": {}

}

返回参数说明；

参数名称 | 参数类型 | 参数描述
+++errorMsg | String | 单点请求失败具体描述信息
+++tagName | String | tag点名称
++msg | String | 请求失败原因整体概述
++tagList | List<Map> | 失败Tag点列表
+dsName | String | 数据源名称
+noAuthTags | List<String> | 没有权限Tag点列表
+notExistTags | List<String> | 不存在Tag点列表
+requeFailedTags | Map<String, Object> | 请求失败Tag点集合
+successTags | List | 成功点表
failList | List<Map> | 失败数据源列表
successList | List<Map> | 成功数据源列表


S_BI_HD_04 查询tag点实时值

Navigation: »No topics above this level«

S_BI_HD_04 查询tag点实时值

 Return to chapter overview

· 接口说明:

当前版本：0.1

接口描述：查询tag点的实时值

接口服务ID：S_BI_HD_04

请求服务名：BIHDDataHandle

请求方法：queryRealTimeData

· 请求参数示例

HTTP请求：[POST] /service/S_BI_HD_04

HTTP请求体如下：

{

"__sys__": {

"msg": "",

"msgKey": "",

"detailMsg": "",

"status": 0

},

"__version__": "2.0",

"__blocks__": {},

"dsTags": {

"236test": {

"clientId": "1662527075199957",

"secret": "4CA22F930ABCEC5882F444FA93856B17",

"tags": [

{

"tagName": "tag10082024"

},

{

"tagName": "tag2"

},

{

"tagName": "ihd_opc_opcua_tag_5"

},

{

"tagName": "tag10086"

}

]

}

}

}

请求参数含义解析:

层级名称 | 键（Key） | 键（Key）描述
dsTags | 236test | 数据源名称
+236test | clientId | 客户端id
 | secret | 密钥
 | tags | tag点信息列表
++tags | tagName | tag点名称

· 调用返回示例

{

"successList":[

{

"dsName":"236test",

"successTags":[

{

"records":[

{

"recordTime":"2024-02-03T00:17:00.000",

"value":"1",

"quality":"Good"

}

],

"tagType":1,

"tagName":"tag10086"

}

]

}

],

"__sys__":{

"msg":"",

"traceId":"0aa19a82217369314388870000000b",

"detailMsg":"",

"msgKey":"",

"status":2

},

"__version__":"2.0",

"failList":[

{

"noAuthTags":[

"ihd_opc_opcua_tag_5"

],

"dsName":"236test",

"notExistTags":[

"tag2"

],

"requestFailedTags":{

"msg":"点存在且有权限，但调用服务异常！",

"tagList":[

{

"tagName":"tag10082024",

"errorMsg":"查询的内存快照不存在 "

}

]

}

}

],

"__blocks__":{

}

}

返回参数说明：

参数名称 | 参数类型 | 参数描述
successList | List<Map> | 注意首先要判断__sys__ 下的status，如果status<0可能没有successList信息 成功数据源列表
+dsName | String | 数据源名称
+successTags | List | 成功点表
++tagName | String | tag点名称
++tagType | Integer | tag点数据类型 0： HD3_TAG_TYPE_INT 1： HD3_TAG_TYPE_INT16, 2： HD3_TAG_TYPE_INT32, 3： HD3_TAG_TYPE_FLOAT32, 4： HD3_TAG_TYPE_FLOAT64, 5： HD3_TAG_TYPE_DIGITAL, 6： HD3_TAG_TYPE_STRING, 7： HD3_TAG_TYPE_BLOB
++records | Map | 记录集合
+++recordTime | String | 记录时间
+++value | String | 记录值
+++quality | String | 记录质量
failList | List<Map> | 注意首先要判断__sys__ 下的status，如果status = 0可能没有failList信息 失败数据源列表
+dsName | String | 数据源名称
+noAuthTags | List<String> | 没有权限Tag点列表
+notExistTags | List<String> | 不存在Tag点列表
+requeFailedTags | Map<String, Object> | 请求失败Tag点集合
++msg | String | 请求失败原因整体概述
++tagList | List<Map> | 失败Tag点列表
+++tagName | String | tag点名称
+++errorMsg | String | 单点请求失败具体描述信息


S_BI_HD_05 查询tag点历史数据

Navigation: »No topics above this level«

S_BI_HD_05 查询tag点历史数据

 Return to chapter overview

· 接口说明:

当前版本：0.1

接口描述：查询tag点的历史数据

接口服务ID：S_BI_HD_05

请求服务名：BIHDDataHandle

请求方法：queryHistoryData

· 请求参数示例

HTTP请求：[POST] /service/S_BI_HD_05

HTTP请求体如下：

{

"__sys__": {

"msg": "",

"msgKey": "",

"detailMsg": "",

"status": 0

},

"__version__": "2.0",

"__blocks__": {},

"startTime": "2024-01-01T00:00:00.000",

"endTime": "2024-01-04T01:00:00.000",

"model": 0,

"limit": 100,

"dsTags": {

"236test": {

"clientId": "1662527075199957",

"secret": "4CA22F930ABCEC5882F444FA93856B17",

"tagNameList": [

"tag10086",

"tag2",

"tag10082024",

"ihd_opc_opcua_tag_5"

]

}

}

}

请求参数含义解析:

名称 | 类型 | 是否必需 | 描述
startTime | String | 是 | 开始时间
endTime | String | 是 | 结束时间(有model无需该参数，开始-结束区间内最多能查65535条)
model | int | 否 | 查询模式（1表示向已过去时间，0表示向未来时间）
limit | int | 否 | 限制条数(limit和model需要同时填且limit最大不能超过65535)

层级名称 | 键（Key） | 键（Key）描述
dsTags | 236test | 数据源名称
+236test | clientId | 客户端id
 | secret | 密钥
 | tags | tag点名称列表

·历史数据查询三种场景

1.查询某一段时间内的历史记录：startTime和endTime必填，model和limit参数不需要。返回结果为tag点在startTime和endTime区间内的历史数据，最多65535条。

2.按记录条数查询某时间点向前（过去时间）的历史记录：startTime、model和limit必填，endTime不需要。model填1，startTime和limit按实际填写。返回结果为以startTime为起始时间点，查询过去的若干条历史数据（用limit控制），最多65535条。

3.按记录条数查询某时间点向后（未来时间）的历史记录：startTime、model和limit必填，endTime不需要。model填0，startTime和limit按实际填写。返回结果为以startTime为起始时间点，查询未来的若干条历史数据（用limit控制），最多65535条。

注：此处场景主要针对startTime、endTime、model、limit四个参数的使用进行说明。

· 调用返回示例

{

"successList":[

{

"dsName":"236test",

"successTags":[

{

"records":[

{

"recordTime":"2024-01-02T00:12:00.000",

"value":"1",

"quality":"Good"

},

{

"recordTime":"2024-01-03T00:12:00.000",

"value":"1",

"quality":"Good"

},

{

"recordTime":"2024-01-04T00:12:00.000",

"value":"1",

"quality":"Good"

},

{

"recordTime":"2024-02-03T00:12:00.000",

"value":"1",

"quality":"Good"

},

{

"recordTime":"2024-02-03T00:13:00.000",

"value":"1",

"quality":"Good"

},

{

"recordTime":"2024-02-03T00:15:00.000",

"value":"1",

"quality":"Good"

},

{

"recordTime":"2024-02-03T00:17:00.000",

"value":"1",

"quality":"Good"

}

],

"tagType":1,

"tagName":"tag10086"

},

{

"records":[

],

"tagType":0,

"tagName":"tag10082024"

}

]

}

],

"__sys__":{

"msg":"",

"traceId":"0aa19a82217369323716060000000c",

"detailMsg":"",

"msgKey":"",

"status":2

},

"__version__":"2.0",

"failList":[

{

"noAuthTags":[

"ihd_opc_opcua_tag_5"

],

"dsName":"236test",

"notExistTags":[

"tag2"

],

"requestFailedTags":{

"msg":"点存在且有权限，但调用服务异常！",

"tagList":[

{

"tagName":"tag10086",

"errorMsg":"没有符合查询条件的记录 "

}

]

}

}

],

"__blocks__":{

}

}

返回参数说明；

参数名称 | 参数类型 | 参数描述
successList | List<Map> | 注意首先要判断__sys__ 下的status，如果status<0可能没有successList信息 成功数据源列表
+dsName | String | 数据源名称
+successTags | List | 成功点表
++tagName | String | tag点名称
++tagType | Integer | tag点数据类型 0： HD3_TAG_TYPE_INT 1： HD3_TAG_TYPE_INT16, 2： HD3_TAG_TYPE_INT32, 3： HD3_TAG_TYPE_FLOAT32, 4： HD3_TAG_TYPE_FLOAT64, 5： HD3_TAG_TYPE_DIGITAL, 6： HD3_TAG_TYPE_STRING, 7： HD3_TAG_TYPE_BLOB
++records | Map | 记录集合
+++recordTime | String | 记录时间
+++value | String | 记录值(数据类型是Digital时，无论用户有没有配置数字量状态集，value返回值=历史值)
+++quality | String | 记录质量
failList | List<Map> | 注意首先要判断__sys__ 下的status，如果status = 0可能没有failList信息 失败数据源列表
+dsName | String | 数据源名称
+noAuthTags | List<String> | 没有权限Tag点列表
+notExistTags | List<String> | 不存在Tag点列表
+requeFailedTags | Map<String, Object> | 请求失败Tag点集合
++msg | String | 请求失败原因整体概述
++tagList | List<Map> | 失败Tag点列表
+++tagName | String | tag点名称
+++errorMsg | String | 单点请求失败具体描述信息


S_BI_HD_06 查询tag点插值

Navigation: »No topics above this level«

S_BI_HD_06 查询tag点插值

 Return to chapter overview

· 接口说明:

当前版本：0.1

接口描述：查询tag点的插值

接口服务ID：S_BI_HD_06

请求服务名：BIHDDataHandle

请求方法：queryInterPolation

· 请求参数示例

HTTP请求：[POST] /service/S_BI_HD_06

HTTP请求体如下：

{

"__sys__": {

"msg": "",

"msgKey": "",

"detailMsg": "",

"status": 0

},

"__version__": "2.0",

"__blocks__": {},

"queryMode": 0,

"dsTags": {

"236test": {

"clientId": "1662527075199957",

"secret": "4CA22F930ABCEC5882F444FA93856B17",

"tags": [

{

"tagName": "tag10086",

"startTime": "2024-01-03T00:10:00.000",

"endTime": "2024-01-04T00:10:00.000",

"interTime": "1000"

},

{

"tagName": "tag2",

"startTime": "2024-02-25T00:10:00.000",

"endTime": "2024-02-25T00:10:05.000",

"interTime": "1"

},

{

"tagName": "tag10082024",

"startTime": "2024-02-25T00:10:00.000",

"endTime": "2024-02-25T00:10:05.000",

"interTime": "1"

},

{

"tagName": "ihd_opc_opcua_tag_5",

"startTime": "2024-02-25T00:10:00.000",

"endTime": "2024-02-25T00:10:05.000",

"interTime": "1"

}

]

}

}

}

请求参数含义解析:

名称 | 类型 | 是否必需 | 描述
queryMode | int | 是 | 插值模式 0：线性插值 1：前向插值

层级名称 | 键（Key） | 键（Key）描述
dsTags | 236test | 数据源名称
+236test | clientId | 客户端id
 | secret | 密钥
 | tags | tag点信息列表
++tags | tagName | tag点名称
 | startTime | 开始时间
 | endTime | 结束时间
 | interTime | 插值间隔（单位：s）

· 调用返回示例

{

"successList": [

{

"dsName": "236test",

"successTags": [

{

"records": [

{

"recordTime": "2024-01-04T00:10:00.000",

"value": "1",

"quality": "Good"

}

],

"tagType": 1,

"tagName": "tag10086"

}

]

}

],

"__sys__": {

"msg": "",

"traceId": "0aa19a82217369330216860000000d",

"detailMsg": "",

"msgKey": "",

"status": 2

},

"__version__": "2.0",

"failList": [

{

"noAuthTags": [

"ihd_opc_opcua_tag_5"

],

"dsName": "236test",

"notExistTags": [

"tag2"

],

"requestFailedTags": {

"msg": "点存在且有权限，但调用服务异常！",

"tagList": [

{

"tagName": "tag10082024",

"errorMsg": "插值查询记录不存在 "

}

]

}

}

],

"__blocks__": {}

}

返回参数说明；

参数名称 | 参数类型 | 参数描述
successList | List<Map> | 成功数据源列表
+dsName | String | 数据源名称
+successTags | List | 成功点表
++tagName | String | tag点名称
++tagType | Integer | tag点数据类型 0： HD3_TAG_TYPE_INT 1： HD3_TAG_TYPE_INT16, 2： HD3_TAG_TYPE_INT32, 3： HD3_TAG_TYPE_FLOAT32, 4： HD3_TAG_TYPE_FLOAT64, 5： HD3_TAG_TYPE_DIGITAL, 6： HD3_TAG_TYPE_STRING, 7： HD3_TAG_TYPE_BLOB
++records | Map | 记录集合
+++recordTime | String | 记录时间
+++value | String | 记录值
+++quality | String | 记录质量
failList | List<Map> | 失败数据源列表
+dsName | String | 数据源名称
+noAuthTags | List<String> | 没有权限Tag点列表
+notExistTags | List<String> | 不存在Tag点列表
+requeFailedTags | Map<String, Object> | 请求失败Tag点集合
++msg | String | 请求失败原因整体概述
++tagList | List<Map> | 失败Tag点列表
+++tagName | String | tag点名称
+++errorMsg | String | 单点请求失败具体描述信息


S_BI_HD_09 统计

Navigation: »No topics above this level«

S_BI_HD_09 统计

 Return to chapter overview

· 接口说明:

当前版本：0.1

接口描述：统计计算接口

接口服务ID：S_BI_HD_09

请求服务名：BIHD09

请求方法：calculateTagValues

· 请求参数示例

HTTP请求：[POST] /service/S_BI_HD_09

HTTP请求体如下：

{

"clientId": "4436611986732923",

"secret": "45384AE8472330A8C0843EE969296BEA",

"dsName": "test217",

"tags": [

{

"tagName": "hdsys_cpu_0",

"statsType":0,

"timeRegions":[

{

"startTime": "2024-06-18T0:00:00.000",

"endTime": "2024-06-18T16:01:00.000"

}

]

}

]

}

请求参数含义解析:

名称

类型

是否必需

描述

clientId

String

是

客户端id

secret

String

是

密钥

dsName

String

是

数据源名称

calculateEx

Boolean

否

是否调用扩展接口，如未传入该参数或传入值为false，则调用统计计算常规接口，如传入该参数且值为true，则调用统计计算扩展接口

tags

List<Map>

是

点表

详解如下：
常规接口：

key | 含义 | 类型 | 是否必需 | 描述
tagName | 点名 | String | 是 |
statsType | 统计类型 | int | 是 | 统计类型 0：最大值 1：最小值 2：求和 5：算术平均值
timeRegions | 时间范围 | List<Map<String, String>> | 是 | 时间范围， startTime为起始时间，格式为"YYYY-MM-ddThh:mm:ss.SSS"， endTime为结束时间，格式为"YYYY-MM-ddThh:mm:ss.SSS"

扩展接口：

key | 含义 | 类型 | 是否必需 | 描述
tagName | 点名 | String | 是 |
statsType | 统计类型 | int | 是 | 统计类型 0：最大值 1：最小值 2：求和 3：最新值 4：可信度 5：算术平均值 6：时间加权平均值 7：积分 8：值变化 9：区间变化,从<=到>= 10：区间变化，从>=到<= 11：差值统计 12：值在区间 13：值不在区间 14：极差 15：标准差 16：大于某个值的时间 17：大于等于某个值的时间 18：等于某个值的时间 19：不等于某个值的时间 20：小于某个值的时间 21：小于等于某个值的时间 22：在某个值区间的时间 23：不在某个值区间的时间
timeRegions | 时间范围 | List<Map<String, String>> | 是 | 统计区间数组，其中， startTime为起始时间，格式为"YYYY-MM-ddThh:mm:ss.SSS"， endTime为结束时间，格式为"YYYY-MM-ddThh:mm:ss.SSS"，
percentGood | 信任度 | float | 否 | Good的数据个数百分比大于或等于该比例时认为计算出的结果是可信的，取值范围为0-100
sampleType | 统计类型 | float | 否 | 0：原始点 1：线性插值 2：前向插值
filterExpr | 数据过滤表达式 | String | 否 | 数据过滤表达式
filterFailMode | 过滤失败时对采样数据的处理 | int | 否 | 0为过滤采样数据，1为不过滤采样数据
extParam1 | 第一个参数 | float | 否 | 计数和计时的参数, 值变化的参数，区间变化的第一个参数，在区间不在区间的第一个参数
extParam2 | 第二个参数 | float | 否 | 计数和计时的参数，区间变化的第二个参数，在区间不在区间的第二个参数
offset | 偏移量 | int | 否 | 采样模式为插值时，插值点为startTime+nOffset,startTime+nOffset+nPeriod, 单位为秒
period | 插值间隔 | int | 否 | 采样模式为插值时，插值点的间隔为nPeriod, 单位为秒
useBadValue | bad值是否参与统计 | int | 否 | 1表示bad值参与统计，0表示不参与

· java调用示例

EiInfo inInfo = new EiInfo();

List<Map> tagList = new ArrayList<>();

Map<String, Object> map = new HashMap<>();

map.put("tagName", "hdsys_cpu_0");

map.put("statsType", 0);

List<Map> timeList = new ArrayList<>();

Map<String, String> TimeMap = new HashMap<>();

TimeMap.put("startTime", "2024-07-01T0:00:00.000");

TimeMap.put("endTime", "2024-07-01T0:00:00.000");

timeList.add(TimeMap);

map.put("timeRegions", timeList);

tagList.add(map);

inInfo.set("clientId","4436611986732923");

inInfo.set("secret","45384AE8472330A8C0843EE969296BEA");

inInfo.set("dsName","test217");

inInfo.set("tags",tagList);

inInfo.set(EiConstant.serviceId, "S_BI_HD_09");

outInfo = XServiceManager.call(inInfo);

· 返回结果示例

{

"result": {

"tags": [

{

"tagName": "hdsys_cpu_0",

"tagId": "1",

"errorCode": "0",

"value": "28"

}

]

},

"__sys__": {

"msg": "",

"traceId": "0aa19758e17224093092310000005c",

"detailMsg": "",

"msgKey": "",

"status": 1

},

"__version__": "2.0",

"__blocks__": {}

}


S_BI_HD_0101 添加tag点

Navigation: »No topics above this level«

S_BI_HD_0101 添加tag点

 Return to chapter overview

· 接口说明:

当前版本：0.1

接口描述：添加tag点并绑定资源组，如果资源组为空

接口服务ID：S_BI_HD_0101

请求服务名：BIHDTagHandle

请求方法：addTags

· 请求参数示例

HTTP请求：[POST] /service/S_BI_HD_0101

HTTP请求体如下：

{

"__sys__": {

"msg": "",

"msgKey": "",

"detailMsg": "",

"status": 0

},

"__version__": "2.0",

"__blocks__": {},

"dsTags": {

"236test": {

"clientId": "6155998518178528",

"secret": "F6FF8B631458F705F2338103ADE226D5",

"tags": [

{

"descriptor": "description1",

"tagName": "tag092024",

"tagType": 1,

"resourceGroups": [

"recordaccess"

]

}

]

},

"128test": {

"clientId": "2387495788185032",

"secret": "0C9C38E7FADBE5C4B4D2CEA8C8284ED6",

"tags": [

{

"descriptor": "description1",

"tagName": "tag092024",

"tagType": 1

}

]

}

},

"tagClass": "basic"

}

请求参数含义解析:

名称 | 类型 | 是否必需 | 描述
tags | Map<List<Map>> | 是 | tag点信息（第一层map的key为数据源名称）
++descriptor | String | 是 | tag点描述
++tagName | String | 是 | tag点名称
++tagType | Integer | 是 | tag点类型
++resourceGroups | List<String> | 否 | tag点想要绑定的资源组名称列表
tagClass | String | 是 | tag点类型（普通点basic、计算点calc、统计点stats）
clientId | String | 是 | 客户端id
secret | String | 是 | 密钥

tag点属性字段列表:

公共属性 | 说明 | 普通点特有属性 | 说明 | 计算点特有属性 | 说明 | 统计点特有属性 | 说明
"tagName" | 数据源名称，在数据库内唯一 | "instrumentAddress" |  | "caCalcMode" |  | "statsType" |
"archiving" | 归档状态，为1表示需要，为0表示不需要 | "instrumentAddressType" |  | "calcPeriod" |  | "sampleStartDate" |
"changeDate" | tag最近一次的修改日期，系统自动生成 | "collectorName" | 采集器名 | "calcExOpcStatepr" |  | "sampleMode" | enum，统计点采样模式/统计方式，HD3_STATS_SAMPLE_MODE
"changer" | tag最近一次的修改日期，系统自动生成 | "collectorID" |  | "calcHistory" | 是否设置开始时间，bool | "sampleInterval" |
"compDev" | float，存储压缩误差，为0表示不启用 | "deviceName" |  | "calcStartDate" |  | "sampleBeginOffset" | 基本-每天时段-开始
"compMaxTime" | 基本-存储压缩-超时，为零时表示不启用本属性，通常设定为28800秒，也就是8个小时.CompMax和CompMin必须同时添加和修改 | "deviceID" |  | "calcEndDate" |  | "sampleEndOffset" | 基本-每天时段-结束
"compType" | bool，存储-压缩，0为不压缩，当tagtype为string,blob,digital是只能为不压缩 | "scanGroupName" |  | "haveEndTime" | 是否设置结束时间，bool | "sampleMonthBeginDay" | 基本-定周期-每月时段-开始
"creationDate" | tag的创建日期，系统自动生成 | "scanGroupID" |  | "caSourceTagName" |  | "sampleMonthEndDay" | 基本-定周期-每月时段-结束
"creator" | tag的创建者，系统自动生成 | "dataOrder" | enum，modbus专用，dataType与类型关系见TagConfig.cpp中SetCurrentDataAddr方法 |  |  | "beginTimeStamp" | bool，其他-记录时间戳-起始（1）/结束（0）
"recAccess" | int，详见iHD的权限管理-记录和Tag编辑权限配置说明 |  |  |  |  | "timeStampOffset" | 其他-记录时间戳-起始/结束偏移
"recNormalGroup" |  |  |  |  |  | "scanPeriod" | 基本-扫描周期
"recOwnerGroup" | 表示该点的数值属于哪个owner所拥有，不能为不存在的组 |  |  |  |  | "pctGood" | 最小信任度
"descriptor" | Tag描述 |  |  |  |  | "filterExpr" |
"digitalSet" | 数字量点所对应的数字状态集合的名称，必须设定，否则该数字类型点无法导入数据库，所以必须事先建立状态集合 |  |  |  |  | "dropBadMode" |
"engUnits" | 工程单位 |  |  |  |  | "countParam1" | 统计类型-计数类型下的两个参数
"excMaxTime" |  |  |  |  |  | "countParam2" | 统计类型-计数类型下的两个参数
"excDev" | 采集过滤误差 |  |  |  |  | "sampleType" | enum，统计采样类型，HD_SAMPLE_TYPE
"tagID" | 数据源的ID，一个数据源只有唯一一个ID |  |  |  |  | "interpOffset" |
"tagType" | tag点数据类型 0： HD3_TAG_TYPE_INT 1： HD3_TAG_TYPE_INT16, 2： HD3_TAG_TYPE_INT32, 3： HD3_TAG_TYPE_FLOAT32, 4： HD3_TAG_TYPE_FLOAT64, 5： HD3_TAG_TYPE_DIGITAL, 6： HD3_TAG_TYPE_STRING, 7： HD3_TAG_TYPE_BLOB |  |  |  |  | "interpPeriod" |
"tagAccess" | int，转二进制，只看高位，表示是否 |  |  |  |  | "conversionType" |
"tagNormalGroup" |  |  |  |  |  | "conversion" |
"tagOwnerGroup" | 控制点配置级别对应属于的owner |  |  |  |  | "filterFailMode" |
"scan" | 设定该点是否被接口机轮询标志 |  |  |  |  | "stCalcPeriod" | 计算周期
"span" | 设定为该点值的跨度 |  |  |  |  | "reset" |
"minValue" |  |  |  |  |  | "useBadValue" | 使用bad记录
"opcState" | OPCServer发布状态 |  |  |  |  | "stSourceTagName" | 监测点
"tagAvaliable" |  |  |  |  |  |  |

返回参数含义解析:

名称 | 类型 | 描述 | 备注
failAddTags | Map<String,Map<String,Object>> | 添加失败的列表 | key 为数据源名称
+failMsg | Sting | 添加失败原因 |
+failAddList | List<Map<String,Object>> | 添加失败的tag点列表 |
++errorCode | Sting | 错误码 |
++tagName | Sting | tag点名称（如test217-tag1） |
++errorMsg | Sting | 错误信息 |
+failBindList | List<Map<String,Object>> | 绑定资源失败的tag点列表 |
successAddTags | Map<String,Map<String,Object>> | 添加成功的列表 | key 为数据源名称
+successAddList | List<String> | 添加成功的tag点列表 |
+successBindList | List<String> | 绑定资源组成功的tag点列表 |
status | int | 调用接口返回状态： 0、所有操作均成功， 2、部分操作成功， -1、所有操作均失败 |
msg | String | 整体接口返回的信息： 1、所有点添加成功且资源组绑定成功 2、所有点添加成功，部分资源组绑定失败 3、部分点添加成功，添加成功的点资源组绑定成功 4、部分点添加成功，添加成功的点部分资源组绑定失败 5、所有点添加失败 |

·调用返回示例

成功示例 | 失败示例 | 部分成功示例
{ "failAddTags": {}, "successAddTags": { "test_90": { "successAddList": [ "eee" ], "successBindList": [ "eee" ] } }, "__sys__": { "msg": "test_90点添加成功，资源绑定成功", "detailMsg": "", "status": 0 } } | { "failAddTags": { "test_90": { "failMsg": "", "failAddList": [ { "errorCode": "117915", "tagName": "ddddd", "errorMsg": "名字已经存在 " } ], "failBindList": [ { "tagName": "eee", "errorMsg": "资源错误" } ] } }, "successAddTags": {}, "__sys__": { "msg": "test_90点添加失败，资源绑定失败", "detailMsg": "", "status": -1 } } | { "failAddTags": { "test_90": { "failMsg": "", "failAddList": [ { "errorCode": "117915", "tagName": "ddddd", "errorMsg": "名字已经存在 " } ], "failBindList": [ { "tagName": "qwe", "errorMsg": "资源错误 " } ] } }, "successAddTags": { "test_90": { "successAddList": [ "qwe", "fre" ], "successBindList": [ "fre" ] } }, "__sys__": { "msg": "test_90点部分添加成功，资源部分绑定成功", "detailMsg": "", "status": 2 } }


S_BI_HD_0102 删除tag点

Navigation: »No topics above this level«

S_BI_HD_0102 删除tag点

 Return to chapter overview

· 接口说明:

当前版本：0.1

接口描述：删除tag点

接口服务ID：S_BI_HD_0102

请求服务名：BIHDTagHandle

请求方法：deleteTags

· 请求参数示例

HTTP请求：[POST] /service/S_BI_HD_0102

HTTP请求体如下：

{

"__sys__": {

"msg": "",

"msgKey": "",

"detailMsg": "",

"status": 0

},

"__version__": "2.0",

"__blocks__": {},

"dsTags": {

"236test": {

"clientId": "1662527075199957",

"secret": "4CA22F930ABCEC5882F444FA93856B17",

"tags": [

{

"tagName": "tag1"

},

{

"tagName": "tag20250108"

},

{

"tagName": "tag20250107"

}

]

}

}

}

请求参数含义解析:

名称 | 类型 | 是否必需 | 描述
tags | Map<List> | 是 | tag点名列表（第一层map的key为数据源名称）
+dsName（例如“mainTest”） | String | 是 | 数据源名称
++tagName） | String | 是 | tag点名
clientId | String | 是 | 客户端id
secret | String | 是 | 密钥

· java调用示例

EiInfo inInfo = new EiInfo();

List<Map> tags = new ArrayList<>();

Map map1 = new HashMap();

map1.put("tagName","tag1");

Map map2= new HashMap();

map2.put("tagName","tag2");

tags.add(map1);

tags.add(map2);

inInfo.set("tags", tags);

inInfo.set("ihdName", "mainTest");

inInfo.set("clientId", "7805711705593430");

inInfo.set("secret", "9B3618F1E7AB15C22E95D9ECDBEF1E27");

inInfo.set(EiConstant.serviceId, "S_BI_HD_0102");

outInfo = XServiceManager.call(inInfo);

· 返回示例

{

"successList": [

{

"dsName": "236test",

"successTags": [

"tag20250108"

]

}

],

"__sys__": {

"msg": "",

"traceId": "0aa19a3ab173707650145600000045",

"detailMsg": "",

"msgKey": "",

"status": 2

},

"__version__": "2.0",

"failList": [

{

"noAuthTags": [

"tag20250107"

],

"dsName": "236test",

"notExistTags": [

"tag1"

],

"requestFailedTags": {}

}

],

"__blocks__": {}

}

返回参数解析:

参数名称 | 参数类型 | 参数描述
successList | List<Map> | 成功的数据源列表
+dsName | String | 数据源名称
+successTags | List | 成功点表
failList | List<Map> | 失败的数据源列表
+dsName | String | 数据源名称
+noAuthTags | List<String> | 没有权限Tag点列表
+notExistTags | List<String> | 不存在Tag点列表
+requeFailedTags | Map<String, Object> | 请求失败Tag点集合
++msg | String | 请求失败原因整体概述
++tagList | List<Map> | 失败Tag点列表
+++tagName | String | tag点名称
+++errorMsg | String | 单点请求失败具体描述信息


S_BI_HD_0103 修改tag点信息

Navigation: »No topics above this level«

S_BI_HD_0103 修改tag点信息

 Return to chapter overview

· 接口说明:

当前版本：0.1

接口描述：修改tag点信息

接口服务ID：S_BI_HD_0103

请求服务名：BIHDTagHandle

请求方法：modifyTags

· 请求参数示例

HTTP请求：[POST] /service/S_BI_HD_0103

HTTP请求体如下：

{

"__sys__": {

"msg": "",

"msgKey": "",

"detailMsg": "",

"status": 0

},

"__version__": "2.0",

"__blocks__": {},

"dsTags": {

"236test": {

"clientId": "1662527075199957",

"secret": "4CA22F930ABCEC5882F444FA93856B17",

"tags": [

{

"descriptor": "description100",

"tagName": "tag10086"

},

{

"descriptor": "description200",

"tagName": "tag20250107"

},

{

"descriptor": "description200",

"tagName": "tag2"

},

{

"tagName": "tag_digit_002"

}

]

}

}

}

请求参数含义解析:

名称 | 类型 | 是否必需 | 描述
tags | Map<List> | 是 | tag点名列表（第一层map的key为数据源名称）
ihdName | String | 是 | 数据源名称
clientId | String | 是 | 客户端id
secret | String | 是 | 密钥

(注：tagName仅用作定位tag点，修改的属性请以其他key-value的形式补充到对应map中）

tag点属性字段列表:

公共属性 | 说明 | 普通点特有属性 | 说明 | 计算点特有属性 | 说明 | 统计点特有属性 | 说明
"tagName" |  | "instrumentAddress" |  | "caCalcMode" |  | "statsType" |
"archiving" |  | "instrumentAddressType" |  | "calcPeriod" |  | "sampleStartDate" |
"changeDate" |  | "collectorName" | 采集器名 | "calcExpr" |  | "sampleMode" | enum，统计点采样模式/统计方式，HD3_STATS_SAMPLE_MODE
"changer" |  | "collectorID" |  | "calcHistory" | 是否设置开始时间，bool | "sampleInterval" |
"compDev" | float，存储压缩-误差 | "deviceName" |  | "calcStartDate" |  | "sampleBeginOffset" | 基本-每天时段-开始
"compMaxTime" | 基本-存储压缩-超时 | "deviceID" |  | "calcEndDate" |  | "sampleEndOffset" | 基本-每天时段-结束
"compType" | bool，存储-压缩 | "scanGroupName" |  | "haveEndTime" | 是否设置结束时间，bool | "sampleMonthBeginDay" | 基本-定周期-每月时段-开始
"creationDate" |  | "scanGroupID" |  | "caSourceTagName" |  | "sampleMonthEndDay" | 基本-定周期-每月时段-结束
"creator" |  | "dataOrder" | enum，modbus专用，dataType与类型关系见TagConfig.cpp中SetCurrentDataAddr方法 |  |  | "beginTimeStamp" | bool，其他-记录时间戳-起始（1）/结束（0）
"recAccess" | int，详见iHD的权限管理-记录和Tag编辑权限配置说明 |  |  |  |  | "timeStampOffset" | 其他-记录时间戳-起始/结束偏移
"recNormalGroup" |  |  |  |  |  | "scanPeriod" | 基本-扫描周期
"recOwnerGroup" | 不能为不存在的组 |  |  |  |  | "pctGood" | 最小信任度
"descriptor" |  |  |  |  |  | "filterExpr" |
"digitalSet" |  |  |  |  |  | "dropBadMode" |
"engUnits" | 工程单位 |  |  |  |  | "countParam1" | 统计类型-计数类型下的两个参数
"excMaxTime" |  |  |  |  |  | "countParam2" | 统计类型-计数类型下的两个参数
"excDev" | 采集过滤误差 |  |  |  |  | "sampleType" | enum，统计采样类型，HD_SAMPLE_TYPE
"tagID" |  |  |  |  |  | "interpOffset" |
"tagType" | tag点数据类型 0： HD3_TAG_TYPE_INT 1： HD3_TAG_TYPE_INT16, 2： HD3_TAG_TYPE_INT32, 3： HD3_TAG_TYPE_FLOAT32, 4： HD3_TAG_TYPE_FLOAT64, 5： HD3_TAG_TYPE_DIGITAL, 6： HD3_TAG_TYPE_STRING, 7： HD3_TAG_TYPE_BLOB |  |  |  |  | "interpPeriod" |
"tagAccess" | int，转二进制，只看高位，表示是否 |  |  |  |  | "conversionType" |
"tagNormalGroup" |  |  |  |  |  | "conversion" |
"tagOwnerGroup" |  |  |  |  |  | "filterFailMode" |
"scan" |  |  |  |  |  | "stCalcPeriod" | 计算周期
"span" |  |  |  |  |  | "reset" |
"minValue" |  |  |  |  |  | "useBadValue" | 使用bad记录
"opcState" |  |  |  |  |  | "stSourceTagName" | 监测点
"tagAvaliable" |  |  |  |  |  |  |

·返回示例

{

"successList": [

{

"dsName": "236test",

"successTags": [

"tag10086"

]

}

],

"__sys__": {

"msg": "",

"traceId": "0aa19a3ab17370784910460000003c",

"detailMsg": "",

"msgKey": "",

"status": 2

},

"__version__": "2.0",

"failList": [

{

"noAuthTags": [

"tag20250107"

],

"dsName": "236test",

"notExistTags": [

"tag2"

],

"missingConditions": {

"failMsg": "tag_digit_002条件仅有tag点名(不可更改)，没有其他可识别修改信息，修改失败！请检查！",

"failTags": [

{

"tagName": "tag_digit_002"

}

]

},

"requestFailedTags": {}

}

],

"__blocks__": {}

}

返回参数解析:

名称 | 类型 | 描述
successList | List<Map> | 成功的数据源列表
+dsName | String | 数据源名称
+successTags | List<String> | 成功操作的tag点名称
failList | List<Map> | 失败的数据源列表
+dsName | String | 数据源名称
+failTags | List<Map> | 失败的数据源列表
++errorCode | String | 错误码
++tagName | String | tag名称
++errorMsg | String | 错误信息
status | Int | 调用接口返回状态（0--所有操作均成功，2--部分操作成功，-1--所有操作均失败）

·java调用示例

EiInfo inInfo = new EiInfo();

List<Map> tags = new ArrayList<>();

Map map1 = new HashMap();

map1.put("tagName","tag1");

map1.put("descriptor","tag100");

Map map2= new HashMap();

map2.put("tagName","tag2");

map2.put("descriptor","tag200");

tags.add(map1);

tags.add(map2);

inInfo.set("tags", tags);

inInfo.set("ihdName", "mainTest");

inInfo.set("clientId", "7805711705593430");

inInfo.set("secret", "9B3618F1E7AB15C22E95D9ECDBEF1E27");

inInfo.set(EiConstant.serviceId, "S_BI_HD_0103");

outInfo = XServiceManager.call(inInfo);


S_BI_HD_0104 查询tag点信息

· 接口说明:

当前版本：0.1

接口描述：查询tag点信息

接口服务ID：S_BI_HD_0104

请求服务名：BIHDTagHandle

请求方法：queryTagsInfo

· 请求参数示例

HTTP请求：[POST] /service/S_BI_HD_0104

HTTP请求体如下：

{

"__sys__": {

"msg": "",

"msgKey": "",

"detailMsg": "",

"status": 0

},

"__version__": "2.0",

"__blocks__": {},

"dsTags": {

"236test": {

"clientId": "1662527075199957",

"secret": "4CA22F930ABCEC5882F444FA93856B17",

"limit": 10,

"offset": 0,

"conditions": [

{

"field": "tagName",

"operator": 6,

"value": "tag*"

}

]

},

"test34": {

"clientId": "515953554475101911",

"secret": "41AC4365AB56310514A7AD7C5CB60AAD",

"limit": 10,

"offset": 0,

"conditions": [

{}

]

}

}

}

请求参数含义解析:

名称 | 类型 | 是否必需 | 描述
conditions | List<Map> | 是 | 查询条件
+map | Map | 是 | +条件组集合
++field | String | 是 | ++查询字段
++operator | int | 是 | ++操作符 0：= 1：<> 2：> 3：>= 4：< 5：<= 6：like
++value | String | 是 | ++字段对应值
dsNameList | List | 是 | 数据源名称列表
clientId | String | 是 | 客户端id
secret | String | 是 | 密钥

(注：operator使用需结合field的实际逻辑）

tag点属性字段列表:

公共属性 | 说明 | 普通点特有属性 | 说明 | 计算点特有属性 | 说明 | 统计点特有属性 | 说明
"tagName" |  | "instrumentAddress" |  | "caCalcMode" |  | "statsType" |
"archiving" |  | "instrumentAddressType" |  | "calcPeriod" |  | "sampleStartDate" |
"changeDate" |  | "collectorName" | 采集器名 | "calcExpr" |  | "sampleMode" | enum，统计点采样模式/统计方式，HD3_STATS_SAMPLE_MODE
"changer" |  | "collectorID" |  | "calcHistory" | 是否设置开始时间，bool | "sampleInterval" |
"compDev" | float，存储压缩-误差 | "deviceName" |  | "calcStartDate" |  | "sampleBeginOffset" | 基本-每天时段-开始
"compMaxTime" | 基本-存储压缩-超时 | "deviceID" |  | "calcEndDate" |  | "sampleEndOffset" | 基本-每天时段-结束
"compType" | bool，存储-压缩 | "scanGroupName" |  | "haveEndTime" | 是否设置结束时间，bool | "sampleMonthBeginDay" | 基本-定周期-每月时段-开始
"creationDate" |  | "scanGroupID" |  | "caSourceTagName" |  | "sampleMonthEndDay" | 基本-定周期-每月时段-结束
"creator" |  | "dataOrder" | enum，modbus专用，dataType与类型关系见TagConfig.cpp中SetCurrentDataAddr方法 |  |  | "beginTimeStamp" | bool，其他-记录时间戳-起始（1）/结束（0）
"recAccess" | int，详见iHD的权限管理-记录和Tag编辑权限配置说明 |  |  |  |  | "timeStampOffset" | 其他-记录时间戳-起始/结束偏移
"recNormalGroup" |  |  |  |  |  | "scanPeriod" | 基本-扫描周期
"recOwnerGroup" | 不能为不存在的组 |  |  |  |  | "pctGood" | 最小信任度
"descriptor" |  |  |  |  |  | "filterExpr" |
"digitalSet" |  |  |  |  |  | "dropBadMode" |
"engUnits" | 工程单位 |  |  |  |  | "countParam1" | 统计类型-计数类型下的两个参数
"excMaxTime" |  |  |  |  |  | "countParam2" | 统计类型-计数类型下的两个参数
"excDev" | 采集过滤误差 |  |  |  |  | "sampleType" | enum，统计采样类型，HD_SAMPLE_TYPE
"tagID" |  |  |  |  |  | "interpOffset" |
"tagType" | tag点数据类型 0： HD3_TAG_TYPE_INT 1： HD3_TAG_TYPE_INT16, 2： HD3_TAG_TYPE_INT32, 3： HD3_TAG_TYPE_FLOAT32, 4： HD3_TAG_TYPE_FLOAT64, 5： HD3_TAG_TYPE_DIGITAL, 6： HD3_TAG_TYPE_STRING, 7： HD3_TAG_TYPE_BLOB |  |  |  |  | "interpPeriod" |
"tagAccess" | int，转二进制，只看高位，表示是否 |  |  |  |  | "conversionType" |
"tagNormalGroup" |  |  |  |  |  | "conversion" |
"tagOwnerGroup" |  |  |  |  |  | "filterFailMode" |
"scan" |  |  |  |  |  | "stCalcPeriod" | 计算周期
"span" |  |  |  |  |  | "reset" |
"minValue" |  |  |  |  |  | "useBadValue" | 使用bad记录
"opcState" |  |  |  |  |  | "stSourceTagName" | 监测点
"tagAvaliable" |  |  |  |  |  |  |

· java调用示例

EiInfo inInfo = new EiInfo();

List conditions = new ArrayList<>();

Map map = new HashMap();

map.put("field","tagName");

map.put("operator","like");

map.put("tagName","tag2");

conditions.add(map);

inInfo.set("conditions", conditions);

inInfo.set("ihdName", "mainTest");

inInfo.set("clientId", "7805711705593430");

inInfo.set("secret", "9B3618F1E7AB15C22E95D9ECDBEF1E27");

inInfo.set(EiConstant.serviceId, "S_BI_HD_0104");

outInfo = XServiceManager.call(inInfo);

· 返回示例

注：单次请求返回条数上限为65535

{

"successList": [

{

"msg":"共有符合条件tag点2个，本次返回2个,

是：

[

{

tagName=tag_digit_002,

tagId=354504,

tagType=5,

tagClass=0,

descriptor=注意上传Tag点前确保采集相关属性对应通过采集器配置工具添加

},

{

tagName=tag10086,

tagId=354604,

tagType=1,

tagClass=0,

descriptor=description100

}

]

",

"dsName": "236test",

"resultList": [

{

"tagName": "tag_digit_002",

"tagId": "354504",

"tagType": "5",

"tagClass": "0",

"descriptor": "注意上传Tag点前确保采集相关属性对应通过采集器配置工具添加"

},

{

"tagName": "tag10086",

"tagId": "354604",

"tagType": "1",

"tagClass": "0",

"descriptor": "description100"

}

]

}

],

"__sys__": {

"msg": "",

"traceId": "0aa19a3ab17370796541120000000d",

"detailMsg": "",

"msgKey": "",

"status": 2

},

"__version__": "2.0",

"failList": [

{

"dsName": "test34",

"failMsg": "查询失败，未找到当前用户！"

}

],

"__blocks__": {}

}

返回参数解析:

名称 | 类型 | 描述
successList | List<Map> | 成功的数据源列表
+dsName | String | 数据源名称
+resultList | List<Map> | tag点列表
++tagName | String | tag名称
++tagId | String | tag标识
++tagType | String | tag类型
++tagClass | String | tag类别
++descriptor | String | 描述
failList | List<Map> | 失败的数据源列表
+dsName | String | 数据源名称
+failMsg | String | 失败的原因
status | Int | 调用接口返回状态（0--所有操作均成功，2--部分操作成功，-1--所有操作均失败）


S_BI_HD_0105 查询tag点属性

Navigation: »No topics above this level«

S_BI_HD_0105 查询tag点属性

 Return to chapter overview

· 接口说明:

当前版本：0.1

接口描述：查询tag点属性

接口服务ID：S_BI_HD_0105

请求服务名：BIHDTagHandle

请求方法：queryTagsProp

· 请求参数示例

HTTP请求：[POST] /service/S_BI_HD_0105

HTTP请求体如下：

{

"tagClass": "common",

"dsTags": {

"236test": {

"clientId": "1662527075199957",

"secret": "4CA22F930ABCEC5882F444FA93856B17",

"tags": [

{

"tagName": "tag10086"

},

{

"tagName": "tag2"

},

{

"tagName": "tag20250107"

}

]

}

}

}

请求参数含义解析:

名称 | 类型 | 是否必需 | 描述
tags | List<Map> | 是 | tag点名列表
test217（dsName） | String | 是 | 数据源名称
tagClass | String | 是 | tag类别
clientId | String | 是 | 客户端id
secret | String | 是 | 密钥

· java调用示例

EiInfo inInfo = new EiInfo();

List<Map> tags = new ArrayList<>();

Map map1 = new HashMap();

map1.put("tagName","tag1");

Map map2= new HashMap();

map2.put("tagName","tag2");

tags.add(map1);

tags.add(map2);

Map map = new HashMap();

map.set("test217", tags);

inInfo.set("clientId","4436611986732923");

inInfo.set("secret","45384AE8472330A8C0843EE969296BEA");

inInfo.set("tagClass","common");

inInfo.set("tags",map);

inInfo.set(EiConstant.serviceId, "S_BI_HD_0105");

outInfo = XServiceManager.call(inInfo);

· 返回参数示例

注：单次请求返回条数上限为65535

{

"successList": [

{

"dsName": "236test",

"successTags": [

{

"archiving": "true",

"changeDate": "1737077751",

"changer": "admin",

"collectorID": "0",

"collectorName": "",

"compDev": "0",

"compMaxTime": "28800",

"compType": "0",

"creationDate": "1733737053",

"creator": "admin",

"dataOrder": "0",

"descriptor": "description100",

"deviceID": "0",

"deviceName": "Kepware.KEPServerEX.V6",

"digitalSet": "DEFAULT",

"engUnits": "",

"excDev": "0",

"excMaxTime": "0",

"extString1": "",

"extString2": "",

"iMVString": "",

"instrumentAddress": "",

"instrumentAddressType": "0",

"minValue": "0",

"opcState": "0",

"param1": "0",

"param2": "0",

"param3": "0",

"param4": "0",

"param5": "0",

"recAccess": "53",

"recNormalGroup": "admin",

"recOwnerGroup": "admin",

"scan": "true",

"scanGroupID": "0",

"scanGroupName": "",

"span": "0",

"tagAccess": "53",

"tagAvaliable": "0",

"tagClass": "0",

"tagID": "354604",

"tagName": "tag10086",

"tagNormalGroup": "admin",

"tagOwnerGroup": "admin",

"tagType": "1"

}

]

}

],

"__sys__": {

"msg": "",

"traceId": "0aa19a3ab17370804016020000002c",

"detailMsg": "",

"msgKey": "",

"status": 2

},

"__version__": "2.0",

"failList": [

{

"noAuthTags": [

"tag20250107"

],

"dsName": "236test",

"notExistTags": [

"tag2"

],

"requestFailedTags": {}

}

],

"__blocks__": {}

}

返回参数解析:

名称 | 类型 | 描述
successList | List<Map> | 成功的数据源列表
+dsName | String | 数据源名称
+successTags | List | 成功点表
failList | List<Map> | 失败数据源列表
+dsName | String | 数据源名称
+noAuthTags | List<String> | 没有权限Tag点列表
+notExistTags | List<String> | 不存在Tag点列表
+requeFailedTags | Map<String, Object> | 请求失败Tag点集合
++msg | String | 请求失败原因整体概述
++tagList | List<Map> | 失败Tag点列表
+++tagName | String | tag点名称
+++errorMsg | String | 单点请求失败具体描述信息


S_BI_HD_0107 tag点绑定（解绑）资源组

Navigation: »No topics above this level«

S_BI_HD_0107 tag点绑定（解绑）资源组

 Return to chapter overview

· 接口说明:

当前版本：0.1

接口描述：tag点绑定（解绑）资源组

接口服务ID：S_BI_HD_0107

请求服务名：BIHDTagHandle

请求方法：tagBindResourceGroup

· 请求参数示例

HTTP请求：[POST] /service/S_BI_HD_0107

HTTP请求体如下：

{

"__sys__": {

"msg": "",

"msgKey": "",

"detailMsg": "",

"status": 0

},

"__version__": "2.0",

"__blocks__": {},

"dsTags": {

"test217": {

"tagNameList":["tag-tesst090401","tag-tesst090402","tag-tesst090403"],

"resourceGroupNameList":["stcgrrr"],

"isBind":1

}

}

}

请求参数含义解析:

名称 | 类型 | 是否必需 | 描述
dsTags | Map<List<Map>> | 是 | tag点信息（第一层map的key为数据源名称）
isBind | Integer | 是 | 操作：1表示绑定， 0表示解绑
resourceGroupNameList | List<String> | 是 | 资源组名称列表
tagNameList | List<String> | 是 | tag点名称列表

· 返回调用示例

{

"__sys__":{

"msg":"数据源test217绑定资源组成功！",

"traceId":"0aa19a43317254296673320000000f",

"detailMsg":"",

"msgKey":"",

"status":0

},

"__version__":"2.0",

"__blocks__":{

}

}


S_BI_HD_0204 查询指定用户对于指定点表的权限信息接口

Navigation: »No topics above this level«

S_BI_HD_0204 查询指定用户对于指定点表的权限信息接口

 Return to chapter overview

· 接口说明:

当前版本：0.1

接口描述：查询指定用户对于指定点表的权限信息

接口服务ID：S_BI_HD_0204

请求服务名：BIHD02

请求方法：queryTagAuth

· 请求参数示例

HTTP请求：[POST] /service/S_BI_HD_0204

HTTP请求体如下：

{

"__sys__": {

"msg": "",

"msgKey": "",

"detailMsg": "",

"status": 0

},

"__version__": "2.0",

"__blocks__": {},

"dsName": "mainTest",

"tagNameList": ["tag0", "tag1"],

"clientId": "8158293047419731",

"secret": "C791B2439C40554D6905A0D7FFD4CCFE"

}

请求参数含义解析:

名称 | 类型 | 是否必需 | 最大长度 | 描述
dsName | String | 是 |  | 数据源名称
tagNameList | List<String> | 是 |  | tag点名称列表
clientId | String | 是 |  | 客户端id
secret | String | 是 |  | 密钥

· java调用示例

EiInfo inInfo = new EiInfo();

inInfo.set("dsName", "mainTest");

inInfo.set("tagNameList", ["tag0","tag1"]);

inInfo.set("clientId", "8158293047419731");

inInfo.set("secret", "C791B2439C40554D6905A0D7FFD4CCFE");

inInfo.set(EiConstant.serviceId, "S_BI_HD_0204");

outInfo = XServiceManager.call(inInfo);

· 返回示例

auth表示请求的点表针对于请求用户所具有的权限类型，其中1-4表述数据操作权限，5-8表示tag点配置修改、删除权限。

1-4表示点的读写，5-8表示点配置的读写

{

"__sys__": {

"msg": "",

"traceId": "0aa197526170703657419500000008",

"detailMsg": "",

"msgKey": "",

"status": 1

},

"auth": {

"tag0": [

2,

7

],

"tag1": [

2,

7

]

},

"__version__": "2.0",

"__blocks__": {}

}


S_BI_HD_0501 查询区间范围内tag点历史信息

Navigation: »No topics above this level«

S_BI_HD_0501 查询区间范围内tag点历史信息

 Return to chapter overview

· 接口说明:

当前版本：0.1

接口描述：查询区间范围内tag点历史信息

接口服务ID：S_BI_HD_0501

请求服务名：BIHDDataHandle

请求方法：queryHistoryDataByRange

· 请求参数示例

HTTP请求：[POST] /service/S_BI_HD_0501

HTTP请求体如下：

{

"__sys__": {

"msg": "",

"msgKey": "",

"detailMsg": "",

"status": 0

},

"__version__": "2.0",

"__blocks__": {},

"startTime": "2025-03-13T15:03:11.931",

"endTime": "2025-03-13T15:53:11.931",

"expectedNum": 3,

"dsTags": {

"test_236": {

"clientId": "4165529151024180",

"secret": "098234FD121688561A5AA3C518ED49A8",

"tagNameList": [

"ihd_opc_opcua_tag_1",

"tag20250100"

]

}

}

}

请求参数含义解析:

名称 | 类型 | 是否必需 | 描述
startTime | String | 是 | 开始时间
endTime | String | 是 | 结束时间
expectedNum | int | 是 | 查询目标条数

层级名称 | 键（Key） | 键（Key）描述
dsTags | 236test | 数据源名称
+236test | clientId | 客户端id
 | secret | 密钥
 | tagNameList | tag点名称列表

· 调用返回示例

{

"successList": [

{

"dsName": "test_236",

"successTags": [

{

"records": [

{

"recordTime": "2025-03-13T15:43:11.931",

"value": "16185",

"quality": "Good"

},

{

"recordTime": "2025-03-13T15:33:11.930",

"value": "13505",

"quality": "Good"

},

{

"recordTime": "2025-03-13T15:23:11.930",

"value": "10827",

"quality": "Good"

}

],

"tagType": 1,

"tagName": "ihd_opc_opcua_tag_1"

}

]

}

],

"__sys__": {

"msg": "",

"traceId": "0aa191d5c17418534481130000005d",

"detailMsg": "",

"msgKey": "",

"status": 2

},

"__version__": "2.0",

"failList": [

{

"noAuthTags": [],

"dsName": "test_236",

"notExistTags": [

"tag20250100"

],

"requestFailedTags": {}

}

],

"__blocks__": {}

}

返回参数说明：

参数名称 | 参数类型 | 参数描述
successList | List<Map> | 注意首先要判断__sys__ 下的status，如果status<0可能没有successList信息 成功数据源列表
+dsName | String | 数据源名称
+successTags | List | 成功点表
++tagName | String | tag点名称
++tagType | Integer | tag点数据类型 0： HD3_TAG_TYPE_INT 1： HD3_TAG_TYPE_INT16, 2： HD3_TAG_TYPE_INT32, 3： HD3_TAG_TYPE_FLOAT32, 4： HD3_TAG_TYPE_FLOAT64, 5： HD3_TAG_TYPE_DIGITAL, 6： HD3_TAG_TYPE_STRING, 7： HD3_TAG_TYPE_BLOB
++records | Map | 记录集合
+++recordTime | String | 记录时间
+++value | String | 记录值
+++quality | String | 记录质量
failList | List<Map> | 注意首先要判断__sys__ 下的status，如果status = 0可能没有failList信息 失败数据源列表
+dsName | String | 数据源名称
+noAuthTags | List<String> | 没有权限Tag点列表
+notExistTags | List<String> | 不存在Tag点列表
+requeFailedTags | Map<String, Object> | 请求失败Tag点集合
++tagList | List<Map> | 失败Tag点列表
+++tagName | String | tag点名称
+++errorMsg | String | 单点请求失败具体描述信息
status | int | 调用接口返回状态 0：查询成功 -1：查询失败 2：查询部分成功
msg | String | 整体接口返回的信息： 1、查询历史信息成功 2、查询历史信息成失败 3、查询历史信息部分成功


S_BI_HD_0502 查询某一时间戳向前或向后x条tag点历史信息

Navigation: »No topics above this level«

S_BI_HD_0502 查询某一时间戳向前或向后x条tag点历史信息

 Return to chapter overview

· 接口说明:

当前版本：0.1

接口描述：查询某一时间戳向前或向后x条tag点历史信息

接口服务ID：S_BI_HD_0502

请求服务名：BIHDDataHandle

请求方法：queryHistoryDataByDir

· 请求参数示例

HTTP请求：[POST] /service/S_BI_HD_0502

HTTP请求体如下：

{

"__sys__": {

"msg": "",

"msgKey": "",

"detailMsg": "",

"status": 0

},

"__version__": "2.0",

"__blocks__": {},

"startTime": "2025-03-13T15:03:11.931",

"model": 1,

"limit": 10,

"dsTags": {

"test_236": {

"clientId": "4165529151024180",

"secret": "098234FD121688561A5AA3C518ED49A8",

"tagNameList": [

"ihd_opc_opcua_tag_1",

"tag20250100"

]

}

}

}

请求参数含义解析:

名称 | 类型 | 是否必需 | 描述
startTime | String | 是 | 开始时间
endTime | String | 是 | 结束时间
model | int | 否 | 查询模式（1表示查询过去时间，0表示查询未来时间）
limit | int | 否 | 限制条数(limit和model需要同时填，没有model则不生效。limit最大不能超过65535)

层级名称 | 键（Key） | 键（Key）描述
dsTags | 236test | 数据源名称
+236test | clientId | 客户端id
 | secret | 密钥
 | tagNameList | tag点名称列表

· 调用返回示例

{

"successList": [

{

"dsName": "test_236",

"successTags": [

{

"records": [

{

"recordTime": "2025-03-13T14:53:11.929",

"value": "2791",

"quality": "Good"

},

{

"recordTime": "2025-03-13T14:43:11.928",

"value": "112",

"quality": "Good"

},

{

"recordTime": "2025-03-13T14:33:11.928",

"value": "-2568",

"quality": "Good"

},

{

"recordTime": "2025-03-13T14:23:11.928",

"value": "-5247",

"quality": "Good"

},

{

"recordTime": "2025-03-13T14:13:11.927",

"value": "-7926",

"quality": "Good"

},

{

"recordTime": "2025-03-13T14:03:11.926",

"value": "-10605",

"quality": "Good"

},

{

"recordTime": "2025-03-13T13:53:11.925",

"value": "-13284",

"quality": "Good"

},

{

"recordTime": "2025-03-13T13:43:11.925",

"value": "-15963",

"quality": "Good"

},

{

"recordTime": "2025-03-13T13:33:11.924",

"value": "-18643",

"quality": "Good"

},

{

"recordTime": "2025-03-13T13:23:11.923",

"value": "-21321",

"quality": "Good"

}

],

"tagType": 1,

"tagName": "ihd_opc_opcua_tag_1"

}

]

}

],

"__sys__": {

"msg": "",

"traceId": "0aa191d5c174185480436500000060",

"detailMsg": "",

"msgKey": "",

"status": 2

},

"__version__": "2.0",

"failList": [

{

"noAuthTags": [],

"dsName": "test_236",

"notExistTags": [

"tag20250100"

],

"requestFailedTags": {}

}

],

"__blocks__": {}

}

返回参数说明：

参数名称 | 参数类型 | 参数描述
successList | List<Map> | 注意首先要判断__sys__ 下的status，如果status<0可能没有successList信息 成功数据源列表
+dsName | String | 数据源名称
+successTags | List | 成功点表
++tagName | String | tag点名称
++tagType | Integer | tag点数据类型 0： HD3_TAG_TYPE_INT 1： HD3_TAG_TYPE_INT16, 2： HD3_TAG_TYPE_INT32, 3： HD3_TAG_TYPE_FLOAT32, 4： HD3_TAG_TYPE_FLOAT64, 5： HD3_TAG_TYPE_DIGITAL, 6： HD3_TAG_TYPE_STRING, 7： HD3_TAG_TYPE_BLOB
++records | Map | 记录集合
+++recordTime | String | 记录时间
+++value | String | 记录值
+++quality | String | 记录质量
failList | List<Map> | 注意首先要判断__sys__ 下的status，如果status =0可能没有failList信息 失败数据源列表
+dsName | String | 数据源名称
+noAuthTags | List<String> | 没有权限Tag点列表
+notExistTags | List<String> | 不存在Tag点列表
+requeFailedTags | Map<String, Object> | 请求失败Tag点集合
++tagList | List<Map> | 失败Tag点列表
+++tagName | String | tag点名称
+++errorMsg | String | 单点请求失败具体描述信息
status | int | 调用接口返回状态 0：查询成功 -1：查询失败 2：查询部分成功
msg | String | 整体接口返回的信息： 1、查询历史信息成功 2、查询历史信息成失败 3、查询历史信息部分成功


sc_add_group

Navigation: »No topics above this level«

sc_add_group

 Return to chapter overview

sc_add_group

Glossary Item Box

函数

在一台服务器上添加一个组

int32 sc_add_group(

HDHANDLE hServer,

const char* szGroupName,

const char* szGroupDesc

);

参数

hServer

[in] 服务器句柄。

szGroupName

[in] 组名称。

szGroupDesc

[in] 组描述。

返回值

添加组成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

举例

sc_add_group

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

printf("login server failed, error code[%d]!\n", nRet);

return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

sprintf(szUserNames[i], "userName_%d", i);

sprintf(szPassWords[i], "passWord", i);

sprintf(szUserDescs[i], "userDesc_%d", i);

nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

return -1;

}

printf("add user successful!\n");

//modify user desc

sprintf(szUserDescs[i], "userDescModified_%d", i);

nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

return -1;

}

printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all user failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secUser);

if (RD_SUCCESS == nRet)

{

printf("query user successful, user name is %s!\n", secUser.szUserName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query user complete!\n");

break;

}

else

{

printf("query user failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

strcpy(hdSecTrust.szUserName, "admin");

nRet = sc_add_trust(hServer, &hdSecTrust);

if (nRet != RD_SUCCESS)

{

printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

return -1;

}

printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all trust failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &hdSecTrust);

if (RD_SUCCESS == nRet)

{

printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query trusts complete!\n");

break;

}

else

{

printf("query trust failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

//add group

sprintf(szGroupNames[i], "groupName_%d", i);

sprintf(szGroupDescs[i], "groupDesc_%d", i);

nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

return -1;

}

printf("add group successful!\n");

//modify group desc

sprintf(szGroupDescs[i], "groupDescModified_%d", i);

nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

return -1;

}

printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all group failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secGroup);

if (RD_SUCCESS == nRet)

{

printf("query group successful, group name is %s!\n", secGroup.szGroupName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group complete!\n");

break;

}

else

{

printf("query group failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("add user to group failed, error code[%d]!\n", nRet);

return -1;

}

printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secUser);

if (RD_SUCCESS == nRet)

{

printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

break;

}

else

{

printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

break;

}

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secGroup);

if (RD_SUCCESS == nRet)

{

printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group of user[name:%s] complete!\n", szUserNames[0]);

break;

}

else

{

printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

break;

}

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("query tag manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("query group manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("query group security item successfully, own group[name:%s], operate group[name:%s]!\n",

secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("modify tag manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("modify group manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

szUserNames[i], szGroupNames[i], nRet);

return -1;

}

printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_user(hServer, szUserNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

return -1;

}

printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_group(hServer, szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

return -1;

}

printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

printf("query current user name failed, error code[%d]!\n", nRet);

return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

printf("modify user[name:admin] password failed, error code[%d]!\n", nRet);

return -1;

}

printf("modify user[name:admin] password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

printf("reset user[name:admin] password failed, error code[%d]!\n", nRet);

return -1;

}

printf("reset user[name:admin] password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_delete_group

sc_modify_group_desc

sc_add_user_to_group

sc_delete_user_from_group


sc_add_trust

Navigation: »No topics above this level«

sc_add_trust

 Return to chapter overview

sc_add_trust

Glossary Item Box

函数

在一台服务器上添加一个信任

int32 sc_add_trust(

HDHANDLE hServer,

const HDSecTrust* pSecTrust

);

参数

hServer

[in] 服务器句柄。

pSecTrust

[in] 信任结构体。

返回值

添加成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

举例

sc_add_trust

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

 printf("login server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(szUserNames[i], "userName_%d", i);

 sprintf(szPassWords[i], "passWord", i);

 sprintf(szUserDescs[i], "userDesc_%d", i);

 nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("add user successful!\n");

 //modify user desc

 sprintf(szUserDescs[i], "userDescModified_%d", i);

 nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

  return -1;

 }

 printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all user failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user successful, user name is %s!\n", secUser.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query user complete!\n");

  break;

 }

 else

 {

  printf("query user failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

 strcpy(hdSecTrust.szUserName, "admin");

 nRet = sc_add_trust(hServer, &hdSecTrust);

 if (nRet != RD_SUCCESS)

 {

  printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

  return -1;

 }

 printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all trust failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &hdSecTrust);

 if (RD_SUCCESS == nRet)

 {

  printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query trusts complete!\n");

  break;

 }

 else

 {

  printf("query trust failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

 //add group

 sprintf(szGroupNames[i], "groupName_%d", i);

 sprintf(szGroupDescs[i], "groupDesc_%d", i);

 nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("add group successful!\n");

 //modify group desc

 sprintf(szGroupDescs[i], "groupDescModified_%d", i);

 nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

  return -1;

 }

 printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all group failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group successful, group name is %s!\n", secGroup.szGroupName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group complete!\n");

  break;

 }

 else

 {

  printf("query group failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user to group failed, error code[%d]!\n", nRet);

  return -1;

 }

 printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

  break;

 }

 else

 {

  printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group of user[name:%s] complete!\n", szUserNames[0]);

  break;

 }

 else

 {

  printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query  group security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

   szUserNames[i], szGroupNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user(hServer, szUserNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_group(hServer, szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

 printf("query current user name failed, error code[%d]!\n", nRet);

 return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

 printf("modify user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("modify user[name:admin]  password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

 printf("reset user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("reset user[name:admin]  password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_add_user

sc_query_all_trusts

sc_query_all_users

sc_delete_trust


sc_add_user

Navigation: »No topics above this level«

sc_add_user

 Return to chapter overview

sc_add_user

Glossary Item Box

函数

在一台服务器上添加一个用户

int32 sc_add_user(

HDHANDLE hServer,

const char* szUserName,

const char* szPassWord,

const char* szUserDesc

);

参数

hServer

[in] 服务器句柄。

szUserName

[in] 用户名称。

szPassWord

[in] 用户密码。

szUserDesc

[in] 用户描述。

返回值

添加用户成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

举例

sc_add_user

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

printf("login server failed, error code[%d]!\n", nRet);

return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

sprintf(szUserNames[i], "userName_%d", i);

sprintf(szPassWords[i], "passWord", i);

sprintf(szUserDescs[i], "userDesc_%d", i);

nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

return -1;

}

printf("add user successful!\n");

//modify user desc

sprintf(szUserDescs[i], "userDescModified_%d", i);

nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

return -1;

}

printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all user failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secUser);

if (RD_SUCCESS == nRet)

{

printf("query user successful, user name is %s!\n", secUser.szUserName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query user complete!\n");

break;

}

else

{

printf("query user failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

strcpy(hdSecTrust.szUserName, "admin");

nRet = sc_add_trust(hServer, &hdSecTrust);

if (nRet != RD_SUCCESS)

{

printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

return -1;

}

printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all trust failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &hdSecTrust);

if (RD_SUCCESS == nRet)

{

printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query trusts complete!\n");

break;

}

else

{

printf("query trust failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

//add group

sprintf(szGroupNames[i], "groupName_%d", i);

sprintf(szGroupDescs[i], "groupDesc_%d", i);

nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

return -1;

}

printf("add group successful!\n");

//modify group desc

sprintf(szGroupDescs[i], "groupDescModified_%d", i);

nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

return -1;

}

printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all group failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secGroup);

if (RD_SUCCESS == nRet)

{

printf("query group successful, group name is %s!\n", secGroup.szGroupName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group complete!\n");

break;

}

else

{

printf("query group failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("add user to group failed, error code[%d]!\n", nRet);

return -1;

}

printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secUser);

if (RD_SUCCESS == nRet)

{

printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

break;

}

else

{

printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

break;

}

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secGroup);

if (RD_SUCCESS == nRet)

{

printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group of user[name:%s] complete!\n", szUserNames[0]);

break;

}

else

{

printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

break;

}

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("query tag manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("query group manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("query group security item successfully, own group[name:%s], operate group[name:%s]!\n",

secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("modify tag manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("modify group manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

szUserNames[i], szGroupNames[i], nRet);

return -1;

}

printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_user(hServer, szUserNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

return -1;

}

printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_group(hServer, szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

return -1;

}

printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

printf("query current user name failed, error code[%d]!\n", nRet);

return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

printf("modify user[name:admin] password failed, error code[%d]!\n", nRet);

return -1;

}

printf("modify user[name:admin] password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

printf("reset user[name:admin] password failed, error code[%d]!\n", nRet);

return -1;

}

printf("reset user[name:admin] password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_delete_user

sc_reset_password

sc_modify_password

sc_modify_user_desc


sc_add_user_to_group

Navigation: »No topics above this level«

sc_add_user_to_group

 Return to chapter overview

sc_add_user_to_group

Glossary Item Box

函数

在一台服务器上添加一个用户到组

int32 sc_add_user_to_group(

HDHANDLE hServer,

const char* szUserName,

const char* szGroupName

);

参数

hServer

[in] 服务器句柄。

szUserName

[in] 用户名称。

szGroupName

[in] 组名称。

返回值

添加用户到组成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

举例

sc_add_user_to_group

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

printf("login server failed, error code[%d]!\n", nRet);

return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

sprintf(szUserNames[i], "userName_%d", i);

sprintf(szPassWords[i], "passWord", i);

sprintf(szUserDescs[i], "userDesc_%d", i);

nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

return -1;

}

printf("add user successful!\n");

//modify user desc

sprintf(szUserDescs[i], "userDescModified_%d", i);

nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

return -1;

}

printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all user failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secUser);

if (RD_SUCCESS == nRet)

{

printf("query user successful, user name is %s!\n", secUser.szUserName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query user complete!\n");

break;

}

else

{

printf("query user failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

strcpy(hdSecTrust.szUserName, "admin");

nRet = sc_add_trust(hServer, &hdSecTrust);

if (nRet != RD_SUCCESS)

{

printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

return -1;

}

printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all trust failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &hdSecTrust);

if (RD_SUCCESS == nRet)

{

printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query trusts complete!\n");

break;

}

else

{

printf("query trust failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

//add group

sprintf(szGroupNames[i], "groupName_%d", i);

sprintf(szGroupDescs[i], "groupDesc_%d", i);

nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

return -1;

}

printf("add group successful!\n");

//modify group desc

sprintf(szGroupDescs[i], "groupDescModified_%d", i);

nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

return -1;

}

printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all group failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secGroup);

if (RD_SUCCESS == nRet)

{

printf("query group successful, group name is %s!\n", secGroup.szGroupName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group complete!\n");

break;

}

else

{

printf("query group failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("add user to group failed, error code[%d]!\n", nRet);

return -1;

}

printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secUser);

if (RD_SUCCESS == nRet)

{

printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

break;

}

else

{

printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

break;

}

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secGroup);

if (RD_SUCCESS == nRet)

{

printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group of user[name:%s] complete!\n", szUserNames[0]);

break;

}

else

{

printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

break;

}

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("query tag manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("query group manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("query group security item successfully, own group[name:%s], operate group[name:%s]!\n",

secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("modify tag manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("modify group manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

szUserNames[i], szGroupNames[i], nRet);

return -1;

}

printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_user(hServer, szUserNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

return -1;

}

printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_group(hServer, szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

return -1;

}

printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

printf("query current user name failed, error code[%d]!\n", nRet);

return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

printf("modify user[name:admin] password failed, error code[%d]!\n", nRet);

return -1;

}

printf("modify user[name:admin] password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

printf("reset user[name:admin] password failed, error code[%d]!\n", nRet);

return -1;

}

printf("reset user[name:admin] password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_add_user

sc_add_group

sc_delete_user_from_group

sc_modify_user_desc

sc_modify_group_desc


扫描组

Navigation: »No topics above this level«

扫描组

 Return to chapter overview

扫描组

Glossary Item Box

《扫描组》中的接口主要包括：

?ct_add_scan_group

?ct_delete_scan_group

?ct_query_scan_group

?ct_query_scan_group_id_by_name

?ct_query_scan_groups_of_device

?ct_modify_scan_group

©2015. All Rights Reserved.


安全数据库管理概述

Navigation: »No topics above this level«

安全数据库管理概述

 Return to chapter overview

安全数据库管理概述

Glossary Item Box

©2015. All Rights Reserved.


sc_delete_group

Navigation: »No topics above this level«

sc_delete_group

 Return to chapter overview

sc_delete_group

Glossary Item Box

函数

在一台服务器上删除一个组

int32 sc_delete_group(

HDHANDLE hServer,

const char* szGroupName

);

参数

hServer

[in] 服务器句柄。

szGroupName

[in] 组名称。

返回值

删除组成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

举例

sc_delete_group

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

printf("login server failed, error code[%d]!\n", nRet);

return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

sprintf(szUserNames[i], "userName_%d", i);

sprintf(szPassWords[i], "passWord", i);

sprintf(szUserDescs[i], "userDesc_%d", i);

nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

return -1;

}

printf("add user successful!\n");

//modify user desc

sprintf(szUserDescs[i], "userDescModified_%d", i);

nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

return -1;

}

printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all user failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secUser);

if (RD_SUCCESS == nRet)

{

printf("query user successful, user name is %s!\n", secUser.szUserName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query user complete!\n");

break;

}

else

{

printf("query user failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

strcpy(hdSecTrust.szUserName, "admin");

nRet = sc_add_trust(hServer, &hdSecTrust);

if (nRet != RD_SUCCESS)

{

printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

return -1;

}

printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all trust failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &hdSecTrust);

if (RD_SUCCESS == nRet)

{

printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query trusts complete!\n");

break;

}

else

{

printf("query trust failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

//add group

sprintf(szGroupNames[i], "groupName_%d", i);

sprintf(szGroupDescs[i], "groupDesc_%d", i);

nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

return -1;

}

printf("add group successful!\n");

//modify group desc

sprintf(szGroupDescs[i], "groupDescModified_%d", i);

nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

return -1;

}

printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all group failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secGroup);

if (RD_SUCCESS == nRet)

{

printf("query group successful, group name is %s!\n", secGroup.szGroupName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group complete!\n");

break;

}

else

{

printf("query group failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("add user to group failed, error code[%d]!\n", nRet);

return -1;

}

printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secUser);

if (RD_SUCCESS == nRet)

{

printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

break;

}

else

{

printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

break;

}

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secGroup);

if (RD_SUCCESS == nRet)

{

printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group of user[name:%s] complete!\n", szUserNames[0]);

break;

}

else

{

printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

break;

}

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("query tag manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("query group manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("query group security item successfully, own group[name:%s], operate group[name:%s]!\n",

secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("modify tag manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("modify group manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

szUserNames[i], szGroupNames[i], nRet);

return -1;

}

printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_user(hServer, szUserNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

return -1;

}

printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_group(hServer, szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

return -1;

}

printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

printf("query current user name failed, error code[%d]!\n", nRet);

return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

printf("modify user[name:admin] password failed, error code[%d]!\n", nRet);

return -1;

}

printf("modify user[name:admin] password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

printf("reset user[name:admin] password failed, error code[%d]!\n", nRet);

return -1;

}

printf("reset user[name:admin] password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_add_group

sc_modify_group_desc

sc_add_user_to_group

sc_delete_user_from_group


sc_delete_trust

Navigation: »No topics above this level«

sc_delete_trust

 Return to chapter overview

sc_delete_trust

Glossary Item Box

函数

在一台服务器上删除一个信任

int32 sc_delete_trust(

HDHANDLE hServer,

const char* szTrustName

);

参数

hServer

[in] 服务器句柄。

szTrustName

[in] 信任名称。

返回值

删除成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

举例

sc_delete_trust

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

 printf("login server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(szUserNames[i], "userName_%d", i);

 sprintf(szPassWords[i], "passWord", i);

 sprintf(szUserDescs[i], "userDesc_%d", i);

 nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("add user successful!\n");

 //modify user desc

 sprintf(szUserDescs[i], "userDescModified_%d", i);

 nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

  return -1;

 }

 printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all user failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user successful, user name is %s!\n", secUser.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query user complete!\n");

  break;

 }

 else

 {

  printf("query user failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

 strcpy(hdSecTrust.szUserName, "admin");

 nRet = sc_add_trust(hServer, &hdSecTrust);

 if (nRet != RD_SUCCESS)

 {

  printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

  return -1;

 }

 printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all trust failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &hdSecTrust);

 if (RD_SUCCESS == nRet)

 {

  printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query trusts complete!\n");

  break;

 }

 else

 {

  printf("query trust failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

 //add group

 sprintf(szGroupNames[i], "groupName_%d", i);

 sprintf(szGroupDescs[i], "groupDesc_%d", i);

 nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("add group successful!\n");

 //modify group desc

 sprintf(szGroupDescs[i], "groupDescModified_%d", i);

 nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

  return -1;

 }

 printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all group failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group successful, group name is %s!\n", secGroup.szGroupName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group complete!\n");

  break;

 }

 else

 {

  printf("query group failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user to group failed, error code[%d]!\n", nRet);

  return -1;

 }

 printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

  break;

 }

 else

 {

  printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group of user[name:%s] complete!\n", szUserNames[0]);

  break;

 }

 else

 {

  printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query  group security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

   szUserNames[i], szGroupNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user(hServer, szUserNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_group(hServer, szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

 printf("query current user name failed, error code[%d]!\n", nRet);

 return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

 printf("modify user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("modify user[name:admin]  password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

 printf("reset user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("reset user[name:admin]  password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_query_all_trusts

sc_add_trust


sc_delete_user

Navigation: »No topics above this level«

sc_delete_user

 Return to chapter overview

sc_delete_user

Glossary Item Box

函数

在一台服务器上删除一个用户

int32 sc_add_user(

HDHANDLE hServer,

const char* szUserName

);

参数

hServer

[in] 服务器句柄。

szUserName

[in] 用户名称。

返回值

删除用户成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

举例

sc_delete_user

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

printf("login server failed, error code[%d]!\n", nRet);

return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

sprintf(szUserNames[i], "userName_%d", i);

sprintf(szPassWords[i], "passWord", i);

sprintf(szUserDescs[i], "userDesc_%d", i);

nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

return -1;

}

printf("add user successful!\n");

//modify user desc

sprintf(szUserDescs[i], "userDescModified_%d", i);

nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

return -1;

}

printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all user failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secUser);

if (RD_SUCCESS == nRet)

{

printf("query user successful, user name is %s!\n", secUser.szUserName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query user complete!\n");

break;

}

else

{

printf("query user failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

strcpy(hdSecTrust.szUserName, "admin");

nRet = sc_add_trust(hServer, &hdSecTrust);

if (nRet != RD_SUCCESS)

{

printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

return -1;

}

printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all trust failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &hdSecTrust);

if (RD_SUCCESS == nRet)

{

printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query trusts complete!\n");

break;

}

else

{

printf("query trust failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

//add group

sprintf(szGroupNames[i], "groupName_%d", i);

sprintf(szGroupDescs[i], "groupDesc_%d", i);

nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

return -1;

}

printf("add group successful!\n");

//modify group desc

sprintf(szGroupDescs[i], "groupDescModified_%d", i);

nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

return -1;

}

printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all group failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secGroup);

if (RD_SUCCESS == nRet)

{

printf("query group successful, group name is %s!\n", secGroup.szGroupName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group complete!\n");

break;

}

else

{

printf("query group failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("add user to group failed, error code[%d]!\n", nRet);

return -1;

}

printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secUser);

if (RD_SUCCESS == nRet)

{

printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

break;

}

else

{

printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

break;

}

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secGroup);

if (RD_SUCCESS == nRet)

{

printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group of user[name:%s] complete!\n", szUserNames[0]);

break;

}

else

{

printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

break;

}

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("query tag manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("query group manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("query group security item successfully, own group[name:%s], operate group[name:%s]!\n",

secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("modify tag manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("modify group manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

szUserNames[i], szGroupNames[i], nRet);

return -1;

}

printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_user(hServer, szUserNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

return -1;

}

printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_group(hServer, szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

return -1;

}

printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

printf("query current user name failed, error code[%d]!\n", nRet);

return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

printf("modify user[name:admin] password failed, error code[%d]!\n", nRet);

return -1;

}

printf("modify user[name:admin] password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

printf("reset user[name:admin] password failed, error code[%d]!\n", nRet);

return -1;

}

printf("reset user[name:admin] password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_add_user

sc_reset_password

sc_modify_password

sc_modify_user_desc


sc_delete_user_from_group

Navigation: »No topics above this level«

sc_delete_user_from_group

 Return to chapter overview

sc_delete_user_from_group

Glossary Item Box

函数

在一台服务器上从组中删除一个用户

int32 sc_delete_user_from_group(

HDHANDLE hServer,

const char* szUserName,

const char* szGroupName

);

参数

hServer

[in] 服务器句柄。

szUserName

[in] 用户名称。

szGroupName

[in] 组名称。

返回值

从组中删除用户成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

举例

sc_delete_user_from_group

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

 printf("login server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(szUserNames[i], "userName_%d", i);

 sprintf(szPassWords[i], "passWord", i);

 sprintf(szUserDescs[i], "userDesc_%d", i);

 nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("add user successful!\n");

 //modify user desc

 sprintf(szUserDescs[i], "userDescModified_%d", i);

 nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

  return -1;

 }

 printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all user failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user successful, user name is %s!\n", secUser.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query user complete!\n");

  break;

 }

 else

 {

  printf("query user failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

 strcpy(hdSecTrust.szUserName, "admin");

 nRet = sc_add_trust(hServer, &hdSecTrust);

 if (nRet != RD_SUCCESS)

 {

  printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

  return -1;

 }

 printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all trust failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &hdSecTrust);

 if (RD_SUCCESS == nRet)

 {

  printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query trusts complete!\n");

  break;

 }

 else

 {

  printf("query trust failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

 //add group

 sprintf(szGroupNames[i], "groupName_%d", i);

 sprintf(szGroupDescs[i], "groupDesc_%d", i);

 nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("add group successful!\n");

 //modify group desc

 sprintf(szGroupDescs[i], "groupDescModified_%d", i);

 nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

  return -1;

 }

 printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all group failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group successful, group name is %s!\n", secGroup.szGroupName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group complete!\n");

  break;

 }

 else

 {

  printf("query group failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user to group failed, error code[%d]!\n", nRet);

  return -1;

 }

 printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

  break;

 }

 else

 {

  printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group of user[name:%s] complete!\n", szUserNames[0]);

  break;

 }

 else

 {

  printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query  group security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

   szUserNames[i], szGroupNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user(hServer, szUserNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_group(hServer, szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

 printf("query current user name failed, error code[%d]!\n", nRet);

 return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

 printf("modify user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("modify user[name:admin]  password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

 printf("reset user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("reset user[name:admin]  password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_add_user

sc_add_group

sc_add_user_to_group

sc_modify_user_desc

sc_modify_group_desc


权限管理接口

Navigation: »No topics above this level«

权限管理接口

 Return to chapter overview

权限管理接口

Glossary Item Box

《权限管理接口》主要内容包括：

用户与组

?sc_login

?sc_add_user

?sc_modify_password

?sc_reset_password

?sc_modify_user_desc

?sc_delete_user

?sc_add_group

?sc_add_user_to_group

?sc_modify_group_desc

?sc_delete_group

?sc_query_all_users

?sc_query_members_of_group

?sc_query_all_groups

?sc_query_current_user_name

?sc_query_groups_of_user

?sc_delete_user_from_group

信任

?sc_add_trust

?sc_delete_trust

?sc_query_all_trusts

数据库安全

?sc_modify_manage_security

?sc_query_manage_security

©2015. All Rights Reserved.


sc_login

Navigation: »No topics above this level«

sc_login

 Return to chapter overview

sc_login

Glossary Item Box

函数

在一台服务器上用户登录

int32 sc_login(

HDHANDLE hServer,

const char* szUserName,

const char* szPassWord

);

参数

hServer

[in] 服务器句柄。

szUserName

[in] 用户名称。

szPassWord

[in] 用户密码。

返回值

用户登录成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

举例

sc_login

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

 printf("login server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(szUserNames[i], "userName_%d", i);

 sprintf(szPassWords[i], "passWord", i);

 sprintf(szUserDescs[i], "userDesc_%d", i);

 nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("add user successful!\n");

 //modify user desc

 sprintf(szUserDescs[i], "userDescModified_%d", i);

 nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

  return -1;

 }

 printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all user failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user successful, user name is %s!\n", secUser.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query user complete!\n");

  break;

 }

 else

 {

  printf("query user failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

 strcpy(hdSecTrust.szUserName, "admin");

 nRet = sc_add_trust(hServer, &hdSecTrust);

 if (nRet != RD_SUCCESS)

 {

  printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

  return -1;

 }

 printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all trust failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &hdSecTrust);

 if (RD_SUCCESS == nRet)

 {

  printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query trusts complete!\n");

  break;

 }

 else

 {

  printf("query trust failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

 //add group

 sprintf(szGroupNames[i], "groupName_%d", i);

 sprintf(szGroupDescs[i], "groupDesc_%d", i);

 nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("add group successful!\n");

 //modify group desc

 sprintf(szGroupDescs[i], "groupDescModified_%d", i);

 nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

  return -1;

 }

 printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all group failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group successful, group name is %s!\n", secGroup.szGroupName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group complete!\n");

  break;

 }

 else

 {

  printf("query group failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user to group failed, error code[%d]!\n", nRet);

  return -1;

 }

 printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

  break;

 }

 else

 {

  printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group of user[name:%s] complete!\n", szUserNames[0]);

  break;

 }

 else

 {

  printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query  group security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

   szUserNames[i], szGroupNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user(hServer, szUserNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_group(hServer, szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

 printf("query current user name failed, error code[%d]!\n", nRet);

 return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

 printf("modify user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("modify user[name:admin]  password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

 printf("reset user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("reset user[name:admin]  password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_add_user

sc_delete_user

sc_modify_password

sc_reset_password

sc_add_group

sc_delete_group


sc_modify_group_desc

Navigation: »No topics above this level«

sc_modify_group_desc

 Return to chapter overview

sc_modify_group_desc

Glossary Item Box

函数

在一台服务器上修改一个组描述

int32 sc_modify_group_desc(

HDHANDLE hServer,

const char* szGroupName,

const char* szNewGroupDesc

);

参数

hServer

[in] 服务器句柄。

szGroupName

[in] 组名称。

szNewGroupDesc

[in] 组新描述。

返回值

修改组描述成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

举例

sc_modify_group_desc

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

printf("login server failed, error code[%d]!\n", nRet);

return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

sprintf(szUserNames[i], "userName_%d", i);

sprintf(szPassWords[i], "passWord", i);

sprintf(szUserDescs[i], "userDesc_%d", i);

nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

return -1;

}

printf("add user successful!\n");

//modify user desc

sprintf(szUserDescs[i], "userDescModified_%d", i);

nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

return -1;

}

printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all user failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secUser);

if (RD_SUCCESS == nRet)

{

printf("query user successful, user name is %s!\n", secUser.szUserName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query user complete!\n");

break;

}

else

{

printf("query user failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

strcpy(hdSecTrust.szUserName, "admin");

nRet = sc_add_trust(hServer, &hdSecTrust);

if (nRet != RD_SUCCESS)

{

printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

return -1;

}

printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all trust failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &hdSecTrust);

if (RD_SUCCESS == nRet)

{

printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query trusts complete!\n");

break;

}

else

{

printf("query trust failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

//add group

sprintf(szGroupNames[i], "groupName_%d", i);

sprintf(szGroupDescs[i], "groupDesc_%d", i);

nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

return -1;

}

printf("add group successful!\n");

//modify group desc

sprintf(szGroupDescs[i], "groupDescModified_%d", i);

nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

return -1;

}

printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all group failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secGroup);

if (RD_SUCCESS == nRet)

{

printf("query group successful, group name is %s!\n", secGroup.szGroupName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group complete!\n");

break;

}

else

{

printf("query group failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("add user to group failed, error code[%d]!\n", nRet);

return -1;

}

printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secUser);

if (RD_SUCCESS == nRet)

{

printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

break;

}

else

{

printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

break;

}

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secGroup);

if (RD_SUCCESS == nRet)

{

printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group of user[name:%s] complete!\n", szUserNames[0]);

break;

}

else

{

printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

break;

}

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("query tag manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("query group manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("query group security item successfully, own group[name:%s], operate group[name:%s]!\n",

secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("modify tag manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("modify group manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

szUserNames[i], szGroupNames[i], nRet);

return -1;

}

printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_user(hServer, szUserNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

return -1;

}

printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_group(hServer, szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

return -1;

}

printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

printf("query current user name failed, error code[%d]!\n", nRet);

return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

printf("modify user[name:admin] password failed, error code[%d]!\n", nRet);

return -1;

}

printf("modify user[name:admin] password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

printf("reset user[name:admin] password failed, error code[%d]!\n", nRet);

return -1;

}

printf("reset user[name:admin] password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_add_group

sc_delete_group

sc_add_user_to_group

sc_delete_user_from_group


sc_modify_manage_security

Navigation: »No topics above this level«

sc_modify_manage_security

 Return to chapter overview

sc_modify_manage_security

Glossary Item Box

函数

在一台服务器上修改安全数据库项

int32 sc_query_manage_security(

HDHANDLE hServer,

int32 nItemType,

HDSecItem* pSecItem

);

参数

hServer

[in] 服务器句柄。

nItemType

[in] 安全数据库项类型。

pSecItem

[out] 安全数据库项结构体。

返回值

修改成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

说明

安全项类型见安全数据库管理概述说明或hdAPI.h。

举例

sc_modify_manage_security

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

 printf("login server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(szUserNames[i], "userName_%d", i);

 sprintf(szPassWords[i], "passWord", i);

 sprintf(szUserDescs[i], "userDesc_%d", i);

 nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("add user successful!\n");

 //modify user desc

 sprintf(szUserDescs[i], "userDescModified_%d", i);

 nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

  return -1;

 }

 printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all user failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user successful, user name is %s!\n", secUser.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query user complete!\n");

  break;

 }

 else

 {

  printf("query user failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

 strcpy(hdSecTrust.szUserName, "admin");

 nRet = sc_add_trust(hServer, &hdSecTrust);

 if (nRet != RD_SUCCESS)

 {

  printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

  return -1;

 }

 printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all trust failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &hdSecTrust);

 if (RD_SUCCESS == nRet)

 {

  printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query trusts complete!\n");

  break;

 }

 else

 {

  printf("query trust failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

 //add group

 sprintf(szGroupNames[i], "groupName_%d", i);

 sprintf(szGroupDescs[i], "groupDesc_%d", i);

 nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("add group successful!\n");

 //modify group desc

 sprintf(szGroupDescs[i], "groupDescModified_%d", i);

 nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

  return -1;

 }

 printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all group failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group successful, group name is %s!\n", secGroup.szGroupName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group complete!\n");

  break;

 }

 else

 {

  printf("query group failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user to group failed, error code[%d]!\n", nRet);

  return -1;

 }

 printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

  break;

 }

 else

 {

  printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group of user[name:%s] complete!\n", szUserNames[0]);

  break;

 }

 else

 {

  printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query  group security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

   szUserNames[i], szGroupNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user(hServer, szUserNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_group(hServer, szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

 printf("query current user name failed, error code[%d]!\n", nRet);

 return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

 printf("modify user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("modify user[name:admin]  password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

 printf("reset user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("reset user[name:admin]  password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_query_manage_security


sc_modify_password

Navigation: »No topics above this level«

sc_modify_password

 Return to chapter overview

sc_modify_password

Glossary Item Box

函数

在一台服务器上修改用户密码

int32 sc_modify_password(

HDHANDLE hServer,

const char* szUserName,

const char* szOldPassWord,

const char* szNewPassWord

);

参数

hServer

[in] 服务器句柄。

szUserName

[in] 用户名称。

szOldPassWord

[in] 用户原密码。

szNewPassWord

[in] 用户新密码。

返回值

修改密码成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

举例

sc_modify_password

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

printf("login server failed, error code[%d]!\n", nRet);

return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

sprintf(szUserNames[i], "userName_%d", i);

sprintf(szPassWords[i], "passWord", i);

sprintf(szUserDescs[i], "userDesc_%d", i);

nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

return -1;

}

printf("add user successful!\n");

//modify user desc

sprintf(szUserDescs[i], "userDescModified_%d", i);

nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

return -1;

}

printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all user failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secUser);

if (RD_SUCCESS == nRet)

{

printf("query user successful, user name is %s!\n", secUser.szUserName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query user complete!\n");

break;

}

else

{

printf("query user failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

strcpy(hdSecTrust.szUserName, "admin");

nRet = sc_add_trust(hServer, &hdSecTrust);

if (nRet != RD_SUCCESS)

{

printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

return -1;

}

printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all trust failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &hdSecTrust);

if (RD_SUCCESS == nRet)

{

printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query trusts complete!\n");

break;

}

else

{

printf("query trust failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

//add group

sprintf(szGroupNames[i], "groupName_%d", i);

sprintf(szGroupDescs[i], "groupDesc_%d", i);

nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

return -1;

}

printf("add group successful!\n");

//modify group desc

sprintf(szGroupDescs[i], "groupDescModified_%d", i);

nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

return -1;

}

printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all group failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secGroup);

if (RD_SUCCESS == nRet)

{

printf("query group successful, group name is %s!\n", secGroup.szGroupName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group complete!\n");

break;

}

else

{

printf("query group failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("add user to group failed, error code[%d]!\n", nRet);

return -1;

}

printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secUser);

if (RD_SUCCESS == nRet)

{

printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

break;

}

else

{

printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

break;

}

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secGroup);

if (RD_SUCCESS == nRet)

{

printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group of user[name:%s] complete!\n", szUserNames[0]);

break;

}

else

{

printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

break;

}

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("query tag manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("query group manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("query group security item successfully, own group[name:%s], operate group[name:%s]!\n",

secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("modify tag manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("modify group manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

szUserNames[i], szGroupNames[i], nRet);

return -1;

}

printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_user(hServer, szUserNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

return -1;

}

printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_group(hServer, szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

return -1;

}

printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

printf("query current user name failed, error code[%d]!\n", nRet);

return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

printf("modify user[name:admin] password failed, error code[%d]!\n", nRet);

return -1;

}

printf("modify user[name:admin] password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

printf("reset user[name:admin] password failed, error code[%d]!\n", nRet);

return -1;

}

printf("reset user[name:admin] password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_add_user

sc_reset_password

sc_delete_user

sc_modify_user_desc


sc_modify_user_desc

Navigation: »No topics above this level«

sc_modify_user_desc

 Return to chapter overview

sc_modify_user_desc

Glossary Item Box

函数

在一台服务器上修改一个用户描述

int32 sc_modify_user_desc(

HDHANDLE hServer,

const char* szUserName,

const char* szNewUserDesc

);

参数

hServer

[in] 服务器句柄。

szUserName

[in] 用户名称。

szNewUserDesc

[in] 用户新描述。

返回值

修改用户描述成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

举例

sc_modify_user_desc

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

printf("login server failed, error code[%d]!\n", nRet);

return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

sprintf(szUserNames[i], "userName_%d", i);

sprintf(szPassWords[i], "passWord", i);

sprintf(szUserDescs[i], "userDesc_%d", i);

nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

return -1;

}

printf("add user successful!\n");

//modify user desc

sprintf(szUserDescs[i], "userDescModified_%d", i);

nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

return -1;

}

printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all user failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secUser);

if (RD_SUCCESS == nRet)

{

printf("query user successful, user name is %s!\n", secUser.szUserName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query user complete!\n");

break;

}

else

{

printf("query user failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

strcpy(hdSecTrust.szUserName, "admin");

nRet = sc_add_trust(hServer, &hdSecTrust);

if (nRet != RD_SUCCESS)

{

printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

return -1;

}

printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all trust failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &hdSecTrust);

if (RD_SUCCESS == nRet)

{

printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query trusts complete!\n");

break;

}

else

{

printf("query trust failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

//add group

sprintf(szGroupNames[i], "groupName_%d", i);

sprintf(szGroupDescs[i], "groupDesc_%d", i);

nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

return -1;

}

printf("add group successful!\n");

//modify group desc

sprintf(szGroupDescs[i], "groupDescModified_%d", i);

nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

return -1;

}

printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all group failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secGroup);

if (RD_SUCCESS == nRet)

{

printf("query group successful, group name is %s!\n", secGroup.szGroupName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group complete!\n");

break;

}

else

{

printf("query group failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("add user to group failed, error code[%d]!\n", nRet);

return -1;

}

printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secUser);

if (RD_SUCCESS == nRet)

{

printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

break;

}

else

{

printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

break;

}

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secGroup);

if (RD_SUCCESS == nRet)

{

printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group of user[name:%s] complete!\n", szUserNames[0]);

break;

}

else

{

printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

break;

}

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("query tag manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("query group manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("query group security item successfully, own group[name:%s], operate group[name:%s]!\n",

secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("modify tag manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("modify group manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

szUserNames[i], szGroupNames[i], nRet);

return -1;

}

printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_user(hServer, szUserNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

return -1;

}

printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_group(hServer, szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

return -1;

}

printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

printf("query current user name failed, error code[%d]!\n", nRet);

return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

printf("modify user[name:admin] password failed, error code[%d]!\n", nRet);

return -1;

}

printf("modify user[name:admin] password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

printf("reset user[name:admin] password failed, error code[%d]!\n", nRet);

return -1;

}

printf("reset user[name:admin] password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_add_user

sc_modify_password

sc_reset_password

sc_delete_user


sc_query_all_groups

Navigation: »No topics above this level«

sc_query_all_groups

 Return to chapter overview

sc_query_all_groups

Glossary Item Box

函数

在一台服务器上查询所有组

int32 sc_query_all_groups(

HDHANDLE hServer,

HDHANDLE* pHIter

);

参数

hServer

[in] 服务器句柄。

pHIter

[out] 查询迭代器。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

说明

调用该接口成功后会获得一个查询迭代器的句柄，然后调用ut_get_item_step接口，传入迭代器句柄和分配的内存空间(HDSecGroup*)，返回RD_SUCCESS就可以获得第一个组，再调用ut_get_item_step返回RD_SUCCESS就可以获得第二个组。如此循环的查询直到调用ut_get_item_step返回错误码为EC_HD_API_QUERY_END表明所有的组都查询完毕了。查询完毕后调用ut_free_iterator方法来释放迭代器。

举例

sc_query_all_groups

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

 printf("login server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(szUserNames[i], "userName_%d", i);

 sprintf(szPassWords[i], "passWord", i);

 sprintf(szUserDescs[i], "userDesc_%d", i);

 nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("add user successful!\n");

 //modify user desc

 sprintf(szUserDescs[i], "userDescModified_%d", i);

 nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

  return -1;

 }

 printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all user failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user successful, user name is %s!\n", secUser.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query user complete!\n");

  break;

 }

 else

 {

  printf("query user failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

 strcpy(hdSecTrust.szUserName, "admin");

 nRet = sc_add_trust(hServer, &hdSecTrust);

 if (nRet != RD_SUCCESS)

 {

  printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

  return -1;

 }

 printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all trust failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &hdSecTrust);

 if (RD_SUCCESS == nRet)

 {

  printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query trusts complete!\n");

  break;

 }

 else

 {

  printf("query trust failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

 //add group

 sprintf(szGroupNames[i], "groupName_%d", i);

 sprintf(szGroupDescs[i], "groupDesc_%d", i);

 nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("add group successful!\n");

 //modify group desc

 sprintf(szGroupDescs[i], "groupDescModified_%d", i);

 nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

  return -1;

 }

 printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all group failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group successful, group name is %s!\n", secGroup.szGroupName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group complete!\n");

  break;

 }

 else

 {

  printf("query group failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user to group failed, error code[%d]!\n", nRet);

  return -1;

 }

 printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

  break;

 }

 else

 {

  printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group of user[name:%s] complete!\n", szUserNames[0]);

  break;

 }

 else

 {

  printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query  group security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

   szUserNames[i], szGroupNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user(hServer, szUserNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_group(hServer, szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

 printf("query current user name failed, error code[%d]!\n", nRet);

 return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

 printf("modify user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("modify user[name:admin]  password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

 printf("reset user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("reset user[name:admin]  password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_add_user

sc_add_group

sc_delete_group

sc_query_groups_of_user

sc_add_user_to_group


sc_query_all_trusts

Navigation: »No topics above this level«

sc_query_all_trusts

 Return to chapter overview

sc_query_all_trusts

Glossary Item Box

函数

在一台服务器上查询所有信任

int32 sc_query_all_trusts(

HDHANDLE hServer,

HDHANDLE* pHIter

);

参数

hServer

[in] 服务器句柄。

pHIter

[out] 查询迭代器。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

说明

调用该接口成功后会获得一个查询迭代器的句柄，然后调用ut_get_item_step接口，传入迭代器句柄和分配的内存空间(HDSecTrust*)，返回RD_SUCCESS就可以获得第一个信任，再调用ut_get_item_step返回RD_SUCCESS就可以获得第二个信任。如此循环的查询直到调用ut_get_item_step返回错误码为EC_HD_API_QUERY_END表明所有的信任都查询完毕了。查询完毕后调用ut_free_iterator方法来释放迭代器。

举例

sc_query_all_trusts

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

 printf("login server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(szUserNames[i], "userName_%d", i);

 sprintf(szPassWords[i], "passWord", i);

 sprintf(szUserDescs[i], "userDesc_%d", i);

 nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("add user successful!\n");

 //modify user desc

 sprintf(szUserDescs[i], "userDescModified_%d", i);

 nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

  return -1;

 }

 printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all user failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user successful, user name is %s!\n", secUser.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query user complete!\n");

  break;

 }

 else

 {

  printf("query user failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

 strcpy(hdSecTrust.szUserName, "admin");

 nRet = sc_add_trust(hServer, &hdSecTrust);

 if (nRet != RD_SUCCESS)

 {

  printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

  return -1;

 }

 printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all trust failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &hdSecTrust);

 if (RD_SUCCESS == nRet)

 {

  printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query trusts complete!\n");

  break;

 }

 else

 {

  printf("query trust failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

 //add group

 sprintf(szGroupNames[i], "groupName_%d", i);

 sprintf(szGroupDescs[i], "groupDesc_%d", i);

 nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("add group successful!\n");

 //modify group desc

 sprintf(szGroupDescs[i], "groupDescModified_%d", i);

 nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

  return -1;

 }

 printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all group failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group successful, group name is %s!\n", secGroup.szGroupName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group complete!\n");

  break;

 }

 else

 {

  printf("query group failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user to group failed, error code[%d]!\n", nRet);

  return -1;

 }

 printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

  break;

 }

 else

 {

  printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group of user[name:%s] complete!\n", szUserNames[0]);

  break;

 }

 else

 {

  printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query  group security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

   szUserNames[i], szGroupNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user(hServer, szUserNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_group(hServer, szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

 printf("query current user name failed, error code[%d]!\n", nRet);

 return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

 printf("modify user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("modify user[name:admin]  password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

 printf("reset user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("reset user[name:admin]  password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_add_trust

sc_delete_trust


sc_query_all_users

Navigation: »No topics above this level«

sc_query_all_users

 Return to chapter overview

sc_query_all_users

Glossary Item Box

函数

在一台服务器上查询所有用户

int32 sc_query_all_users(

HDHANDLE hServer,

HDHANDLE* pHIter

);

参数

hServer

[in] 服务器句柄。

pHIter

[out] 查询迭代器。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

说明

调用该接口成功后会获得一个查询迭代器的句柄，然后调用ut_get_item_step接口，传入迭代器句柄和分配的内存空间(HDSecUser*)，返回RD_SUCCESS就可以获得第一个用户，再调用ut_get_item_step返回RD_SUCCESS就可以获得第二个用户。如此循环的查询直到调用ut_get_item_step返回错误码为EC_HD_API_QUERY_END表明所有的用户都查询完毕了。查询完毕后调用ut_free_iterator方法来释放迭代器。

举例

sc_query_all_users

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

 printf("login server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(szUserNames[i], "userName_%d", i);

 sprintf(szPassWords[i], "passWord", i);

 sprintf(szUserDescs[i], "userDesc_%d", i);

 nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("add user successful!\n");

 //modify user desc

 sprintf(szUserDescs[i], "userDescModified_%d", i);

 nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

  return -1;

 }

 printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all user failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user successful, user name is %s!\n", secUser.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query user complete!\n");

  break;

 }

 else

 {

  printf("query user failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

 //add group

 sprintf(szGroupNames[i], "groupName_%d", i);

 sprintf(szGroupDescs[i], "groupDesc_%d", i);

 nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("add group successful!\n");

 //modify group desc

 sprintf(szGroupDescs[i], "groupDescModified_%d", i);

 nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

  return -1;

 }

 printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all group failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group successful, group name is %s!\n", secGroup.szGroupName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group complete!\n");

  break;

 }

 else

 {

  printf("query group failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user to group failed, error code[%d]!\n", nRet);

  return -1;

 }

 printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

  break;

 }

 else

 {

  printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group of user[name:%s] complete!\n", szUserNames[0]);

  break;

 }

 else

 {

  printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query  group security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

   szUserNames[i], szGroupNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user(hServer, szUserNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_group(hServer, szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

 printf("query current user name failed, error code[%d]!\n", nRet);

 return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

 printf("modify user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("modify user[name:admin]  password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

 printf("reset user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("reset user[name:admin]  password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_add_user

sc_delete_user

sc_query_members_of_group

sc_modify_user_desc


sc_query_current_user_name

Navigation: »No topics above this level«

sc_query_current_user_name

 Return to chapter overview

sc_query_current_user_name

Glossary Item Box

函数

在一台服务器上查询当前登录的用户

int32 sc_query_current_user_name(

HDHANDLE hServer,

char szUserName[HD_LEN_SEC_USER_NAME]

);

参数

hServer

[in] 服务器句柄。

szUserName

[out] 用户名称。

参数

hServer

[in] 服务器句柄。

szUserName

[out] 用户名称。

返回值

查询成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

说明

待查询的用户名所占的内存由外部分配后调用API。

举例

sc_query_current_user_name

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

 printf("login server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(szUserNames[i], "userName_%d", i);

 sprintf(szPassWords[i], "passWord", i);

 sprintf(szUserDescs[i], "userDesc_%d", i);

 nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("add user successful!\n");

 //modify user desc

 sprintf(szUserDescs[i], "userDescModified_%d", i);

 nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

  return -1;

 }

 printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all user failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user successful, user name is %s!\n", secUser.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query user complete!\n");

  break;

 }

 else

 {

  printf("query user failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

 strcpy(hdSecTrust.szUserName, "admin");

 nRet = sc_add_trust(hServer, &hdSecTrust);

 if (nRet != RD_SUCCESS)

 {

  printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

  return -1;

 }

 printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all trust failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &hdSecTrust);

 if (RD_SUCCESS == nRet)

 {

  printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query trusts complete!\n");

  break;

 }

 else

 {

  printf("query trust failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

 //add group

 sprintf(szGroupNames[i], "groupName_%d", i);

 sprintf(szGroupDescs[i], "groupDesc_%d", i);

 nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("add group successful!\n");

 //modify group desc

 sprintf(szGroupDescs[i], "groupDescModified_%d", i);

 nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

  return -1;

 }

 printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all group failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group successful, group name is %s!\n", secGroup.szGroupName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group complete!\n");

  break;

 }

 else

 {

  printf("query group failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user to group failed, error code[%d]!\n", nRet);

  return -1;

 }

 printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

  break;

 }

 else

 {

  printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group of user[name:%s] complete!\n", szUserNames[0]);

  break;

 }

 else

 {

  printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query  group security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

   szUserNames[i], szGroupNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user(hServer, szUserNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_group(hServer, szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

 printf("query current user name failed, error code[%d]!\n", nRet);

 return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

 printf("modify user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("modify user[name:admin]  password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

 printf("reset user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("reset user[name:admin]  password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_add_user

sc_delete_user

sc_modify_password

sc_reset_password


sc_query_groups_of_user

Navigation: »No topics above this level«

sc_query_groups_of_user

 Return to chapter overview

sc_query_groups_of_user

Glossary Item Box

函数

在一台服务器上查询一个用户所隶属于的所有组

int32 sc_query_groups_of_user(

HDHANDLE hServer,

const char* szUserName,

HDHANDLE* pHIter

);

参数

hServer

[in] 服务器句柄。

szUserName

[in] 用户名称。

pHIter

[out] 查询迭代器。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

说明

调用该接口成功后会获得一个查询迭代器的句柄，然后调用ut_get_item_step接口，传入迭代器句柄和分配的内存空间(HDSecGroup*)，返回RD_SUCCESS就可以获得第一个组，再调用ut_get_item_step返回RD_SUCCESS就可以获得第二个组。如此循环的查询直到调用ut_get_item_step返回错误码为EC_HD_API_QUERY_END表明所有的组都查询完毕了。查询完毕后调用ut_free_iterator方法来释放迭代器。

举例

sc_query_groups_of_user

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

 printf("login server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(szUserNames[i], "userName_%d", i);

 sprintf(szPassWords[i], "passWord", i);

 sprintf(szUserDescs[i], "userDesc_%d", i);

 nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("add user successful!\n");

 //modify user desc

 sprintf(szUserDescs[i], "userDescModified_%d", i);

 nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

  return -1;

 }

 printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all user failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user successful, user name is %s!\n", secUser.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query user complete!\n");

  break;

 }

 else

 {

  printf("query user failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

 strcpy(hdSecTrust.szUserName, "admin");

 nRet = sc_add_trust(hServer, &hdSecTrust);

 if (nRet != RD_SUCCESS)

 {

  printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

  return -1;

 }

 printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all trust failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &hdSecTrust);

 if (RD_SUCCESS == nRet)

 {

  printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query trusts complete!\n");

  break;

 }

 else

 {

  printf("query trust failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

 //add group

 sprintf(szGroupNames[i], "groupName_%d", i);

 sprintf(szGroupDescs[i], "groupDesc_%d", i);

 nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("add group successful!\n");

 //modify group desc

 sprintf(szGroupDescs[i], "groupDescModified_%d", i);

 nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

  return -1;

 }

 printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all group failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group successful, group name is %s!\n", secGroup.szGroupName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group complete!\n");

  break;

 }

 else

 {

  printf("query group failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user to group failed, error code[%d]!\n", nRet);

  return -1;

 }

 printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

  break;

 }

 else

 {

  printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group of user[name:%s] complete!\n", szUserNames[0]);

  break;

 }

 else

 {

  printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query  group security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

   szUserNames[i], szGroupNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user(hServer, szUserNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_group(hServer, szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

 printf("query current user name failed, error code[%d]!\n", nRet);

 return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

 printf("modify user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("modify user[name:admin]  password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

 printf("reset user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("reset user[name:admin]  password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_add_user

sc_add_group

sc_delete_group

sc_add_user_to_group

sc_delete_user_from_group

sc_query_all_groups


sc_query_manage_security

Navigation: »No topics above this level«

sc_query_manage_security

 Return to chapter overview

sc_query_manage_security

Glossary Item Box

函数

在一台服务器上查询安全数据库项

int32 sc_query_manage_security(

HDHANDLE hServer,

int32 nItemType,

HDSecItem* pSecItem

);

参数

hServer

[in] 服务器句柄。

nItemType

[in] 安全数据库项类型。

pSecItem

[out] 安全数据库项结构体。

返回值

添加成功，返回RD_SUCCESS。添加返回其它错误码，见error_code.h

说明

待查询的安全项所占的内存由外部分配后调用API，安全项类型见安全数据库管理概述说明或hdAPI.h。

举例

sc_query_manage_security

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

 printf("login server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(szUserNames[i], "userName_%d", i);

 sprintf(szPassWords[i], "passWord", i);

 sprintf(szUserDescs[i], "userDesc_%d", i);

 nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("add user successful!\n");

 //modify user desc

 sprintf(szUserDescs[i], "userDescModified_%d", i);

 nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

  return -1;

 }

 printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all user failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user successful, user name is %s!\n", secUser.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query user complete!\n");

  break;

 }

 else

 {

  printf("query user failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

 strcpy(hdSecTrust.szUserName, "admin");

 nRet = sc_add_trust(hServer, &hdSecTrust);

 if (nRet != RD_SUCCESS)

 {

  printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

  return -1;

 }

 printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all trust failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &hdSecTrust);

 if (RD_SUCCESS == nRet)

 {

  printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query trusts complete!\n");

  break;

 }

 else

 {

  printf("query trust failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

 //add group

 sprintf(szGroupNames[i], "groupName_%d", i);

 sprintf(szGroupDescs[i], "groupDesc_%d", i);

 nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("add group successful!\n");

 //modify group desc

 sprintf(szGroupDescs[i], "groupDescModified_%d", i);

 nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

  return -1;

 }

 printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all group failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group successful, group name is %s!\n", secGroup.szGroupName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group complete!\n");

  break;

 }

 else

 {

  printf("query group failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user to group failed, error code[%d]!\n", nRet);

  return -1;

 }

 printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

  break;

 }

 else

 {

  printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group of user[name:%s] complete!\n", szUserNames[0]);

  break;

 }

 else

 {

  printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query  group security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

   szUserNames[i], szGroupNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user(hServer, szUserNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_group(hServer, szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

 printf("query current user name failed, error code[%d]!\n", nRet);

 return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

 printf("modify user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("modify user[name:admin]  password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

 printf("reset user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("reset user[name:admin]  password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_modify_manage_security


sc_query_members_of_group

Navigation: »No topics above this level«

sc_query_members_of_group

 Return to chapter overview

sc_query_members_of_group

Glossary Item Box

函数

在一台服务器上查询一个组包含的所有用户

int32 sc_query_members_of_group(

HDHANDLE hServer,

const char* szGroupName,

HDHANDLE* pHIter

);

参数

hServer

[in] 服务器句柄。

szGroupName

[in] 组名称。

pHIter

[out] 查询迭代器。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

说明

调用该接口成功后会获得一个查询迭代器的句柄，然后调用ut_get_item_step接口，传入迭代器句柄和分配的内存空间(HDSecUser*)，返回RD_SUCCESS就可以获得第一个用户，再调用ut_get_item_step返回RD_SUCCESS就可以获得第二个用户。如此循环的查询直到调用ut_get_item_step返回错误码为EC_HD_API_QUERY_END表明所有的用户都查询完毕了。查询完毕后调用ut_free_iterator方法来释放迭代器。

举例

sc_query_members_of_group

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

 printf("login server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(szUserNames[i], "userName_%d", i);

 sprintf(szPassWords[i], "passWord", i);

 sprintf(szUserDescs[i], "userDesc_%d", i);

 nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("add user successful!\n");

 //modify user desc

 sprintf(szUserDescs[i], "userDescModified_%d", i);

 nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

  return -1;

 }

 printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all user failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user successful, user name is %s!\n", secUser.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query user complete!\n");

  break;

 }

 else

 {

  printf("query user failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

 sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

 sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

 strcpy(hdSecTrust.szUserName, "admin");

 nRet = sc_add_trust(hServer, &hdSecTrust);

 if (nRet != RD_SUCCESS)

 {

  printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

  return -1;

 }

 printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all trust failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &hdSecTrust);

 if (RD_SUCCESS == nRet)

 {

  printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

   hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query trusts complete!\n");

  break;

 }

 else

 {

  printf("query trust failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

 //add group

 sprintf(szGroupNames[i], "groupName_%d", i);

 sprintf(szGroupDescs[i], "groupDesc_%d", i);

 nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("add group successful!\n");

 //modify group desc

 sprintf(szGroupDescs[i], "groupDescModified_%d", i);

 nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

  return -1;

 }

 printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

 printf("query all group failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group successful, group name is %s!\n", secGroup.szGroupName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group complete!\n");

  break;

 }

 else

 {

  printf("query group failed, error code [%d]!\n", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("add user to group failed, error code[%d]!\n", nRet);

  return -1;

 }

 printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secUser);

 if (RD_SUCCESS == nRet)

 {

  printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

  break;

 }

 else

 {

  printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &secGroup);

 if (RD_SUCCESS == nRet)

 {

  printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group of user[name:%s] complete!\n", szUserNames[0]);

  break;

 }

 else

 {

  printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

  break;

 }

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("query group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query  group security item successfully, own group[name:%s], operate group[name:%s]!\n",

 secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify tag manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

 printf("modify group manage security failed, error code[%d]!\n",  nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

   szUserNames[i], szGroupNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_user(hServer, szUserNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

  return -1;

 }

 printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

 nRet = sc_delete_group(hServer, szGroupNames[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

  return -1;

 }

 printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

 printf("query current user name failed, error code[%d]!\n", nRet);

 return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

 printf("modify user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("modify user[name:admin]  password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

 printf("reset user[name:admin]  password failed, error code[%d]!\n", nRet);

 return -1;

}

printf("reset user[name:admin]  password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_add_user

sc_add_group

sc_add_user_to_group

sc_delete_user_from_group

sc_query_all_users


sc_reset_password

Navigation: »No topics above this level«

sc_reset_password

 Return to chapter overview

sc_reset_password

Glossary Item Box

函数

在一台服务器上重置用户密码

int32 sc_reset_password(

HDHANDLE hServer,

const char* szUserName,

const char* szNewPassWord

);

参数

hServer

[in] 服务器句柄。

szUserName

[in] 用户名称。

szNewPassWord

[in] 用户新密码。

说明

重置密码功能需要特定的权限，具体由安全数据库管理概述设置。

举例

sc_reset_password

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

HDSecUser secUser;

HDSecGroup secGroup;

HDSecItem secItem;

int32 nSecurityItemType = 0;

int32 i = 0;

HDHANDLE hIter = NULL;

const int32 USER_COUNT = 3;

const int32 GROUP_COUNT = 3;

const int32 TRUST_COUNT = 3;

char szUserNames[USER_COUNT][HD_LEN_USER_NAME];

char szPassWords[USER_COUNT][HD_LEN_SEC_PASSWORD];

char szUserDescs[USER_COUNT][HD_LEN_SEC_USER_DESC];

char szGroupNames[GROUP_COUNT][HD_LEN_SEC_GROUP_NAME];

char szGroupDescs[GROUP_COUNT][HD_LEN_SEC_GROUP_DESC];

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//login

nRet = sc_login(hServer, "admin" , "admin");

if (nRet != RD_SUCCESS)

{

printf("login server failed, error code[%d]!\n", nRet);

return -1;

}

printf("login server successful!\n");

//add users, modify user desc

for (i = 0; i < USER_COUNT; i ++)

{

sprintf(szUserNames[i], "userName_%d", i);

sprintf(szPassWords[i], "passWord", i);

sprintf(szUserDescs[i], "userDesc_%d", i);

nRet = sc_add_user(hServer, szUserNames[i], szPassWords[i], szUserDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("add user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

return -1;

}

printf("add user successful!\n");

//modify user desc

sprintf(szUserDescs[i], "userDescModified_%d", i);

nRet = sc_modify_user_desc(hServer, szUserNames[i], szUserDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("modify user[name:%s] desc[%s] failed, error code[%d]!\n", szUserNames[i], szUserDescs[i], nRet);

return -1;

}

printf("modify user desc successful!\n");

}

//query all user

nRet = sc_query_all_users(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all user failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secUser);

if (RD_SUCCESS == nRet)

{

printf("query user successful, user name is %s!\n", secUser.szUserName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query user complete!\n");

break;

}

else

{

printf("query user failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add trust, delete trust

HDSecTrust hdSecTrust;

for (i = 0; i < USER_COUNT; i ++)

{

sprintf(hdSecTrust.szStartIp, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdSecTrust.szEndIp, "%d.%d.%d.%d", i, i, i, i);

sprintf(hdSecTrust.szTrustName, "%d.%d.%d.%d", i, i, i, i);

strcpy(hdSecTrust.szUserName, "admin");

nRet = sc_add_trust(hServer, &hdSecTrust);

if (nRet != RD_SUCCESS)

{

printf("add trust[name:%s] failed, start ip[%s] end ip[%s] user name[%s], error code[%d]!\n",

hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName, nRet);

return -1;

}

printf("add trust successful successful!\n");

}

//query all trust

nRet = sc_query_all_trusts(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all trust failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &hdSecTrust);

if (RD_SUCCESS == nRet)

{

printf("query trust successful, trust name[%s] start ip[%s] end ip[%s] user name[%s]!\n",

hdSecTrust.szTrustName, hdSecTrust.szStartIp, hdSecTrust.szEndIp, hdSecTrust.szUserName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query trusts complete!\n");

break;

}

else

{

printf("query trust failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add group , modify group desc

for (i = 0; i < GROUP_COUNT; i ++)

{

//add group

sprintf(szGroupNames[i], "groupName_%d", i);

sprintf(szGroupDescs[i], "groupDesc_%d", i);

nRet = sc_add_group(hServer, szGroupNames[i], szGroupDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("add group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

return -1;

}

printf("add group successful!\n");

//modify group desc

sprintf(szGroupDescs[i], "groupDescModified_%d", i);

nRet = sc_modify_group_desc(hServer, szGroupNames[i], szGroupDescs[i]);

if (nRet != RD_SUCCESS)

{

printf("modify group[name:%s] desc[%s] failed, error code[%d]!\n", szGroupNames[i], szGroupDescs[i], nRet);

return -1;

}

printf("modify group desc successful!\n");

}

//query all group

nRet = sc_query_all_groups(hServer,&hIter);

if (nRet != RD_SUCCESS)

{

printf("query all group failed, error code [%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secGroup);

if (RD_SUCCESS == nRet)

{

printf("query group successful, group name is %s!\n", secGroup.szGroupName);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group complete!\n");

break;

}

else

{

printf("query group failed, error code [%d]!\n", nRet);

break;

}

}

ut_free_iterator(hIter);

//add users to group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_add_user_to_group(hServer, szUserNames[i], szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("add user to group failed, error code[%d]!\n", nRet);

return -1;

}

printf("add user to group successful!\n");

}

//query all members of group

nRet = sc_query_members_of_group(hServer, szGroupNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

printf("query user of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secUser);

if (RD_SUCCESS == nRet)

{

printf("query user[name:%s] of group[name:%s] succeed!\n", secUser.szUserName, szGroupNames[0]);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query member of group[name:%s] complete!\n", szGroupNames[0]);

break;

}

else

{

printf("query member of group[name:%s] failed, error code[%d]!\n", szGroupNames[0], nRet);

break;

}

}

ut_free_iterator(hIter);

//query all group of user

nRet = sc_query_groups_of_user(hServer, szUserNames[0], &hIter);

if (nRet != RD_SUCCESS)

{

printf("query groups of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

return -1;

}

while (true)

{

nRet = ut_get_item_step(hIter, &secGroup);

if (RD_SUCCESS == nRet)

{

printf("query group[name:%s] of user[name:%s] succeed!\n", secGroup.szGroupName, szUserNames[0]);

}

else if (EC_HD_API_QUERY_END == nRet)

{

printf("query group of user[name:%s] complete!\n", szUserNames[0]);

break;

}

else

{

printf("query group of user[name:%s] failed, error code[%d]!\n", szUserNames[0], nRet);

break;

}

}

ut_free_iterator(hIter);

//query tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_TAG;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("query tag manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("query tag security item successfully, own group[name:%s], operate group[name:%s]!\n",

secItem.szOwnGroupName, secItem.szOperateGroupName);

//query group manage security

nSecurityItemType = GLOBAL_SC_ITEM_QUERY_GROUP;

nRet = sc_query_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("query group manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("query group security item successfully, own group[name:%s], operate group[name:%s]!\n",

secItem.szOwnGroupName, secItem.szOperateGroupName);

//modify tag manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_TAG;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("modify tag manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify Tag security item successfully!\n");

//modify group manage security

nSecurityItemType = GLOBAL_SC_ITEM_MODIFY_GROUP;

strcpy(secItem.szOwnGroupName, szGroupNames[0]);

strcpy(secItem.szOperateGroupName, szGroupNames[0]);

secItem.nSecurity = 53;

nRet = sc_modify_manage_security(hServer, nSecurityItemType, &secItem);

if (nRet != RD_SUCCESS)

{

printf("modify group manage security failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("modify Group security item successfully!\n");

// delete user from group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_user_from_group(hServer, szUserNames[i], szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete user[name:%s] from group[name:%s] failed, error code[%d]!\n",

szUserNames[i], szGroupNames[i], nRet);

return -1;

}

printf("delete user[name:%s] from group[name:%s] successful!\n", szUserNames[i], szGroupNames[i]);

}

//delete user

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_user(hServer, szUserNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete user[name:%s] failed, error code[%d]!\n", szUserNames[i], nRet);

return -1;

}

printf("delete user[name:%s] successful!\n", szUserNames[i]);

}

//delete group

for (i = 0; i < USER_COUNT; i ++)

{

nRet = sc_delete_group(hServer, szGroupNames[i]);

if (nRet != RD_SUCCESS)

{

printf("delete group[name:%s] failed, error code[%d]!\n", szGroupNames[i], nRet);

return -1;

}

printf("delete group[name:%s] successful!\n", szGroupNames[i]);

}

//get current user name

char szCurrentUserName[HD_LEN_USER_NAME];

nRet = sc_query_current_user_name(hServer, szCurrentUserName);

if (nRet != RD_SUCCESS)

{

printf("query current user name failed, error code[%d]!\n", nRet);

return -1;

}

printf("query current user name successful, current uer name :%s!\n", szCurrentUserName);

//modify pass word

nRet = sc_modify_password(hServer, "admin", "admin", "szNewPassWord");

if (nRet != RD_SUCCESS)

{

printf("modify user[name:admin] password failed, error code[%d]!\n", nRet);

return -1;

}

printf("modify user[name:admin] password successful!\n");

//reset password

nRet = sc_reset_password(hServer, "admin", "admin");

if (nRet != RD_SUCCESS)

{

printf("reset user[name:admin] password failed, error code[%d]!\n", nRet);

return -1;

}

printf("reset user[name:admin] password successful!\n");

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sc_login

sc_add_user

sc_modify_password

sc_delete_user

sc_modify_user_desc


SDK

Navigation: »No topics above this level«

SDK

 Return to chapter overview

SDK

Glossary Item Box

©2015. All Rights Reserved.


设置转储规则

Navigation: »No topics above this level«

设置转储规则

 Return to chapter overview

设置转储规则

Glossary Item Box

本节介绍“设置转储规则”的转储配置，包括：修改转储参数或转储Tag点，以及注意事项。注意如下：

1. 设置转储规则名，记录起始时间，记录间隔，执行起始时间，执行周期；

?记录起始时间和执行起始时间可以设置的最小时间点为1970-01-01 00：00：00，最大时间点为2038-01-19 03:14:06；

2. 点击“置为当前时间” 起始时间会置为当前时间；

3. 点击添加Tag，弹出Tag搜索界面，选择Tag后导入到Tag显示列表上；

?Tag显示列表显示了Tag的iHyperDB源、Tag名、Tag类型、Tag描述信息；

4. 选中列表中的Tag,点击删除Tag，可以删除规则中的Tag；

5. 点击确定，设置规则成功，点击取消，取消设置规则操作；

?若对应的表为窄表，新建规则成功后，会弹出匹配宽表字段的界面，用户需要进行字段匹配。


内存快照接口

Navigation: »No topics above this level«

内存快照接口

 Return to chapter overview

内存快照接口

Glossary Item Box

《内存快照接口》的主要内容包括：

?sn_query_snapshot

?sn_query_snapshots

?sn_save_disorder_snapshots

?sn_save_snapshot

?sn_save_snapshots

©2015. All Rights Reserved.


sn_query_snapshot

Navigation: »No topics above this level«

sn_query_snapshot

 Return to chapter overview

sn_query_snapshot

Glossary Item Box

函数

查询某一普通点的实时数据

int32 sn_query_snapshot(

HDHANDLE hServer,

uint32 nTagID,

HDRecord *pRecord

);

参数

hServer

[in] 服务器句柄。

nTagID

[in] TagID。

pRecord

[out] 实时记录

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

说明

该函数用来查询一个Tag的保存在内存快照中的最新的记录，查询成功，返回RD_SUCCESS，失败，返回错误码。

记录结构体：

HDRecord

!MISSING PHRASE 'COPYCODE'!

typedef struct

{

int32 nSec;

int16 nMsec;

uint16 nQuality;

uint8 nTagType;

union

{

 int8 nInt8;

 int16 nInt16;

 int32 nInt32;

 float32 fFloat32;

 float64 fFloat64;

 int8 nDigital;

struct

 {

  char* pBuf;

  uint16 nLenBuf;

 }strBlob;

}value;

}HDRecord;

记录长度：

?TagType为String和Blob时，value.strBlob.pBuf由使用者来分配空间，分配的空间的大小为value.strBlob.nValueLen不能小于string或者Blob类型允许的最大长度LENGTH_VAR_TYPE_VALUE。

举例

sn_query_snapshot

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName_1 = "szTagName_1";

const char* szTagName_2 = "szTagName_2";

int32 nRecNum = 2;

HDRecord snapshotsSaved[2];

uint32 nTagIDs[2];

int32 nErrorCodes[2];

HDRecord snapshotsQueried[2];

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add two tag , type is int32 and string

strcpy(tag.szTagName, szTagName_1);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

strcpy(tag.szTagName, szTagName_2);

tag.nTagType = TAG_TYPE_STRING;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag ids

nRet = pt_query_tagid(hServer, szTagName_1, &nTagIDs[0]);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagIDs[0]);

nRet = pt_query_tagid(hServer, szTagName_2, &nTagIDs[1]);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n", szTagName_2, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_2, nTagIDs[1]);

//save one snapshot

snapshotsSaved[0].nSec = 3600;

snapshotsSaved[0].nMsec = 0;

snapshotsSaved[0].nQuality = 192;

snapshotsSaved[0].value.nInt32 = 111;

nRet = sn_save_snapshot(hServer, nTagIDs[0], &(snapshotsSaved[0]));

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, tag id [%d], error code [%d]!\n", nTagIDs[0], nRet);

}

printf("save snapshot successful, tag id[%d]!\n", nTagIDs[0]);

//query one snapshot

nRet = sn_query_snapshot(hServer, nTagIDs[0], &(snapshotsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("query snapshot failed, tag id [%d], error code [%d]!\n", nTagIDs[0], nRet);

}

printf("query snapshot successful, tag id[%d]!\n", nTagIDs[0]);

//save disorder snapshots

snapshotsSaved[0].nSec = 3600 - 60;

snapshotsSaved[0].nMsec = 0;

snapshotsSaved[0].nQuality = 192;

snapshotsSaved[0].value.nInt32 = 111;

snapshotsSaved[1].nSec = 3600 + 60;

snapshotsSaved[1].nMsec = 0;

snapshotsSaved[1].nQuality = 192;

snapshotsSaved[1].value.nInt32 = 222;

nRet = sn_save_disorder_snapshots(hServer, nRecNum, nTagIDs[0], snapshotsSaved);

if (nRet != RD_SUCCESS)

{

 printf("save disorder snapshots failed,  tag id [%d], error code [%d]!\n", nTagIDs[0], nRet);

}

printf("save disorder snapshots successful, tag id [%d]!\n", nTagIDs[0]);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

 snapshotsSaved[i].nSec = 7200;

 snapshotsSaved[i].nMsec = 0;

 snapshotsSaved[i].nQuality = 192;

}

snapshotsSaved[0].value.nInt32 = 123;

snapshotsSaved[1].value.strBlob.pBuf = new char[LENGTH_VAR_TYPE_VALUE];

strcpy(snapshotsSaved[1].value.strBlob.pBuf, "this is a string");

snapshotsSaved[1].value.strBlob.nLenBuf = strlen(snapshotsSaved[1].value.strBlob.pBuf) + 1;

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, snapshotsSaved, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("save snapshots successful!\n");

}

else if (EC_HD_API_SAVE_SNAPSHOTS_FAILED == nRet)

{

for (i = 0; i < nRecNum; i ++)

 {

  if (nErrorCodes[i] != RD_SUCCESS)

  {

   printf("tag[%d] save snapshot failed, error code [%d]!\n", nTagIDs[i], nErrorCodes[i]);

  }

 }

}

else

{

 printf("save snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 delete[] snapshotsSaved[1].value.strBlob.pBuf;

 snapshotsSaved[1].value.strBlob.pBuf = NULL;

return -1;

}

delete[] snapshotsSaved[1].value.strBlob.pBuf;

snapshotsSaved[1].value.strBlob.pBuf = NULL;

//query sanpshots

snapshotsQueried[1].value.strBlob.pBuf = new char[LENGTH_VAR_TYPE_VALUE];

snapshotsQueried[1].value.strBlob.nLenBuf = LENGTH_VAR_TYPE_VALUE;

nRet = sn_query_snapshots(hServer, nRecNum, nTagIDs, snapshotsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query snapshots successful!\n");

}

else if (EC_HD_API_SAVE_SNAPSHOTS_FAILED == nRet)

{

for (i = 0; i < nRecNum; i ++)

 {

  printf("tag[%d] query snapshot failed, error code [%d]!\n", nTagIDs[i], nErrorCodes[i]);

 }

}

else

{

 printf("query snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 delete[] snapshotsQueried[1].value.strBlob.pBuf;

 snapshotsQueried[1].value.strBlob.pBuf = NULL;

return -1;

}

delete[] snapshotsQueried[1].value.strBlob.pBuf;

snapshotsQueried[1].value.strBlob.pBuf = NULL;

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sn save snapshot

sn save snapshots

sn_query_snapshot

sn query snapshots

sn_save_disorder_snapshots


sn_query_snapshots

Navigation: »No topics above this level«

sn_query_snapshots

 Return to chapter overview

sn_query_snapshots

Glossary Item Box

函数

查询多个普通点的实时记录

int32 sn_query_snapshots(

HDHANDLE hServer,

int32 nRecNum,

uint32 nTagIDs[],

HDRecord records[],

int32 nErrCodes[]

);

参数

hServer

[in] 服务器句柄。

nRecNum

[in] 查询的实时记录的数量，不能超过65535。

nTagIDs

[in] TagID数组。

records

[out]查询的实时记录。

nErrCodes

[out] 状态码的数组，状态码标识保存记录成功或失败。

返回值

查询成功，返回RD_SUCCESS，不是所有的都成功返回EC_HD_API_QUERY_SNAPSHOTS_FAILED。查询失败返回其它错误码，见error_code.h。

说明

查询多个普通点的内存快照。返回RD_SUCCESS，表示所有的内存快照都查询成功，nErrorCode[]数组都是RD_SUCCESS，返回EC_HD_API_QUERY_SNAPSHOTS_FAILED，表明不是所有查询都成功，具体的错误码保存在nErrorCode[]中，返回其它错误码表明查询失败，具体的错误码保存在nErrorCode[]中。

举例

sn_query_snapshots

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName_1 = "szTagName_1";

const char* szTagName_2 = "szTagName_2";

int32 nRecNum = 2;

HDRecord snapshotsSaved[2];

uint32 nTagIDs[2];

int32 nErrorCodes[2];

HDRecord snapshotsQueried[2];

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add two tag , type is int32 and string

strcpy(tag.szTagName, szTagName_1);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

strcpy(tag.szTagName, szTagName_2);

tag.nTagType = TAG_TYPE_STRING;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag ids

nRet = pt_query_tagid(hServer, szTagName_1, &nTagIDs[0]);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagIDs[0]);

nRet = pt_query_tagid(hServer, szTagName_2, &nTagIDs[1]);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n", szTagName_2, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_2, nTagIDs[1]);

//save one snapshot

snapshotsSaved[0].nSec = 3600;

snapshotsSaved[0].nMsec = 0;

snapshotsSaved[0].nQuality = 192;

snapshotsSaved[0].value.nInt32 = 111;

nRet = sn_save_snapshot(hServer, nTagIDs[0], &(snapshotsSaved[0]));

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, tag id [%d], error code [%d]!\n", nTagIDs[0], nRet);

}

printf("save snapshot successful, tag id[%d]!\n", nTagIDs[0]);

//query one snapshot

nRet = sn_query_snapshot(hServer, nTagIDs[0], &(snapshotsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("query snapshot failed, tag id [%d], error code [%d]!\n", nTagIDs[0], nRet);

}

printf("query snapshot successful, tag id[%d]!\n", nTagIDs[0]);

//save disorder snapshots

snapshotsSaved[0].nSec = 3600 - 60;

snapshotsSaved[0].nMsec = 0;

snapshotsSaved[0].nQuality = 192;

snapshotsSaved[0].value.nInt32 = 111;

snapshotsSaved[1].nSec = 3600 + 60;

snapshotsSaved[1].nMsec = 0;

snapshotsSaved[1].nQuality = 192;

snapshotsSaved[1].value.nInt32 = 222;

nRet = sn_save_disorder_snapshots(hServer, nRecNum, nTagIDs[0], snapshotsSaved);

if (nRet != RD_SUCCESS)

{

 printf("save disorder snapshots failed,  tag id [%d], error code [%d]!\n", nTagIDs[0], nRet);

}

printf("save disorder snapshots successful, tag id [%d]!\n", nTagIDs[0]);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

 snapshotsSaved[i].nSec = 7200;

 snapshotsSaved[i].nMsec = 0;

 snapshotsSaved[i].nQuality = 192;

}

snapshotsSaved[0].value.nInt32 = 123;

snapshotsSaved[1].value.strBlob.pBuf = new char[LENGTH_VAR_TYPE_VALUE];

strcpy(snapshotsSaved[1].value.strBlob.pBuf, "this is a string");

snapshotsSaved[1].value.strBlob.nLenBuf = strlen(snapshotsSaved[1].value.strBlob.pBuf) + 1;

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, snapshotsSaved, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("save snapshots successful!\n");

}

else if (EC_HD_API_SAVE_SNAPSHOTS_FAILED == nRet)

{

for (i = 0; i < nRecNum; i ++)

 {

  if (nErrorCodes[i] != RD_SUCCESS)

  {

   printf("tag[%d] save snapshot failed, error code [%d]!\n", nTagIDs[i], nErrorCodes[i]);

  }

 }

}

else

{

 printf("save snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 delete[] snapshotsSaved[1].value.strBlob.pBuf;

 snapshotsSaved[1].value.strBlob.pBuf = NULL;

return -1;

}

delete[] snapshotsSaved[1].value.strBlob.pBuf;

snapshotsSaved[1].value.strBlob.pBuf = NULL;

//query sanpshots

snapshotsQueried[1].value.strBlob.pBuf = new char[LENGTH_VAR_TYPE_VALUE];

snapshotsQueried[1].value.strBlob.nLenBuf = LENGTH_VAR_TYPE_VALUE;

nRet = sn_query_snapshots(hServer, nRecNum, nTagIDs, snapshotsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query snapshots successful!\n");

}

else if (EC_HD_API_SAVE_SNAPSHOTS_FAILED == nRet)

{

for (i = 0; i < nRecNum; i ++)

 {

  printf("tag[%d] query snapshot failed, error code [%d]!\n", nTagIDs[i], nErrorCodes[i]);

 }

}

else

{

 printf("query snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 delete[] snapshotsQueried[1].value.strBlob.pBuf;

 snapshotsQueried[1].value.strBlob.pBuf = NULL;

return -1;

}

delete[] snapshotsQueried[1].value.strBlob.pBuf;

snapshotsQueried[1].value.strBlob.pBuf = NULL;

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sn save snapshot

sn save snapshots

sn_query_snapshot

sn query snapshots

sn_save_disorder_snapshots


sn_save_disorder_snapshots

Navigation: »No topics above this level«

sn_save_disorder_snapshots

 Return to chapter overview

sn_save_disorder_snapshots

Glossary Item Box

函数

保存一个普通点的多条乱序记录到服务器

int32 sn_save_disorder_snapshots(

HDHANDLE hServer,

int32 nRecNum,

uint32 nTagID,

HDRecord records[]

);

参数

hServer

[in] 服务器句柄。

nRecNum

[in] 记录条数不能超过65535。

nTagID

[in] Tag ID。

records

[in] 待保存的乱序记录。

返回值

保存成功，返回RD_SUCCESS，保存失败返回其它错误码，见error_code.h。

说明

该接口用来保存一个点的若干乱序记录到服务器。

当记录时间小于快照时间时，该记录会作为归档记录插入到归档文件，内存快照不变。若在归档文件中有一条原始记录的时间与该记录的时间一样，该乱序记录会被丢弃，记录被丢弃时返回值仍然是RD_SUCCESS。

当记录时间等于快照时间时，该记录会被丢弃，记录被丢弃时返回值仍然是0。

当记录时间大于快照时间时，该记录会作为最新的记录存入服务器，同时该记录会作为内存快照保存到服务器。

Record请参见sn_save_snapshot

举例

sn_save_disorder_snapshots

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName_1 = "szTagName_1";

const char* szTagName_2 = "szTagName_2";

int32 nRecNum = 2;

HDRecord snapshotsSaved[2];

uint32 nTagIDs[2];

int32 nErrorCodes[2];

HDRecord snapshotsQueried[2];

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add two tag , type is int32 and string

strcpy(tag.szTagName, szTagName_1);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

strcpy(tag.szTagName, szTagName_2);

tag.nTagType = TAG_TYPE_STRING;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag ids

nRet = pt_query_tagid(hServer, szTagName_1, &nTagIDs[0]);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagIDs[0]);

nRet = pt_query_tagid(hServer, szTagName_2, &nTagIDs[1]);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n", szTagName_2, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_2, nTagIDs[1]);

//save one snapshot

snapshotsSaved[0].nSec = 3600;

snapshotsSaved[0].nMsec = 0;

snapshotsSaved[0].nQuality = 192;

snapshotsSaved[0].value.nInt32 = 111;

nRet = sn_save_snapshot(hServer, nTagIDs[0], &(snapshotsSaved[0]));

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, tag id [%d], error code [%d]!\n", nTagIDs[0], nRet);

}

printf("save snapshot successful, tag id[%d]!\n", nTagIDs[0]);

//query one snapshot

nRet = sn_query_snapshot(hServer, nTagIDs[0], &(snapshotsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("query snapshot failed, tag id [%d], error code [%d]!\n", nTagIDs[0], nRet);

}

printf("query snapshot successful, tag id[%d]!\n", nTagIDs[0]);

//save disorder snapshots

snapshotsSaved[0].nSec = 3600 - 60;

snapshotsSaved[0].nMsec = 0;

snapshotsSaved[0].nQuality = 192;

snapshotsSaved[0].value.nInt32 = 111;

snapshotsSaved[1].nSec = 3600 + 60;

snapshotsSaved[1].nMsec = 0;

snapshotsSaved[1].nQuality = 192;

snapshotsSaved[1].value.nInt32 = 222;

nRet = sn_save_disorder_snapshots(hServer, nRecNum, nTagIDs[0], snapshotsSaved);

if (nRet != RD_SUCCESS)

{

 printf("save disorder snapshots failed,  tag id [%d], error code [%d]!\n", nTagIDs[0], nRet);

}

printf("save disorder snapshots successful, tag id [%d]!\n", nTagIDs[0]);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

 snapshotsSaved[i].nSec = 7200;

 snapshotsSaved[i].nMsec = 0;

 snapshotsSaved[i].nQuality = 192;

}

snapshotsSaved[0].value.nInt32 = 123;

snapshotsSaved[1].value.strBlob.pBuf = new char[LENGTH_VAR_TYPE_VALUE];

strcpy(snapshotsSaved[1].value.strBlob.pBuf, "this is a string");

snapshotsSaved[1].value.strBlob.nLenBuf = strlen(snapshotsSaved[1].value.strBlob.pBuf) + 1;

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, snapshotsSaved, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("save snapshots successful!\n");

}

else if (EC_HD_API_SAVE_SNAPSHOTS_FAILED == nRet)

{

for (i = 0; i < nRecNum; i ++)

 {

  if (nErrorCodes[i] != RD_SUCCESS)

  {

   printf("tag[%d] save snapshot failed, error code [%d]!\n", nTagIDs[i], nErrorCodes[i]);

  }

 }

}

else

{

 printf("save snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 delete[] snapshotsSaved[1].value.strBlob.pBuf;

 snapshotsSaved[1].value.strBlob.pBuf = NULL;

return -1;

}

delete[] snapshotsSaved[1].value.strBlob.pBuf;

snapshotsSaved[1].value.strBlob.pBuf = NULL;

//query sanpshots

snapshotsQueried[1].value.strBlob.pBuf = new char[LENGTH_VAR_TYPE_VALUE];

snapshotsQueried[1].value.strBlob.nLenBuf = LENGTH_VAR_TYPE_VALUE;

nRet = sn_query_snapshots(hServer, nRecNum, nTagIDs, snapshotsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query snapshots successful!\n");

}

else if (EC_HD_API_SAVE_SNAPSHOTS_FAILED == nRet)

{

for (i = 0; i < nRecNum; i ++)

 {

  printf("tag[%d] query snapshot failed, error code [%d]!\n", nTagIDs[i], nErrorCodes[i]);

 }

}

else

{

 printf("query snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 delete[] snapshotsQueried[1].value.strBlob.pBuf;

 snapshotsQueried[1].value.strBlob.pBuf = NULL;

return -1;

}

delete[] snapshotsQueried[1].value.strBlob.pBuf;

snapshotsQueried[1].value.strBlob.pBuf = NULL;

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sn_save_snapshot

sn_save_snapshots

sn_query_snapshot

sn query snapshots

sn_save_disorder_snapshots


sn_save_snapshot

Navigation: »No topics above this level«

sn_save_snapshot

 Return to chapter overview

sn_save_snapshot

Glossary Item Box

函数

将一条最新的记录保存到服务器

int32 sn_save_snapshot(

HDHANDLE hServer,

uint32 nTagID,

HDRecord* pRecord

);

参数

hServer

[in] 服务器句柄。

nTagID

[in] TagID。

pRecord

[in] 被保存的实时记录。

返回值

查询成功，返回RD_SUCCESS，查询失败返回其它错误码，见error_code.h。

说明

记录结构体：

HDRecord

!MISSING PHRASE 'COPYCODE'!

typedef struct

{

int32 nSec;

int16 nMsec;

uint16 nQuality;

uint8 nTagType;

union

{

 int8 nInt8;

 int16 nInt16;

 int32 nInt32;

 float32 fFloat32;

 float64 fFloat64;

 int8 nDigital;

struct

 {

  char* pBuf;

  uint16 nLenBuf;

 }strBlob;

}value;

}HDRecord;

记录长度：

?TagType为String和Blob时，value.strBlob.pBuf由使用者来分配空间，分配的空间的大小为value.strBlob.nValueLen不能小于string或者Blob类型允许的最大长度LENGTH_VAR_TYPE_VALUE。

举例

sn_save_snapshot

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName_1 = "szTagName_1";

const char* szTagName_2 = "szTagName_2";

int32 nRecNum = 2;

HDRecord snapshotsSaved[2];

uint32 nTagIDs[2];

int32 nErrorCodes[2];

HDRecord snapshotsQueried[2];

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add two tag , type is int32 and string

strcpy(tag.szTagName, szTagName_1);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

strcpy(tag.szTagName, szTagName_2);

tag.nTagType = TAG_TYPE_STRING;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag ids

nRet = pt_query_tagid(hServer, szTagName_1, &nTagIDs[0]);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagIDs[0]);

nRet = pt_query_tagid(hServer, szTagName_2, &nTagIDs[1]);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n", szTagName_2, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_2, nTagIDs[1]);

//save one snapshot

snapshotsSaved[0].nSec = 3600;

snapshotsSaved[0].nMsec = 0;

snapshotsSaved[0].nQuality = 192;

snapshotsSaved[0].value.nInt32 = 111;

nRet = sn_save_snapshot(hServer, nTagIDs[0], &(snapshotsSaved[0]));

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, tag id [%d], error code [%d]!\n", nTagIDs[0], nRet);

}

printf("save snapshot successful, tag id[%d]!\n", nTagIDs[0]);

//query one snapshot

nRet = sn_query_snapshot(hServer, nTagIDs[0], &(snapshotsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("query snapshot failed, tag id [%d], error code [%d]!\n", nTagIDs[0], nRet);

}

printf("query snapshot successful, tag id[%d]!\n", nTagIDs[0]);

//save disorder snapshots

snapshotsSaved[0].nSec = 3600 - 60;

snapshotsSaved[0].nMsec = 0;

snapshotsSaved[0].nQuality = 192;

snapshotsSaved[0].value.nInt32 = 111;

snapshotsSaved[1].nSec = 3600 + 60;

snapshotsSaved[1].nMsec = 0;

snapshotsSaved[1].nQuality = 192;

snapshotsSaved[1].value.nInt32 = 222;

nRet = sn_save_disorder_snapshots(hServer, nRecNum, nTagIDs[0], snapshotsSaved);

if (nRet != RD_SUCCESS)

{

 printf("save disorder snapshots failed,  tag id [%d], error code [%d]!\n", nTagIDs[0], nRet);

}

printf("save disorder snapshots successful, tag id [%d]!\n", nTagIDs[0]);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

 snapshotsSaved[i].nSec = 7200;

 snapshotsSaved[i].nMsec = 0;

 snapshotsSaved[i].nQuality = 192;

}

snapshotsSaved[0].value.nInt32 = 123;

snapshotsSaved[1].value.strBlob.pBuf = new char[LENGTH_VAR_TYPE_VALUE];

strcpy(snapshotsSaved[1].value.strBlob.pBuf, "this is a string");

snapshotsSaved[1].value.strBlob.nLenBuf = strlen(snapshotsSaved[1].value.strBlob.pBuf) + 1;

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, snapshotsSaved, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("save snapshots successful!\n");

}

else if (EC_HD_API_SAVE_SNAPSHOTS_FAILED == nRet)

{

for (i = 0; i < nRecNum; i ++)

 {

  if (nErrorCodes[i] != RD_SUCCESS)

  {

   printf("tag[%d] save snapshot failed, error code [%d]!\n", nTagIDs[i], nErrorCodes[i]);

  }

 }

}

else

{

 printf("save snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 delete[] snapshotsSaved[1].value.strBlob.pBuf;

 snapshotsSaved[1].value.strBlob.pBuf = NULL;

return -1;

}

delete[] snapshotsSaved[1].value.strBlob.pBuf;

snapshotsSaved[1].value.strBlob.pBuf = NULL;

//query sanpshots

snapshotsQueried[1].value.strBlob.pBuf = new char[LENGTH_VAR_TYPE_VALUE];

snapshotsQueried[1].value.strBlob.nLenBuf = LENGTH_VAR_TYPE_VALUE;

nRet = sn_query_snapshots(hServer, nRecNum, nTagIDs, snapshotsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query snapshots successful!\n");

}

else if (EC_HD_API_SAVE_SNAPSHOTS_FAILED == nRet)

{

for (i = 0; i < nRecNum; i ++)

 {

  printf("tag[%d] query snapshot failed, error code [%d]!\n", nTagIDs[i], nErrorCodes[i]);

 }

}

else

{

 printf("query snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 delete[] snapshotsQueried[1].value.strBlob.pBuf;

 snapshotsQueried[1].value.strBlob.pBuf = NULL;

return -1;

}

delete[] snapshotsQueried[1].value.strBlob.pBuf;

snapshotsQueried[1].value.strBlob.pBuf = NULL;

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sn_save_snapshot

sn_save_snapshots

sn_query_snapshot

sn query snapshots

sn_save_disorder_snapshots


sn_save_snapshots

Navigation: »No topics above this level«

sn_save_snapshots

 Return to chapter overview

sn_save_snapshots

Glossary Item Box

函数

保存多个点的实时记录

int32 sn_save_snapshots(

HDHANDLE hServer,

int32 nRecNum,

uint32 nTagIDs[],

HDRecord records[],

int32 nErrCodes[]

);

参数

hServer

[in] 服务器句柄。

nRecNum

[in] 实时记录的个数不能超过65535。

nTagIDs

[in] TagID的数组。

records

[in] 需要被保存的记录数组。

nErrCodes

[out] 错误码数组，表明每一条记录的是否保存成功。

返回值

保存成功，返回RD_SUCCESS，不是所有的都成功返回EC_HD_API_SAVE_SNAPSHOTS_FAILED。保存失败返回其它错误码，见error_code.h。

说明

记录结构体：

HDRecord

!MISSING PHRASE 'COPYCODE'!

typedef struct

{

int32 nSec;

int16 nMsec;

uint16 nQuality;

uint8 nTagType;

union

{

 int8 nInt8;

 int16 nInt16;

 int32 nInt32;

 float32 fFloat32;

 float64 fFloat64;

 int8 nDigital;

struct

 {

  char* pBuf;

  uint16 nLenBuf;

 }strBlob;

}value;

}HDRecord;

记录长度：

?TagType为String和Blob时，value.strBlob.pBuf由使用者来分配空间，分配的空间的大小为value.strBlob.nValueLen不能小于string或者Blob类型允许的最大长度LENGTH_VAR_TYPE_VALUE。

举例

sn_save_snapshots

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName_1 = "szTagName_1";

const char* szTagName_2 = "szTagName_2";

int32 nRecNum = 2;

HDRecord snapshotsSaved[2];

uint32 nTagIDs[2];

int32 nErrorCodes[2];

HDRecord snapshotsQueried[2];

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add two tag , type is int32 and string

strcpy(tag.szTagName, szTagName_1);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

strcpy(tag.szTagName, szTagName_2);

tag.nTagType = TAG_TYPE_STRING;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag ids

nRet = pt_query_tagid(hServer, szTagName_1, &nTagIDs[0]);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagIDs[0]);

nRet = pt_query_tagid(hServer, szTagName_2, &nTagIDs[1]);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n", szTagName_2, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_2, nTagIDs[1]);

//save one snapshot

snapshotsSaved[0].nSec = 3600;

snapshotsSaved[0].nMsec = 0;

snapshotsSaved[0].nQuality = 192;

snapshotsSaved[0].value.nInt32 = 111;

nRet = sn_save_snapshot(hServer, nTagIDs[0], &(snapshotsSaved[0]));

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, tag id [%d], error code [%d]!\n", nTagIDs[0], nRet);

}

printf("save snapshot successful, tag id[%d]!\n", nTagIDs[0]);

//query one snapshot

nRet = sn_query_snapshot(hServer, nTagIDs[0], &(snapshotsQueried[0]));

if (nRet != RD_SUCCESS)

{

 printf("query snapshot failed, tag id [%d], error code [%d]!\n", nTagIDs[0], nRet);

}

printf("query snapshot successful, tag id[%d]!\n", nTagIDs[0]);

//save disorder snapshots

snapshotsSaved[0].nSec = 3600 - 60;

snapshotsSaved[0].nMsec = 0;

snapshotsSaved[0].nQuality = 192;

snapshotsSaved[0].value.nInt32 = 111;

snapshotsSaved[1].nSec = 3600 + 60;

snapshotsSaved[1].nMsec = 0;

snapshotsSaved[1].nQuality = 192;

snapshotsSaved[1].value.nInt32 = 222;

nRet = sn_save_disorder_snapshots(hServer, nRecNum, nTagIDs[0], snapshotsSaved);

if (nRet != RD_SUCCESS)

{

 printf("save disorder snapshots failed,  tag id [%d], error code [%d]!\n", nTagIDs[0], nRet);

}

printf("save disorder snapshots successful, tag id [%d]!\n", nTagIDs[0]);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

 snapshotsSaved[i].nSec = 7200;

 snapshotsSaved[i].nMsec = 0;

 snapshotsSaved[i].nQuality = 192;

}

snapshotsSaved[0].value.nInt32 = 123;

snapshotsSaved[1].value.strBlob.pBuf = new char[LENGTH_VAR_TYPE_VALUE];

strcpy(snapshotsSaved[1].value.strBlob.pBuf, "this is a string");

snapshotsSaved[1].value.strBlob.nLenBuf = strlen(snapshotsSaved[1].value.strBlob.pBuf) + 1;

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, snapshotsSaved, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("save snapshots successful!\n");

}

else if (EC_HD_API_SAVE_SNAPSHOTS_FAILED == nRet)

{

for (i = 0; i < nRecNum; i ++)

 {

  if (nErrorCodes[i] != RD_SUCCESS)

  {

   printf("tag[%d] save snapshot failed, error code [%d]!\n", nTagIDs[i], nErrorCodes[i]);

  }

 }

}

else

{

 printf("save snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 delete[] snapshotsSaved[1].value.strBlob.pBuf;

 snapshotsSaved[1].value.strBlob.pBuf = NULL;

return -1;

}

delete[] snapshotsSaved[1].value.strBlob.pBuf;

snapshotsSaved[1].value.strBlob.pBuf = NULL;

//query sanpshots

snapshotsQueried[1].value.strBlob.pBuf = new char[LENGTH_VAR_TYPE_VALUE];

snapshotsQueried[1].value.strBlob.nLenBuf = LENGTH_VAR_TYPE_VALUE;

nRet = sn_query_snapshots(hServer, nRecNum, nTagIDs, snapshotsQueried, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query snapshots successful, tag!\n");

}

else if (EC_HD_API_SAVE_SNAPSHOTS_FAILED == nRet)

{

for (i = 0; i < nRecNum; i ++)

 {

  printf("tag[%d] query snapshot failed, error code [%d]!\n", nTagIDs[i], nErrorCodes[i]);

 }

}

else

{

 printf("query snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 delete[] snapshotsQueried[1].value.strBlob.pBuf;

 snapshotsQueried[1].value.strBlob.pBuf = NULL;

return -1;

}

delete[] snapshotsQueried[1].value.strBlob.pBuf;

snapshotsQueried[1].value.strBlob.pBuf = NULL;

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

sn save snapshot

sn_save_snapshots

sn_query_snapshot

sn query snapshots

sn_save_disorder_snapshots


spc_acknowledge_alarm

Navigation: »No topics above this level«

spc_acknowledge_alarm

 Return to chapter overview

spc_acknowledge_alarm

Glossary Item Box

函数

在一台服务器中确认某些时刻的SPC报警记录

int32 spc_acknowledge_alarm(

HDHANDLE hServer,

uint32 TagIDs[],

HDTime alarmTimes[],

int32 nAckNum

);

参数

hServer

[in] 服务器句柄

nTagIDs[]

[in] 报警点ID数组

alarmTimes[],

[in] 报警产生的时间数组

nAckNum

[in] 报警个数

返回值

查询成功，返回RD_SUCCESS，查询失败返回其它错误码，见error_code.h。

说明

调用该方法成功后，该报警点在某一时刻产生的报警记录的确认状态为确认。

举例

spc_acknowledge_alarm

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

#include <windows.h>

void spc_record_callback(HDHANDLE hServer, int8 nType, const HDSPCAlarmRecord* spcAlarm)

{

printf("spc alarm occer, nType %d, tag id %d, time %d\n", nType, spcAlarm->nSPCTagID, spcAlarm->tvStartTime.nSec);

}

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "168.2.237.35";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statsTag;

SPCAlarmTagProp spcAlarmTagSave;

int32 nRecNum = 4;

const int32 SPC_ALARM_TAG_NUM = 4;

uint32 nSPCTagIDs[SPC_ALARM_TAG_NUM];

HDSPCAlarmQuery queryCond;

HDRecord snapshot;

HDHANDLE hIter = NULL;

HDSPCAlarmRecord spcAlarmRec;

HDSPCAlarmRecord snSPCAlarms[SPC_ALARM_TAG_NUM];

int32 nErrorCodes[SPC_ALARM_TAG_NUM];

HDTime alarmTimes[SPC_ALARM_TAG_NUM];

int32 i = 0;

uint32 nSrcTagID = 0;

uint32 nUCLTagID = 0;

uint32 nCLTagID = 0;

uint32 nLCLTagID = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

nRet = sc_login(hServer, "admin", "admin");

// add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nSrcTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

//add statistics tag

strcpy(statsTag.szTagName, "szStatsTag");

strcpy(statsTag.szSourceTagName, normalTag.szTagName);

statsTag.nScanPeriod = 1;

statsTag.nStatsType = HD_STATS_TYPE_MAX;

statsTag.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statsTag.nSampleInerval = 1;

statsTag.nSampleStartDate = 1;

statsTag.bBeginTimeStamp = true;

nRet = st_add_tag(hServer, &statsTag, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_NAME

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE

 |TAG_PROP_STATS_BEGIN_TIME_STAMP);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statsTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statsTag.szTagName);

//add one normal tag as spc tag ucl tag

strcpy(normalTag.szTagName, "szUCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nUCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 200;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nUCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add one normal tag as spc tag cl tag

strcpy(normalTag.szTagName, "szCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 100;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add one normal tag as spc tag lcl tag

strcpy(normalTag.szTagName, "szLCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nLCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 50;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nLCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add spc alarm tag

for (i = 0; i < SPC_ALARM_TAG_NUM; i ++)

{

 memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

 sprintf(spcAlarmTagSave.szTagName, "szSPCAlarmTag_%d", i);

 strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

 spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

 strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

 strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

 strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

 spcAlarmTagSave.dUCLDefaultValue = 200;

 spcAlarmTagSave.dCLDefaultVaule = 100;

 spcAlarmTagSave.dLCLDefaultValue = 50;

 spcAlarmTagSave.bJudgeContinuous = true;

 spcAlarmTagSave.bRule1 = true;

 spcAlarmTagSave.nRule1M = 1;

 nRet = spc_add_tag(hServer, &spcAlarmTagSave,

  TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

  | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

 if (nRet != RD_SUCCESS)

 {

  printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

 nRet = spc_query_tagid(hServer, spcAlarmTagSave.szTagName, &nSPCTagIDs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query spc alarm tag id failed,  alarm spc name[%s], error code[%d]!\n", spcAlarmTagSave.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("spc alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  spcAlarmTagSave.szTagName, nSPCTagIDs[i]);

}

//reg spc alarm callback

spc_register_alarm_record_info(hServer, spc_record_callback);

//save snapshots generate spc alarm

for (i = 0; i < nRecNum; i++)

{

 snapshot.nSec =  i + 1;

 snapshot.nMsec = 0;

 snapshot.nQuality = 192;

 snapshot.value.nInt32 = 300;

 nRet = sn_save_snapshot(hServer, nSrcTagID, &snapshot);

 if (nRet != RD_SUCCESS)

 {

  printf("save snapshot failed, error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("save snapshot successful!\n");

 Sleep(10);

}

Sleep(3000);

//query alarm snapshot

nRet = spc_query_snapshots(hServer, SPC_ALARM_TAG_NUM, nSPCTagIDs,

 ALARM_REC_PROP_ALL, snSPCAlarms, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query alarm snapshots successful!\n");

}

else if (EC_HD_API_AM_QUERY_SNAPSHOTS_FAILED == nRet)

{

 for (i = 0; i < SPC_ALARM_TAG_NUM; i ++)

 {

  if (nErrorCodes[i] != RD_SUCCESS)

  {

   printf("query alarm tag[%d] snapshot failed, error code [%d]!\n", nSPCTagIDs[i], nErrorCodes[i]);

  }

 }

}

else

{

 printf("query alarm snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//ack alarms

for (i = 0; i < nRecNum; i++)

{

 alarmTimes[i].nSec = snSPCAlarms[i].tvStartTime.nSec;

 alarmTimes[i].nMsec = snSPCAlarms[i].tvStartTime.nMsec;

}

nRet = spc_acknowledge_alarms(hServer, nSPCTagIDs, alarmTimes,  SPC_ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("acknowledge alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("acknowledge alarms successful!\n");

//comment alarms

nRet = spc_comment_alarms(hServer, nSPCTagIDs, alarmTimes, "this is a comment", SPC_ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("comment alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("comment alarms successful!\n");

//query tag alarm records

queryCond.tvStart.nSec = 1;

queryCond.tvStart.nMsec = 0;

queryCond.tvEnd.nMsec =0;

queryCond.tvEnd.nSec =100;

queryCond.nAckMask = (int8)MASK_ALARM_ALL;

queryCond.nCommentMask = (int8)MASK_ALARM_ALL;

queryCond.nRestoreMask = (int8)MASK_ALARM_ALL;

nRet = spc_query_tag_records(hServer, nSPCTagIDs[0], &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags all records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query group alarm records

nRet = spc_query_group_records(hServer, 0, &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query group records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query tags alarm records

nRet = spc_query_tags_records(hServer, nSPCTagIDs, SPC_ALARM_TAG_NUM,

 &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//disconnect

nt_disconnect(hServer);

return 0;

}

?参见：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


spc_add_tag

Navigation: »No topics above this level«

spc_add_tag

 Return to chapter overview

spc_add_tag

Glossary Item Box

函数

在一台服务器中添加一个spc报警点

int32 spc_add_tag(

HDHANDLE hServer,

const SPCAlarmTagProp* pAlarmTag,

int64 nPropMask

);

参数

hServer

[in] 服务器句柄。

pAlarmTag

[in] 报警点属性。

nPropMask

[in] 报警点属性掩码，表明要存储报警点的哪些属性。

返回值

添加成功，返回RD_SUCCESS。添加失败返回其它错误码，见error_code.h

说明

添加报警点时，报警点名称, 报警点源点名称必须添加，其它属性可以选择性的添加，添加哪些属性有属性掩码决定。SPC报警点的源点只能是统计点

举例

demo

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statsTag;

SPCAlarmTagProp spcAlarmTagSave;

SPCAlarmTagProp spcAlarmTagQuery;

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

int32 nErrCode = 0;

char (*szTagNames)[HD_LEN_TAG_NAME] = NULL;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag as stats tag source tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add statistics tag

strcpy(statsTag.szTagName, "szStatsTag");

strcpy(statsTag.szSourceTagName, normalTag.szTagName);

statsTag.nScanPeriod = 60;

statsTag.nStatsType = HD_STATS_TYPE_MAX;

statsTag.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statsTag.nSampleInerval = 3600;

statsTag.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statsTag, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_NAME

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statsTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statsTag.szTagName);

//add one normal tag as spc tag ucl tag

strcpy(normalTag.szTagName, "szUCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add one normal tag as spc tag cl tag

strcpy(normalTag.szTagName, "szCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add one normal tag as spc tag lcl tag

strcpy(normalTag.szTagName, "szLCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add spc alarm tag

memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

strcpy(spcAlarmTagSave.szTagName, "szSPCAlarmTag_1");

strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

spcAlarmTagSave.dUCLDefaultValue = 200;

spcAlarmTagSave.dCLDefaultVaule = 100;

spcAlarmTagSave.dLCLDefaultValue = 50;

nRet = spc_add_tag(hServer, &spcAlarmTagSave,

 TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

 | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

if (nRet != RD_SUCCESS)

{

 printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

strcpy(spcAlarmTagSave.szTagName, "szSPCAlarmTag_2");

strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

spcAlarmTagSave.dUCLDefaultValue = 200;

spcAlarmTagSave.dCLDefaultVaule = 100;

spcAlarmTagSave.dLCLDefaultValue = 50;

nRet = spc_add_tag(hServer, &spcAlarmTagSave,

 TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

 | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

if (nRet != RD_SUCCESS)

{

 printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

//query spc tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_DIGITAL);

nRet = spc_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME| TAG_PROP_TIME_DEADBAND | TAG_PROP_VALUE_DEADBAND, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query spc tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query spc tag successful, tag name is %s!\n", spcAlarmTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query spc tag complete!\n");

  break;

 }

 else

 {

  printf("query spc tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you have queried %d spc alarm tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = spc_query_tagid(hServer, spcAlarmTagSave.szTagName, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query spc alarm tag id failed,  alarm spc name[%s], error code[%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("spc alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  spcAlarmTagSave.szTagName, nTagID);

//modify tag desc

strcpy(spcAlarmTagSave.szDescriptor, "spc tag descriptor is modified");

spcAlarmTagSave.bRule1 = true;

spcAlarmTagSave.nRule1M = 10;

nRet = spc_modify_tag_prop(hServer, nTagID, &spcAlarmTagSave, TAG_PROP_DESCRIPTOR|TAG_PROP_SPC_RULE);

if (nRet != RD_SUCCESS)

{

 printf("modify spc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify spc tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = spc_query_tag_prop(hServer, nTagID, &spcAlarmTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query spc tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query spc tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 spcAlarmTagQuery.nTagID, spcAlarmTagQuery.szTagName, spcAlarmTagQuery.szDescriptor);

//query tag names

szTagNames = new char[1][HD_LEN_TAG_NAME];

nRet = spc_query_tag_names(hServer, 1, &nTagID, szTagNames, &nErrCode);

if (RD_SUCCESS == nRet)

{

 printf("query spc alarm tag[id:%d] name[%s] successful!\n", nTagID, szTagNames[0]);

}

else if (EC_HD_API_AM_QUERY_TAG_NAMES_FAILED == nRet)

{

 printf("query spc tag names failed, tag id[%d], error code[%d]!\n", nTagID, nErrCode);

}

if (nRet != RD_SUCCESS)

{

 printf("query spc tag names failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 delete[] szTagNames;

 nt_disconnect(hServer);

 return -1;

}

delete[] szTagNames;

//delete spc tag

nRet = spc_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete spc alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete spc alarm tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

?参见：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


spc_comment_alarms

Navigation: »No topics above this level«

spc_comment_alarms

 Return to chapter overview

spc_comment_alarms

Glossary Item Box

函数

int32 spc_comment_alarms(

HDHANDLE hServer,

uint32 tagIDs[],

HDTime alarmTimes[],

const char* szComment,

int32 nCommentNum

);

参数

hServer

[in] 服务器句柄

tagIDs[]

[in] 报警点ID数组

alarmTimes[]

[in] 报警产生的时间数组

szComment

[in]注释内容

nCommentNum

[in]需要注释的报警个数

返回值

查询成功，返回RD_SUCCESS，查询失败返回其它错误码，见error_code.h。

举例

spc_comment_alarms

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

#include <windows.h>

void spc_record_callback(HDHANDLE hServer, int8 nType, const HDSPCAlarmRecord* spcAlarm)

{

printf("spc alarm occer, nType %d, tag id %d, time %d\n", nType, spcAlarm->nSPCTagID, spcAlarm->tvStartTime.nSec);

}

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "168.2.237.35";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statsTag;

SPCAlarmTagProp spcAlarmTagSave;

int32 nRecNum = 4;

const int32 SPC_ALARM_TAG_NUM = 4;

uint32 nSPCTagIDs[SPC_ALARM_TAG_NUM];

HDSPCAlarmQuery queryCond;

HDRecord snapshot;

HDHANDLE hIter = NULL;

HDSPCAlarmRecord spcAlarmRec;

HDSPCAlarmRecord snSPCAlarms[SPC_ALARM_TAG_NUM];

int32 nErrorCodes[SPC_ALARM_TAG_NUM];

HDTime alarmTimes[SPC_ALARM_TAG_NUM];

int32 i = 0;

uint32 nSrcTagID = 0;

uint32 nUCLTagID = 0;

uint32 nCLTagID = 0;

uint32 nLCLTagID = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

nRet = sc_login(hServer, "admin", "admin");

// add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nSrcTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

//add statistics tag

strcpy(statsTag.szTagName, "szStatsTag");

strcpy(statsTag.szSourceTagName, normalTag.szTagName);

statsTag.nScanPeriod = 1;

statsTag.nStatsType = HD_STATS_TYPE_MAX;

statsTag.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statsTag.nSampleInerval = 1;

statsTag.nSampleStartDate = 1;

statsTag.bBeginTimeStamp = true;

nRet = st_add_tag(hServer, &statsTag, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_NAME

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE

 |TAG_PROP_STATS_BEGIN_TIME_STAMP);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statsTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statsTag.szTagName);

//add one normal tag as spc tag ucl tag

strcpy(normalTag.szTagName, "szUCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nUCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 200;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nUCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add one normal tag as spc tag cl tag

strcpy(normalTag.szTagName, "szCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 100;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add one normal tag as spc tag lcl tag

strcpy(normalTag.szTagName, "szLCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nLCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 50;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nLCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add spc alarm tag

for (i = 0; i < SPC_ALARM_TAG_NUM; i ++)

{

 memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

 sprintf(spcAlarmTagSave.szTagName, "szSPCAlarmTag_%d", i);

 strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

 spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

 strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

 strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

 strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

 spcAlarmTagSave.dUCLDefaultValue = 200;

 spcAlarmTagSave.dCLDefaultVaule = 100;

 spcAlarmTagSave.dLCLDefaultValue = 50;

 spcAlarmTagSave.bJudgeContinuous = true;

 spcAlarmTagSave.bRule1 = true;

 spcAlarmTagSave.nRule1M = 1;

 nRet = spc_add_tag(hServer, &spcAlarmTagSave,

  TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

  | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

 if (nRet != RD_SUCCESS)

 {

  printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

 nRet = spc_query_tagid(hServer, spcAlarmTagSave.szTagName, &nSPCTagIDs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query spc alarm tag id failed,  alarm spc name[%s], error code[%d]!\n", spcAlarmTagSave.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("spc alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  spcAlarmTagSave.szTagName, nSPCTagIDs[i]);

}

//reg spc alarm callback

spc_register_alarm_record_info(hServer, spc_record_callback);

//save snapshots generate spc alarm

for (i = 0; i < nRecNum; i++)

{

 snapshot.nSec =  i + 1;

 snapshot.nMsec = 0;

 snapshot.nQuality = 192;

 snapshot.value.nInt32 = 300;

 nRet = sn_save_snapshot(hServer, nSrcTagID, &snapshot);

 if (nRet != RD_SUCCESS)

 {

  printf("save snapshot failed, error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("save snapshot successful!\n");

 Sleep(10);

}

Sleep(3000);

//query alarm snapshot

nRet = spc_query_snapshots(hServer, SPC_ALARM_TAG_NUM, nSPCTagIDs,

 ALARM_REC_PROP_ALL, snSPCAlarms, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query alarm snapshots successful!\n");

}

else if (EC_HD_API_AM_QUERY_SNAPSHOTS_FAILED == nRet)

{

 for (i = 0; i < SPC_ALARM_TAG_NUM; i ++)

 {

  if (nErrorCodes[i] != RD_SUCCESS)

  {

   printf("query alarm tag[%d] snapshot failed, error code [%d]!\n", nSPCTagIDs[i], nErrorCodes[i]);

  }

 }

}

else

{

 printf("query alarm snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//ack alarms

for (i = 0; i < nRecNum; i++)

{

 alarmTimes[i].nSec = snSPCAlarms[i].tvStartTime.nSec;

 alarmTimes[i].nMsec = snSPCAlarms[i].tvStartTime.nMsec;

}

nRet = spc_acknowledge_alarms(hServer, nSPCTagIDs, alarmTimes,  SPC_ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("acknowledge alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("acknowledge alarms successful!\n");

//comment alarms

nRet = spc_comment_alarms(hServer, nSPCTagIDs, alarmTimes, "this is a comment", SPC_ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("comment alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("comment alarms successful!\n");

//query tag alarm records

queryCond.tvStart.nSec = 1;

queryCond.tvStart.nMsec = 0;

queryCond.tvEnd.nMsec =0;

queryCond.tvEnd.nSec =100;

queryCond.nAckMask = (int8)MASK_ALARM_ALL;

queryCond.nCommentMask = (int8)MASK_ALARM_ALL;

queryCond.nRestoreMask = (int8)MASK_ALARM_ALL;

nRet = spc_query_tag_records(hServer, nSPCTagIDs[0], &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags all records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query group alarm records

nRet = spc_query_group_records(hServer, 0, &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query group records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query tags alarm records

nRet = spc_query_tags_records(hServer, nSPCTagIDs, SPC_ALARM_TAG_NUM,

 &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//disconnect

nt_disconnect(hServer);

return 0;

}

?参见：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


spc_delete_tag

Navigation: »No topics above this level«

spc_delete_tag

 Return to chapter overview

spc_delete_tag

Glossary Item Box

函数

在一台服务器中删除一个spc报警点

int32 spc_delete_tag(

HDHANDLE hServer,

uint32 nTagID

);

参数

hServer

[in] 服务器句柄。

nTagID

[in] 报警点ID。

返回值

删除成功，返回RD_SUCCESS。删除失败返回其它错误码，见error_code.h。

说明

举例

demo

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statsTag;

SPCAlarmTagProp spcAlarmTagSave;

SPCAlarmTagProp spcAlarmTagQuery;

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

int32 nErrCode = 0;

char (*szTagNames)[HD_LEN_TAG_NAME] = NULL;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag as stats tag source tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add statistics tag

strcpy(statsTag.szTagName, "szStatsTag");

strcpy(statsTag.szSourceTagName, normalTag.szTagName);

statsTag.nScanPeriod = 60;

statsTag.nStatsType = HD_STATS_TYPE_MAX;

statsTag.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statsTag.nSampleInerval = 3600;

statsTag.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statsTag, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_NAME

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statsTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statsTag.szTagName);

//add one normal tag as spc tag ucl tag

strcpy(normalTag.szTagName, "szUCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add one normal tag as spc tag cl tag

strcpy(normalTag.szTagName, "szCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add one normal tag as spc tag lcl tag

strcpy(normalTag.szTagName, "szLCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add spc alarm tag

memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

strcpy(spcAlarmTagSave.szTagName, "szSPCAlarmTag_1");

strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

spcAlarmTagSave.dUCLDefaultValue = 200;

spcAlarmTagSave.dCLDefaultVaule = 100;

spcAlarmTagSave.dLCLDefaultValue = 50;

nRet = spc_add_tag(hServer, &spcAlarmTagSave,

 TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

 | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

if (nRet != RD_SUCCESS)

{

 printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

strcpy(spcAlarmTagSave.szTagName, "szSPCAlarmTag_2");

strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

spcAlarmTagSave.dUCLDefaultValue = 200;

spcAlarmTagSave.dCLDefaultVaule = 100;

spcAlarmTagSave.dLCLDefaultValue = 50;

nRet = spc_add_tag(hServer, &spcAlarmTagSave,

 TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

 | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

if (nRet != RD_SUCCESS)

{

 printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

//query spc tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_DIGITAL);

nRet = spc_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME| TAG_PROP_TIME_DEADBAND | TAG_PROP_VALUE_DEADBAND, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query spc tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query spc tag successful, tag name is %s!\n", spcAlarmTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query spc tag complete!\n");

  break;

 }

 else

 {

  printf("query spc tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you have queried %d spc alarm tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = spc_query_tagid(hServer, spcAlarmTagSave.szTagName, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query spc alarm tag id failed,  alarm spc name[%s], error code[%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("spc alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  spcAlarmTagSave.szTagName, nTagID);

//modify tag desc

strcpy(spcAlarmTagSave.szDescriptor, "spc tag descriptor is modified");

spcAlarmTagSave.bRule1 = true;

spcAlarmTagSave.nRule1M = 10;

nRet = spc_modify_tag_prop(hServer, nTagID, &spcAlarmTagSave, TAG_PROP_DESCRIPTOR|TAG_PROP_SPC_RULE);

if (nRet != RD_SUCCESS)

{

 printf("modify spc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify spc tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = spc_query_tag_prop(hServer, nTagID, &spcAlarmTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query spc tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query spc tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 spcAlarmTagQuery.nTagID, spcAlarmTagQuery.szTagName, spcAlarmTagQuery.szDescriptor);

//query tag names

szTagNames = new char[1][HD_LEN_TAG_NAME];

nRet = spc_query_tag_names(hServer, 1, &nTagID, szTagNames, &nErrCode);

if (RD_SUCCESS == nRet)

{

 printf("query spc alarm tag[id:%d] name[%s] successful!\n", nTagID, szTagNames[0]);

}

else if (EC_HD_API_AM_QUERY_TAG_NAMES_FAILED == nRet)

{

 printf("query spc tag names failed, tag id[%d], error code[%d]!\n", nTagID, nErrCode);

}

if (nRet != RD_SUCCESS)

{

 printf("query spc tag names failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 delete[] szTagNames;

 nt_disconnect(hServer);

 return -1;

}

delete[] szTagNames;

//delete spc tag

nRet = spc_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete spc alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete spc alarm tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

?参见：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


spc_modify_tag_prop

Navigation: »No topics above this level«

spc_modify_tag_prop

 Return to chapter overview

spc_modify_tag_prop

Glossary Item Box

函数

int32 spc_modify_tag_prop(

HDHANDLE hServer,

uint32 nTagID,

const SPCAlarmTagProp* pTagProp,

int64 nPropMask

);

参数

hServer

[in] 服务器句柄。

nTagID

[in] 报警点ID。

pTagProp

[in] 报警点属性。

nPropMask

[in] 报警点属性掩码。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h

说明

创建日期，修改日期，报警点ID，报警点名称，报警点类型，源点名称，控制图类型，触发模式不会被修改。

举例

spc_add_tag

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statsTag;

SPCAlarmTagProp spcAlarmTagSave;

SPCAlarmTagProp spcAlarmTagQuery;

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

int32 nErrCode = 0;

char (*szTagNames)[HD_LEN_TAG_NAME] = NULL;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag as stats tag source tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add statistics tag

strcpy(statsTag.szTagName, "szStatsTag");

strcpy(statsTag.szSourceTagName, normalTag.szTagName);

statsTag.nScanPeriod = 60;

statsTag.nStatsType = HD_STATS_TYPE_MAX;

statsTag.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statsTag.nSampleInerval = 3600;

statsTag.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statsTag, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_NAME

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statsTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statsTag.szTagName);

//add one normal tag as spc tag ucl tag

strcpy(normalTag.szTagName, "szUCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add one normal tag as spc tag cl tag

strcpy(normalTag.szTagName, "szCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add one normal tag as spc tag lcl tag

strcpy(normalTag.szTagName, "szLCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add spc alarm tag

memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

strcpy(spcAlarmTagSave.szTagName, "szSPCAlarmTag_1");

strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

spcAlarmTagSave.dUCLDefaultValue = 200;

spcAlarmTagSave.dCLDefaultVaule = 100;

spcAlarmTagSave.dLCLDefaultValue = 50;

nRet = spc_add_tag(hServer, &spcAlarmTagSave,

 TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

 | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

if (nRet != RD_SUCCESS)

{

 printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

strcpy(spcAlarmTagSave.szTagName, "szSPCAlarmTag_2");

strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

spcAlarmTagSave.dUCLDefaultValue = 200;

spcAlarmTagSave.dCLDefaultVaule = 100;

spcAlarmTagSave.dLCLDefaultValue = 50;

nRet = spc_add_tag(hServer, &spcAlarmTagSave,

 TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

 | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

if (nRet != RD_SUCCESS)

{

 printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

//query spc tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_DIGITAL);

nRet = spc_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME| TAG_PROP_TIME_DEADBAND | TAG_PROP_VALUE_DEADBAND, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query spc tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query spc tag successful, tag name is %s!\n", spcAlarmTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query spc tag complete!\n");

  break;

 }

 else

 {

  printf("query spc tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you have queried %d spc alarm tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = spc_query_tagid(hServer, spcAlarmTagSave.szTagName, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query spc alarm tag id failed,  alarm spc name[%s], error code[%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("spc alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  spcAlarmTagSave.szTagName, nTagID);

//modify tag desc

strcpy(spcAlarmTagSave.szDescriptor, "spc tag descriptor is modified");

spcAlarmTagSave.bRule1 = true;

spcAlarmTagSave.nRule1M = 10;

nRet = spc_modify_tag_prop(hServer, nTagID, &spcAlarmTagSave, TAG_PROP_DESCRIPTOR|TAG_PROP_SPC_RULE);

if (nRet != RD_SUCCESS)

{

 printf("modify spc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify spc tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = spc_query_tag_prop(hServer, nTagID, &spcAlarmTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query spc tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query spc tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 spcAlarmTagQuery.nTagID, spcAlarmTagQuery.szTagName, spcAlarmTagQuery.szDescriptor);

//query tag names

szTagNames = new char[1][HD_LEN_TAG_NAME];

nRet = spc_query_tag_names(hServer, 1, &nTagID, szTagNames, &nErrCode);

if (RD_SUCCESS == nRet)

{

 printf("query spc alarm tag[id:%d] name[%s] successful!\n", nTagID, szTagNames[0]);

}

else if (EC_HD_API_AM_QUERY_TAG_NAMES_FAILED == nRet)

{

 printf("query spc tag names failed, tag id[%d], error code[%d]!\n", nTagID, nErrCode);

}

if (nRet != RD_SUCCESS)

{

 printf("query spc tag names failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 delete[] szTagNames;

 nt_disconnect(hServer);

 return -1;

}

delete[] szTagNames;

//delete spc tag

nRet = spc_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete spc alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete spc alarm tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

?参见：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


spc_query_group_child_tags

Navigation: »No topics above this level«

spc_query_group_child_tags

 Return to chapter overview

spc_query_group_child_tags

Glossary Item Box

函数

在一台服务器中查询一个报警组下面的spc子报警点

int32 spc_query_group_child_tags(

HDHANDLE hServer,

uint32 nGroupID,

HDHANDLE* pHIter

);

参数

hServer

[in] 服务器句柄。

nGroupID

[in] 报警组ID。

pHIter

[out] 查询迭代器。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

说明

调用该接口成功后会获得一个查询迭代器的句柄，然后调用ut_get_item_step接口，传入迭代器句柄和分配的空间(uint32*)，返回RD_SUCCESS就可以获得第一个子报警点的ID，再调用ut_get_item_step返回RD_SUCCESS就可以获得第二个子报警点的ID。如此循环的查询直到调用ut_get_item_step返回错误码为EC_HD_API_QUERY_END表明所有的子报警点的ID都查询完毕了。查询完毕后调用ut_free_iterator方法来释放迭代器.

举例

demo

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

uint32 nOrphenGroupID = 0;

const int32 ALARM_GROUP_COUNT = 2;

uint32 nGroupIDs[ALARM_GROUP_COUNT] = {0};

HDAlarmGroup alarmGroups[ALARM_GROUP_COUNT];

int32 nErrCodes[ALARM_GROUP_COUNT];

TagProp normalTag;

HDHANDLE hIter = NULL;

uint32 nChildGroupID = 0;

uint32 nChildAlarmTagID = 0;

SPCAlarmTagProp spcAlarmTagSave;

StatsTagProp statsTag;

int32 i = 0;

memset(alarmGroups, 0, sizeof(alarmGroups));

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 sprintf(alarmGroups[i].szName, "alarm_group_name_%d", i);

 sprintf(alarmGroups[i].szDesc, "alarm_group_desc_%d", i);

 alarmGroups[i].nParentID = nOrphenGroupID;

 nRet = am_add_group(hServer, alarmGroups[i].szName, alarmGroups[i].szDesc, nOrphenGroupID);

 if (nRet != RD_SUCCESS)

 {

  printf("add alarm group[%s] failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add alarm group[%s] successful!\n",alarmGroups[i].szName);

}

//query alarm group id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_groupid(hServer, alarmGroups[i].szName, nOrphenGroupID, &(nGroupIDs[i]));

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [%s] id failed, error code [%d]!\n", alarmGroups[i].szName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%s] id successful!\n",alarmGroups[i].szName);

}

//query alarm group props

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 HDAlarmGroup queryAlarmGroups[ALARM_GROUP_COUNT];

 nRet = am_query_group_props(hServer, ALARM_GROUP_COUNT, nGroupIDs, queryAlarmGroups, nErrCodes);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] prop failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("query alarm group[%d] prop successful!\n",nGroupIDs[i]);

}

//modify alarm group name

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szName, "_modify");

 nRet = am_modify_group_name(hServer,nGroupIDs[i], alarmGroups[i].szName);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] name failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] name successful!\n",nGroupIDs[i]);

}

//modify alarm group desc

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 strcat(alarmGroups[i].szDesc, "_modify");

 nRet = am_modify_group_desc(hServer, nGroupIDs[i], alarmGroups[i].szDesc);

 if (nRet != RD_SUCCESS)

 {

  printf("modify alarm group [id:%d] desc failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("modify alarm group[id:%d] desc successful!\n",nGroupIDs[i]);

}

//modify alarm group parent id

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 if (i >= 1)

 {

  nRet = am_modify_group_parentid(hServer, nGroupIDs[i], nGroupIDs[i - 1]);

  if (nRet != RD_SUCCESS)

  {

   printf("modify alarm group [id:%d] parent id[%d] failed, error code [%d]!\n", nGroupIDs[i],  nGroupIDs[i - 1], nRet);

   nt_disconnect(hServer);

   return -1;

  }

  printf("modify alarm group[id:%d] parent id [%d] successful!\n",nGroupIDs[i], nGroupIDs[i - 1]);

 }

}

//query child alarm group

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_groups(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child group failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildGroupID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child group successful, child group id %d!\n", nGroupIDs[i], nChildGroupID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child group complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child group, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//add one normal tag as stats tag source tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add statistics tag

strcpy(statsTag.szTagName, "szStatsTag");

strcpy(statsTag.szSourceTagName, normalTag.szTagName);

statsTag.nScanPeriod = 60;

statsTag.nStatsType = HD_STATS_TYPE_MAX;

statsTag.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statsTag.nSampleInerval = 3600;

statsTag.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statsTag, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_NAME

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statsTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statsTag.szTagName);

//add one normal tag as spc tag ucl tag

strcpy(normalTag.szTagName, "szUCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add one normal tag as spc tag cl tag

strcpy(normalTag.szTagName, "szCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add one normal tag as spc tag lcl tag

strcpy(normalTag.szTagName, "szLCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add spc alarm tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

 sprintf(spcAlarmTagSave.szTagName, "szSPCAlarmTag_%d", i);

 strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

 spcAlarmTagSave.nAlarmGroupID = nGroupIDs[i];

 spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

 strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

 strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

 strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

 spcAlarmTagSave.dUCLDefaultValue = 200;

 spcAlarmTagSave.dCLDefaultVaule = 100;

 spcAlarmTagSave.dLCLDefaultValue = 50;

 nRet = spc_add_tag(hServer, &spcAlarmTagSave,

  TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME | TAG_PROP_SPC_ALARM_GROUP_ID

  | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

 if (nRet != RD_SUCCESS)

 {

  printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

}

//query alarm group tag

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_query_group_child_tags(hServer, nGroupIDs[i], &hIter);

 if (nRet != RD_SUCCESS)

 {

  printf("query alarm group [id:%d] child tags failed, error code [%d]!\n", nGroupIDs[i], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 while (true)

 {

  nRet = ut_get_item_step(hIter, &nChildAlarmTagID);

  if (RD_SUCCESS == nRet)

  {

   printf("query alarm group [id:%d] child tag successful, child tag id %d!\n", nGroupIDs[i], nChildAlarmTagID);

   nRet = spc_delete_tag(hServer, nChildAlarmTagID);

   if (nRet != RD_SUCCESS)

   {

    printf("delete alarm tag [id:%d] failed, error code [%d]!\n", nChildAlarmTagID, nRet);

    ut_free_iterator(hIter);

    nt_disconnect(hServer);

    return -1;

   }

   printf("delete alarm tag [id:%d] successful!\n", nChildAlarmTagID);

  }

  else if (EC_HD_API_QUERY_END == nRet)

  {

   printf("query alarm group [id:%d] child tag complete!\n", nGroupIDs[i]);

   break;

  }

  else

  {

   printf("query alarm group [id:%d] child tag, error code [%d]!\n", nGroupIDs[i], nRet);

   break;

  }

 }

 ut_free_iterator(hIter);

}

//delete alarm groups

for (i = 0; i < ALARM_GROUP_COUNT; i ++)

{

 nRet = am_delete_group(hServer, nGroupIDs[ALARM_GROUP_COUNT - i - 1]);

 if (nRet != RD_SUCCESS)

 {

  printf("delete alarm group [id:%d] failed, error code [%d]!\n", nGroupIDs[ALARM_GROUP_COUNT - i - 1], nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("delete alarm group [id:%d] successful!\n", nChildAlarmTagID);

}

//disconnect

nt_disconnect(hServer);

return 0;

}

?参见：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


spc_query_group_records

Navigation: »No topics above this level«

spc_query_group_records

 Return to chapter overview

spc_query_group_records

Glossary Item Box

函数

int32 spc_query_group_records(

HDHANDLE hServer,

uint32 nAlarmGroupID,

const HDAlarmQuery* pQueryCond,

int64 nPropMask,

HDHANDLE* pHIter

);

参数

hServer

[in] 服务器句柄

nAlarmGroupID

[in] 报警组ID

pQueryCond

[in] 查询条件

nPropMask

[in] 返回的报警记录的属性掩码

pHIter

[out] 报警记录迭代器句柄,查询的报警记录包括实时记录和历史记录

返回值

查询成功,返回RD_SUCCESS,查询失败返回其他错误码,见error_code.h

举例

spc_query_group_records

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

#include <windows.h>

void spc_record_callback(HDHANDLE hServer, int8 nType, const HDSPCAlarmRecord* spcAlarm)

{

printf("spc alarm occer, nType %d, tag id %d, time %d\n", nType, spcAlarm->nSPCTagID, spcAlarm->tvStartTime.nSec);

}

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "168.2.237.35";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statsTag;

SPCAlarmTagProp spcAlarmTagSave;

int32 nRecNum = 4;

const int32 SPC_ALARM_TAG_NUM = 4;

uint32 nSPCTagIDs[SPC_ALARM_TAG_NUM];

HDSPCAlarmQuery queryCond;

HDRecord snapshot;

HDHANDLE hIter = NULL;

HDSPCAlarmRecord spcAlarmRec;

HDSPCAlarmRecord snSPCAlarms[SPC_ALARM_TAG_NUM];

int32 nErrorCodes[SPC_ALARM_TAG_NUM];

HDTime alarmTimes[SPC_ALARM_TAG_NUM];

int32 i = 0;

uint32 nSrcTagID = 0;

uint32 nUCLTagID = 0;

uint32 nCLTagID = 0;

uint32 nLCLTagID = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

nRet = sc_login(hServer, "admin", "admin");

// add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nSrcTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

//add statistics tag

strcpy(statsTag.szTagName, "szStatsTag");

strcpy(statsTag.szSourceTagName, normalTag.szTagName);

statsTag.nScanPeriod = 1;

statsTag.nStatsType = HD_STATS_TYPE_MAX;

statsTag.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statsTag.nSampleInerval = 1;

statsTag.nSampleStartDate = 1;

statsTag.bBeginTimeStamp = true;

nRet = st_add_tag(hServer, &statsTag, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_NAME

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE

 |TAG_PROP_STATS_BEGIN_TIME_STAMP);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statsTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statsTag.szTagName);

//add one normal tag as spc tag ucl tag

strcpy(normalTag.szTagName, "szUCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nUCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 200;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nUCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add one normal tag as spc tag cl tag

strcpy(normalTag.szTagName, "szCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 100;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add one normal tag as spc tag lcl tag

strcpy(normalTag.szTagName, "szLCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nLCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 50;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nLCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add spc alarm tag

for (i = 0; i < SPC_ALARM_TAG_NUM; i ++)

{

 memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

 sprintf(spcAlarmTagSave.szTagName, "szSPCAlarmTag_%d", i);

 strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

 spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

 strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

 strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

 strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

 spcAlarmTagSave.dUCLDefaultValue = 200;

 spcAlarmTagSave.dCLDefaultVaule = 100;

 spcAlarmTagSave.dLCLDefaultValue = 50;

 spcAlarmTagSave.bJudgeContinuous = true;

 spcAlarmTagSave.bRule1 = true;

 spcAlarmTagSave.nRule1M = 1;

 nRet = spc_add_tag(hServer, &spcAlarmTagSave,

  TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

  | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

 if (nRet != RD_SUCCESS)

 {

  printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

 nRet = spc_query_tagid(hServer, spcAlarmTagSave.szTagName, &nSPCTagIDs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query spc alarm tag id failed,  alarm spc name[%s], error code[%d]!\n", spcAlarmTagSave.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("spc alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  spcAlarmTagSave.szTagName, nSPCTagIDs[i]);

}

//reg spc alarm callback

spc_register_alarm_record_info(hServer, spc_record_callback);

//save snapshots generate spc alarm

for (i = 0; i < nRecNum; i++)

{

 snapshot.nSec =  i + 1;

 snapshot.nMsec = 0;

 snapshot.nQuality = 192;

 snapshot.value.nInt32 = 300;

 nRet = sn_save_snapshot(hServer, nSrcTagID, &snapshot);

 if (nRet != RD_SUCCESS)

 {

  printf("save snapshot failed, error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("save snapshot successful!\n");

 Sleep(10);

}

Sleep(3000);

//query alarm snapshot

nRet = spc_query_snapshots(hServer, SPC_ALARM_TAG_NUM, nSPCTagIDs,

 ALARM_REC_PROP_ALL, snSPCAlarms, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query alarm snapshots successful!\n");

}

else if (EC_HD_API_AM_QUERY_SNAPSHOTS_FAILED == nRet)

{

 for (i = 0; i < SPC_ALARM_TAG_NUM; i ++)

 {

  if (nErrorCodes[i] != RD_SUCCESS)

  {

   printf("query alarm tag[%d] snapshot failed, error code [%d]!\n", nSPCTagIDs[i], nErrorCodes[i]);

  }

 }

}

else

{

 printf("query alarm snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//ack alarms

for (i = 0; i < nRecNum; i++)

{

 alarmTimes[i].nSec = snSPCAlarms[i].tvStartTime.nSec;

 alarmTimes[i].nMsec = snSPCAlarms[i].tvStartTime.nMsec;

}

nRet = spc_acknowledge_alarms(hServer, nSPCTagIDs, alarmTimes,  SPC_ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("acknowledge alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("acknowledge alarms successful!\n");

//comment alarms

nRet = spc_comment_alarms(hServer, nSPCTagIDs, alarmTimes, "this is a comment", SPC_ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("comment alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("comment alarms successful!\n");

//query tag alarm records

queryCond.tvStart.nSec = 1;

queryCond.tvStart.nMsec = 0;

queryCond.tvEnd.nMsec =0;

queryCond.tvEnd.nSec =100;

queryCond.nAckMask = (int8)MASK_ALARM_ALL;

queryCond.nCommentMask = (int8)MASK_ALARM_ALL;

queryCond.nRestoreMask = (int8)MASK_ALARM_ALL;

nRet = spc_query_tag_records(hServer, nSPCTagIDs[0], &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags all records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query group alarm records

nRet = spc_query_group_records(hServer, 0, &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query group records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query tags alarm records

nRet = spc_query_tags_records(hServer, nSPCTagIDs, SPC_ALARM_TAG_NUM,

 &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//disconnect

nt_disconnect(hServer);

return 0;

}

?参见：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


spc_query_snapshots

Navigation: »No topics above this level«

spc_query_snapshots

 Return to chapter overview

spc_query_snapshots

Glossary Item Box

函数

在一台服务器中查询多个spc报警点的实时报警记录

int32 spc_query_snapshots(

HDHANDLE hServer,

int32 nRecNum,

uint32 nTagIDs[],

int64 nPropMask,

HDSPCAlarmRecord alarmRecords[],

int32 nErrCodes[]

);

参数

hServer

[in] 服务器句柄。

nRecNum

[in] 报警点个数。

nTagIDs

[in] 报警点ID数组。

nPropMask

[in]返回的报警记录的属性掩码

alarmRecords

[out] 报警记录数组。

nErrCodes

[out] 错误码数组。

返回值

查询成功，返回RD_SUCCESS。一部分成功返回EC_HD_API_SPC_QUERY_SNAPSHOTS_FAILED，查询失败返回其它错误码，见error_code.h。

说明

举例

spc_query_snapshots

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

#include <windows.h>

void spc_record_callback(HDHANDLE hServer, int8 nType, const HDSPCAlarmRecord* spcAlarm)

{

printf("spc alarm occer, nType %d, tag id %d, time %d\n", nType, spcAlarm->nSPCTagID, spcAlarm->tvStartTime.nSec);

}

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "168.2.237.35";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statsTag;

SPCAlarmTagProp spcAlarmTagSave;

int32 nRecNum = 4;

const int32 SPC_ALARM_TAG_NUM = 4;

uint32 nSPCTagIDs[SPC_ALARM_TAG_NUM];

HDSPCAlarmQuery queryCond;

HDRecord snapshot;

HDHANDLE hIter = NULL;

HDSPCAlarmRecord spcAlarmRec;

HDSPCAlarmRecord snSPCAlarms[SPC_ALARM_TAG_NUM];

int32 nErrorCodes[SPC_ALARM_TAG_NUM];

HDTime alarmTimes[SPC_ALARM_TAG_NUM];

int32 i = 0;

uint32 nSrcTagID = 0;

uint32 nUCLTagID = 0;

uint32 nCLTagID = 0;

uint32 nLCLTagID = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

nRet = sc_login(hServer, "admin", "admin");

// add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nSrcTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

//add statistics tag

strcpy(statsTag.szTagName, "szStatsTag");

strcpy(statsTag.szSourceTagName, normalTag.szTagName);

statsTag.nScanPeriod = 1;

statsTag.nStatsType = HD_STATS_TYPE_MAX;

statsTag.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statsTag.nSampleInerval = 1;

statsTag.nSampleStartDate = 1;

statsTag.bBeginTimeStamp = true;

nRet = st_add_tag(hServer, &statsTag, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_NAME

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE

 |TAG_PROP_STATS_BEGIN_TIME_STAMP);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statsTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statsTag.szTagName);

//add one normal tag as spc tag ucl tag

strcpy(normalTag.szTagName, "szUCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nUCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 200;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nUCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add one normal tag as spc tag cl tag

strcpy(normalTag.szTagName, "szCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 100;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add one normal tag as spc tag lcl tag

strcpy(normalTag.szTagName, "szLCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nLCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 50;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nLCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add spc alarm tag

for (i = 0; i < SPC_ALARM_TAG_NUM; i ++)

{

 memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

 sprintf(spcAlarmTagSave.szTagName, "szSPCAlarmTag_%d", i);

 strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

 spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

 strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

 strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

 strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

 spcAlarmTagSave.dUCLDefaultValue = 200;

 spcAlarmTagSave.dCLDefaultVaule = 100;

 spcAlarmTagSave.dLCLDefaultValue = 50;

 spcAlarmTagSave.bJudgeContinuous = true;

 spcAlarmTagSave.bRule1 = true;

 spcAlarmTagSave.nRule1M = 1;

 nRet = spc_add_tag(hServer, &spcAlarmTagSave,

  TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

  | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

 if (nRet != RD_SUCCESS)

 {

  printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

 nRet = spc_query_tagid(hServer, spcAlarmTagSave.szTagName, &nSPCTagIDs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query spc alarm tag id failed,  alarm spc name[%s], error code[%d]!\n", spcAlarmTagSave.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("spc alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  spcAlarmTagSave.szTagName, nSPCTagIDs[i]);

}

//reg spc alarm callback

spc_register_alarm_record_info(hServer, spc_record_callback);

//save snapshots generate spc alarm

for (i = 0; i < nRecNum; i++)

{

 snapshot.nSec =  i + 1;

 snapshot.nMsec = 0;

 snapshot.nQuality = 192;

 snapshot.value.nInt32 = 300;

 nRet = sn_save_snapshot(hServer, nSrcTagID, &snapshot);

 if (nRet != RD_SUCCESS)

 {

  printf("save snapshot failed, error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("save snapshot successful!\n");

 Sleep(10);

}

Sleep(3000);

//query alarm snapshot

nRet = spc_query_snapshots(hServer, SPC_ALARM_TAG_NUM, nSPCTagIDs,

 ALARM_REC_PROP_ALL, snSPCAlarms, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query alarm snapshots successful!\n");

}

else if (EC_HD_API_AM_QUERY_SNAPSHOTS_FAILED == nRet)

{

 for (i = 0; i < SPC_ALARM_TAG_NUM; i ++)

 {

  if (nErrorCodes[i] != RD_SUCCESS)

  {

   printf("query alarm tag[%d] snapshot failed, error code [%d]!\n", nSPCTagIDs[i], nErrorCodes[i]);

  }

 }

}

else

{

 printf("query alarm snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//ack alarms

for (i = 0; i < nRecNum; i++)

{

 alarmTimes[i].nSec = snSPCAlarms[i].tvStartTime.nSec;

 alarmTimes[i].nMsec = snSPCAlarms[i].tvStartTime.nMsec;

}

nRet = spc_acknowledge_alarms(hServer, nSPCTagIDs, alarmTimes,  SPC_ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("acknowledge alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("acknowledge alarms successful!\n");

//comment alarms

nRet = spc_comment_alarms(hServer, nSPCTagIDs, alarmTimes, "this is a comment", SPC_ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("comment alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("comment alarms successful!\n");

//query tag alarm records

queryCond.tvStart.nSec = 1;

queryCond.tvStart.nMsec = 0;

queryCond.tvEnd.nMsec =0;

queryCond.tvEnd.nSec =100;

queryCond.nAckMask = (int8)MASK_ALARM_ALL;

queryCond.nCommentMask = (int8)MASK_ALARM_ALL;

queryCond.nRestoreMask = (int8)MASK_ALARM_ALL;

nRet = spc_query_tag_records(hServer, nSPCTagIDs[0], &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags all records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query group alarm records

nRet = spc_query_group_records(hServer, 0, &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query group records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query tags alarm records

nRet = spc_query_tags_records(hServer, nSPCTagIDs, SPC_ALARM_TAG_NUM,

 &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//disconnect

nt_disconnect(hServer);

return 0;

}

?参见：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


spc_query_tagid

Navigation: »No topics above this level«

spc_query_tagid

 Return to chapter overview

spc_query_tagid

Glossary Item Box

函数

在一台服务器中通过SPC报警点的名称查询该报警点的ID

int32 spc_query_tagid(

HDHANDLE hServer,

const char* szName,

uint32* pTagID

);

参数

hServer

[in] 服务器句柄。

szName

[in] 报警点名称。

pTagID

[out] 报警点ID。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

举例

demo

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statsTag;

SPCAlarmTagProp spcAlarmTagSave;

SPCAlarmTagProp spcAlarmTagQuery;

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

int32 nErrCode = 0;

char (*szTagNames)[HD_LEN_TAG_NAME] = NULL;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag as stats tag source tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add statistics tag

strcpy(statsTag.szTagName, "szStatsTag");

strcpy(statsTag.szSourceTagName, normalTag.szTagName);

statsTag.nScanPeriod = 60;

statsTag.nStatsType = HD_STATS_TYPE_MAX;

statsTag.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statsTag.nSampleInerval = 3600;

statsTag.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statsTag, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_NAME

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statsTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statsTag.szTagName);

//add one normal tag as spc tag ucl tag

strcpy(normalTag.szTagName, "szUCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add one normal tag as spc tag cl tag

strcpy(normalTag.szTagName, "szCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add one normal tag as spc tag lcl tag

strcpy(normalTag.szTagName, "szLCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add spc alarm tag

memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

strcpy(spcAlarmTagSave.szTagName, "szSPCAlarmTag_1");

strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

spcAlarmTagSave.dUCLDefaultValue = 200;

spcAlarmTagSave.dCLDefaultVaule = 100;

spcAlarmTagSave.dLCLDefaultValue = 50;

nRet = spc_add_tag(hServer, &spcAlarmTagSave,

 TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

 | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

if (nRet != RD_SUCCESS)

{

 printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

strcpy(spcAlarmTagSave.szTagName, "szSPCAlarmTag_2");

strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

spcAlarmTagSave.dUCLDefaultValue = 200;

spcAlarmTagSave.dCLDefaultVaule = 100;

spcAlarmTagSave.dLCLDefaultValue = 50;

nRet = spc_add_tag(hServer, &spcAlarmTagSave,

 TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

 | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

if (nRet != RD_SUCCESS)

{

 printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

//query spc tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_DIGITAL);

nRet = spc_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME| TAG_PROP_TIME_DEADBAND | TAG_PROP_VALUE_DEADBAND, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query spc tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query spc tag successful, tag name is %s!\n", spcAlarmTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query spc tag complete!\n");

  break;

 }

 else

 {

  printf("query spc tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you have queried %d spc alarm tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = spc_query_tagid(hServer, spcAlarmTagSave.szTagName, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query spc alarm tag id failed,  alarm spc name[%s], error code[%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("spc alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  spcAlarmTagSave.szTagName, nTagID);

//modify tag desc

strcpy(spcAlarmTagSave.szDescriptor, "spc tag descriptor is modified");

spcAlarmTagSave.bRule1 = true;

spcAlarmTagSave.nRule1M = 10;

nRet = spc_modify_tag_prop(hServer, nTagID, &spcAlarmTagSave, TAG_PROP_DESCRIPTOR|TAG_PROP_SPC_RULE);

if (nRet != RD_SUCCESS)

{

 printf("modify spc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify spc tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = spc_query_tag_prop(hServer, nTagID, &spcAlarmTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query spc tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query spc tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 spcAlarmTagQuery.nTagID, spcAlarmTagQuery.szTagName, spcAlarmTagQuery.szDescriptor);

//query tag names

szTagNames = new char[1][HD_LEN_TAG_NAME];

nRet = spc_query_tag_names(hServer, 1, &nTagID, szTagNames, &nErrCode);

if (RD_SUCCESS == nRet)

{

 printf("query spc alarm tag[id:%d] name[%s] successful!\n", nTagID, szTagNames[0]);

}

else if (EC_HD_API_AM_QUERY_TAG_NAMES_FAILED == nRet)

{

 printf("query spc tag names failed, tag id[%d], error code[%d]!\n", nTagID, nErrCode);

}

if (nRet != RD_SUCCESS)

{

 printf("query spc tag names failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 delete[] szTagNames;

 nt_disconnect(hServer);

 return -1;

}

delete[] szTagNames;

//delete spc tag

nRet = spc_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete spc alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete spc alarm tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

?参见：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


spc_query_tag_names

Navigation: »No topics above this level«

spc_query_tag_names

 Return to chapter overview

spc_query_tag_names

Glossary Item Box

函数

在一台服务器中查询多个spc报警点的名称

int32 spc_query_tag_names(

HDHANDLE hServer,

int32 nTagNum,

uint32 nTagIDs[],

char szTagNames[][HD_LEN_TAG_NAME],

int32 nErrCodes[]

);

参数

hServer

[in] 服务器句柄。

nTagNum

[in] 报警点个数。

nTagIDs

[in] 报警点ID数组。

szTagNames

[out] 报警点名称数组。

nErrCodes

[out] 错误码数组。

返回值

查询成功，返回RD_SUCCESS。一部分成功返回EC_HD_API_SPC_QUERY_TAG_NAMES_FAILED，查询失败返回其它错误码，见error_code.h。

说明

返回RD_SUCCESS表明所有的报警点的名称查询都成功。

返回EC_HD_API_SPC_QUERY_TAG_NAMES_FAILED表明一部分报警点的名称查询成功，通过查询错误码数组nErrCodes[]可以知道哪些报警点查询成功。

返回其它错误码表明查询失败。

举例

demo

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statsTag;

SPCAlarmTagProp spcAlarmTagSave;

SPCAlarmTagProp spcAlarmTagQuery;

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

int32 nErrCode = 0;

char (*szTagNames)[HD_LEN_TAG_NAME] = NULL;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag as stats tag source tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add statistics tag

strcpy(statsTag.szTagName, "szStatsTag");

strcpy(statsTag.szSourceTagName, normalTag.szTagName);

statsTag.nScanPeriod = 60;

statsTag.nStatsType = HD_STATS_TYPE_MAX;

statsTag.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statsTag.nSampleInerval = 3600;

statsTag.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statsTag, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_NAME

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statsTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statsTag.szTagName);

//add one normal tag as spc tag ucl tag

strcpy(normalTag.szTagName, "szUCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add one normal tag as spc tag cl tag

strcpy(normalTag.szTagName, "szCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add one normal tag as spc tag lcl tag

strcpy(normalTag.szTagName, "szLCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add spc alarm tag

memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

strcpy(spcAlarmTagSave.szTagName, "szSPCAlarmTag_1");

strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

spcAlarmTagSave.dUCLDefaultValue = 200;

spcAlarmTagSave.dCLDefaultVaule = 100;

spcAlarmTagSave.dLCLDefaultValue = 50;

nRet = spc_add_tag(hServer, &spcAlarmTagSave,

 TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

 | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

if (nRet != RD_SUCCESS)

{

 printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

strcpy(spcAlarmTagSave.szTagName, "szSPCAlarmTag_2");

strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

spcAlarmTagSave.dUCLDefaultValue = 200;

spcAlarmTagSave.dCLDefaultVaule = 100;

spcAlarmTagSave.dLCLDefaultValue = 50;

nRet = spc_add_tag(hServer, &spcAlarmTagSave,

 TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

 | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

if (nRet != RD_SUCCESS)

{

 printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

//query spc tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_DIGITAL);

nRet = spc_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME| TAG_PROP_TIME_DEADBAND | TAG_PROP_VALUE_DEADBAND, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query spc tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query spc tag successful, tag name is %s!\n", spcAlarmTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query spc tag complete!\n");

  break;

 }

 else

 {

  printf("query spc tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you have queried %d spc alarm tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = spc_query_tagid(hServer, spcAlarmTagSave.szTagName, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query spc alarm tag id failed,  alarm spc name[%s], error code[%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("spc alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  spcAlarmTagSave.szTagName, nTagID);

//modify tag desc

strcpy(spcAlarmTagSave.szDescriptor, "spc tag descriptor is modified");

spcAlarmTagSave.bRule1 = true;

spcAlarmTagSave.nRule1M = 10;

nRet = spc_modify_tag_prop(hServer, nTagID, &spcAlarmTagSave, TAG_PROP_DESCRIPTOR|TAG_PROP_SPC_RULE);

if (nRet != RD_SUCCESS)

{

 printf("modify spc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify spc tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = spc_query_tag_prop(hServer, nTagID, &spcAlarmTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query spc tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query spc tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 spcAlarmTagQuery.nTagID, spcAlarmTagQuery.szTagName, spcAlarmTagQuery.szDescriptor);

//query tag names

szTagNames = new char[1][HD_LEN_TAG_NAME];

nRet = spc_query_tag_names(hServer, 1, &nTagID, szTagNames, &nErrCode);

if (RD_SUCCESS == nRet)

{

 printf("query spc alarm tag[id:%d] name[%s] successful!\n", nTagID, szTagNames[0]);

}

else if (EC_HD_API_AM_QUERY_TAG_NAMES_FAILED == nRet)

{

 printf("query spc tag names failed, tag id[%d], error code[%d]!\n", nTagID, nErrCode);

}

if (nRet != RD_SUCCESS)

{

 printf("query spc tag names failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 delete[] szTagNames;

 nt_disconnect(hServer);

 return -1;

}

delete[] szTagNames;

//delete spc tag

nRet = spc_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete spc alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete spc alarm tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

?参见：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


spc_query_tag_prop

Navigation: »No topics above this level«

spc_query_tag_prop

 Return to chapter overview

spc_query_tag_prop

Glossary Item Box

函数

在一台服务器中查询一个SPC报警点的属性

int32 spc_query_tag_prop(

HDHANDLE hServer,

uint32 nTagID,

SPCAlarmTagProp* pTagProp

);

参数

hServer

[in] 服务器句柄。

nTagID

[in] 报警点ID。

pTagProp

[out] SPC报警点属性。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

说明

举例

demo

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statsTag;

SPCAlarmTagProp spcAlarmTagSave;

SPCAlarmTagProp spcAlarmTagQuery;

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

int32 nErrCode = 0;

char (*szTagNames)[HD_LEN_TAG_NAME] = NULL;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag as stats tag source tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add statistics tag

strcpy(statsTag.szTagName, "szStatsTag");

strcpy(statsTag.szSourceTagName, normalTag.szTagName);

statsTag.nScanPeriod = 60;

statsTag.nStatsType = HD_STATS_TYPE_MAX;

statsTag.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statsTag.nSampleInerval = 3600;

statsTag.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statsTag, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_NAME

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statsTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statsTag.szTagName);

//add one normal tag as spc tag ucl tag

strcpy(normalTag.szTagName, "szUCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add one normal tag as spc tag cl tag

strcpy(normalTag.szTagName, "szCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add one normal tag as spc tag lcl tag

strcpy(normalTag.szTagName, "szLCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add spc alarm tag

memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

strcpy(spcAlarmTagSave.szTagName, "szSPCAlarmTag_1");

strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

spcAlarmTagSave.dUCLDefaultValue = 200;

spcAlarmTagSave.dCLDefaultVaule = 100;

spcAlarmTagSave.dLCLDefaultValue = 50;

nRet = spc_add_tag(hServer, &spcAlarmTagSave,

 TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

 | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

if (nRet != RD_SUCCESS)

{

 printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

strcpy(spcAlarmTagSave.szTagName, "szSPCAlarmTag_2");

strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

spcAlarmTagSave.dUCLDefaultValue = 200;

spcAlarmTagSave.dCLDefaultVaule = 100;

spcAlarmTagSave.dLCLDefaultValue = 50;

nRet = spc_add_tag(hServer, &spcAlarmTagSave,

 TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

 | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

if (nRet != RD_SUCCESS)

{

 printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

//query spc tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_DIGITAL);

nRet = spc_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME| TAG_PROP_TIME_DEADBAND | TAG_PROP_VALUE_DEADBAND, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query spc tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query spc tag successful, tag name is %s!\n", spcAlarmTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query spc tag complete!\n");

  break;

 }

 else

 {

  printf("query spc tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you have queried %d spc alarm tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = spc_query_tagid(hServer, spcAlarmTagSave.szTagName, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query spc alarm tag id failed,  alarm spc name[%s], error code[%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("spc alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  spcAlarmTagSave.szTagName, nTagID);

//modify tag desc

strcpy(spcAlarmTagSave.szDescriptor, "spc tag descriptor is modified");

spcAlarmTagSave.bRule1 = true;

spcAlarmTagSave.nRule1M = 10;

nRet = spc_modify_tag_prop(hServer, nTagID, &spcAlarmTagSave, TAG_PROP_DESCRIPTOR|TAG_PROP_SPC_RULE);

if (nRet != RD_SUCCESS)

{

 printf("modify spc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify spc tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = spc_query_tag_prop(hServer, nTagID, &spcAlarmTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query spc tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query spc tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 spcAlarmTagQuery.nTagID, spcAlarmTagQuery.szTagName, spcAlarmTagQuery.szDescriptor);

//query tag names

szTagNames = new char[1][HD_LEN_TAG_NAME];

nRet = spc_query_tag_names(hServer, 1, &nTagID, szTagNames, &nErrCode);

if (RD_SUCCESS == nRet)

{

 printf("query spc alarm tag[id:%d] name[%s] successful!\n", nTagID, szTagNames[0]);

}

else if (EC_HD_API_AM_QUERY_TAG_NAMES_FAILED == nRet)

{

 printf("query spc tag names failed, tag id[%d], error code[%d]!\n", nTagID, nErrCode);

}

if (nRet != RD_SUCCESS)

{

 printf("query spc tag names failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 delete[] szTagNames;

 nt_disconnect(hServer);

 return -1;

}

delete[] szTagNames;

//delete spc tag

nRet = spc_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete spc alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete spc alarm tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

?参见：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


spc_query_tag_records

Navigation: »No topics above this level«

spc_query_tag_records

 Return to chapter overview

spc_query_tag_records

Glossary Item Box

函数

查询多个SPC报警点的报警记录

int32 spc_query_tag_records(

HDHANDLE hServer,

uint32 nTagID,

const HDAlarmQuery* pQueryCond,

int64 nPropMask,

HDHANDLE* pHIter

);

参数

hServer

[in] 服务器句柄

nTagID

[in] 报警点ID数组

nTagNum

[in] 报警点数组个数

pQueryCond

[in] 查询条件

nPropMask

[in] 返回的报警记录的属性掩码

pHIter

[out] 报警记录迭代器句柄,查询的报警记录包括实时记录和历史记录

返回值

查询成功,返回RD_SUCCESS,查询失败返回其他错误码,见error.h

举例

spc_query_tag_records

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

#include <windows.h>

void spc_record_callback(HDHANDLE hServer, int8 nType, const HDSPCAlarmRecord* spcAlarm)

{

printf("spc alarm occer, nType %d, tag id %d, time %d\n", nType, spcAlarm->nSPCTagID, spcAlarm->tvStartTime.nSec);

}

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "168.2.237.35";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statsTag;

SPCAlarmTagProp spcAlarmTagSave;

int32 nRecNum = 4;

const int32 SPC_ALARM_TAG_NUM = 4;

uint32 nSPCTagIDs[SPC_ALARM_TAG_NUM];

HDSPCAlarmQuery queryCond;

HDRecord snapshot;

HDHANDLE hIter = NULL;

HDSPCAlarmRecord spcAlarmRec;

HDSPCAlarmRecord snSPCAlarms[SPC_ALARM_TAG_NUM];

int32 nErrorCodes[SPC_ALARM_TAG_NUM];

HDTime alarmTimes[SPC_ALARM_TAG_NUM];

int32 i = 0;

uint32 nSrcTagID = 0;

uint32 nUCLTagID = 0;

uint32 nCLTagID = 0;

uint32 nLCLTagID = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

nRet = sc_login(hServer, "admin", "admin");

// add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nSrcTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

//add statistics tag

strcpy(statsTag.szTagName, "szStatsTag");

strcpy(statsTag.szSourceTagName, normalTag.szTagName);

statsTag.nScanPeriod = 1;

statsTag.nStatsType = HD_STATS_TYPE_MAX;

statsTag.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statsTag.nSampleInerval = 1;

statsTag.nSampleStartDate = 1;

statsTag.bBeginTimeStamp = true;

nRet = st_add_tag(hServer, &statsTag, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_NAME

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE

 |TAG_PROP_STATS_BEGIN_TIME_STAMP);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statsTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statsTag.szTagName);

//add one normal tag as spc tag ucl tag

strcpy(normalTag.szTagName, "szUCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nUCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 200;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nUCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add one normal tag as spc tag cl tag

strcpy(normalTag.szTagName, "szCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 100;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add one normal tag as spc tag lcl tag

strcpy(normalTag.szTagName, "szLCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nLCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 50;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nLCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add spc alarm tag

for (i = 0; i < SPC_ALARM_TAG_NUM; i ++)

{

 memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

 sprintf(spcAlarmTagSave.szTagName, "szSPCAlarmTag_%d", i);

 strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

 spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

 strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

 strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

 strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

 spcAlarmTagSave.dUCLDefaultValue = 200;

 spcAlarmTagSave.dCLDefaultVaule = 100;

 spcAlarmTagSave.dLCLDefaultValue = 50;

 spcAlarmTagSave.bJudgeContinuous = true;

 spcAlarmTagSave.bRule1 = true;

 spcAlarmTagSave.nRule1M = 1;

 nRet = spc_add_tag(hServer, &spcAlarmTagSave,

  TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

  | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

 if (nRet != RD_SUCCESS)

 {

  printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

 nRet = spc_query_tagid(hServer, spcAlarmTagSave.szTagName, &nSPCTagIDs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query spc alarm tag id failed,  alarm spc name[%s], error code[%d]!\n", spcAlarmTagSave.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("spc alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  spcAlarmTagSave.szTagName, nSPCTagIDs[i]);

}

//reg spc alarm callback

spc_register_alarm_record_info(hServer, spc_record_callback);

//save snapshots generate spc alarm

for (i = 0; i < nRecNum; i++)

{

 snapshot.nSec =  i + 1;

 snapshot.nMsec = 0;

 snapshot.nQuality = 192;

 snapshot.value.nInt32 = 300;

 nRet = sn_save_snapshot(hServer, nSrcTagID, &snapshot);

 if (nRet != RD_SUCCESS)

 {

  printf("save snapshot failed, error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("save snapshot successful!\n");

 Sleep(10);

}

Sleep(3000);

//query alarm snapshot

nRet = spc_query_snapshots(hServer, SPC_ALARM_TAG_NUM, nSPCTagIDs,

 ALARM_REC_PROP_ALL, snSPCAlarms, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query alarm snapshots successful!\n");

}

else if (EC_HD_API_AM_QUERY_SNAPSHOTS_FAILED == nRet)

{

 for (i = 0; i < SPC_ALARM_TAG_NUM; i ++)

 {

  if (nErrorCodes[i] != RD_SUCCESS)

  {

   printf("query alarm tag[%d] snapshot failed, error code [%d]!\n", nSPCTagIDs[i], nErrorCodes[i]);

  }

 }

}

else

{

 printf("query alarm snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//ack alarms

for (i = 0; i < nRecNum; i++)

{

 alarmTimes[i].nSec = snSPCAlarms[i].tvStartTime.nSec;

 alarmTimes[i].nMsec = snSPCAlarms[i].tvStartTime.nMsec;

}

nRet = spc_acknowledge_alarms(hServer, nSPCTagIDs, alarmTimes,  SPC_ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("acknowledge alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("acknowledge alarms successful!\n");

//comment alarms

nRet = spc_comment_alarms(hServer, nSPCTagIDs, alarmTimes, "this is a comment", SPC_ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("comment alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("comment alarms successful!\n");

//query tag alarm records

queryCond.tvStart.nSec = 1;

queryCond.tvStart.nMsec = 0;

queryCond.tvEnd.nMsec =0;

queryCond.tvEnd.nSec =100;

queryCond.nAckMask = (int8)MASK_ALARM_ALL;

queryCond.nCommentMask = (int8)MASK_ALARM_ALL;

queryCond.nRestoreMask = (int8)MASK_ALARM_ALL;

nRet = spc_query_tag_records(hServer, nSPCTagIDs[0], &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags all records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query group alarm records

nRet = spc_query_group_records(hServer, 0, &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query group records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query tags alarm records

nRet = spc_query_tags_records(hServer, nSPCTagIDs, SPC_ALARM_TAG_NUM,

 &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//disconnect

nt_disconnect(hServer);

return 0;

}

?参见：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


spc_query_tags_all_records

Navigation: »No topics above this level«

spc_query_tags_all_records

 Return to chapter overview

spc_query_tags_all_records

Glossary Item Box

函数

查询spc报警点的全部报警记录

int32 spc_query_tags_all_records(

HDHANDLE hServer,

uint32 nTagIDs[],

int32 nTagNum,

const HDAlarmQuery* pQueryCond,

int64 nPropMask,

HDHANDLE* pHIter

);

参数

hServer

[in] 服务器句柄

nTagIDs[]

[in] 报警点ID数组

nTagNum

[in] 报警点数组个数

pQueryCond

[in] 查询条件

nPropMask

[in] 返回的报警记录的属性掩码

pHIter

[out] 报警记录迭代器句柄,查询的报警记录包括实时记录和历史记录

返回值

查询成功,返回RD_SUCCESS;查询失败返回其他错误码,见error.h

说明

举例

spc_query_tags_all_records

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

#include <windows.h>

void spc_record_callback(HDHANDLE hServer, int8 nType, const HDSPCAlarmRecord* spcAlarm)

{

printf("spc alarm occer, nType %d, tag id %d, time %d\n", nType, spcAlarm->nSPCTagID, spcAlarm->tvStartTime.nSec);

}

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "168.2.237.35";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statsTag;

SPCAlarmTagProp spcAlarmTagSave;

int32 nRecNum = 4;

const int32 SPC_ALARM_TAG_NUM = 4;

uint32 nSPCTagIDs[SPC_ALARM_TAG_NUM];

HDSPCAlarmQuery queryCond;

HDRecord snapshot;

HDHANDLE hIter = NULL;

HDSPCAlarmRecord spcAlarmRec;

HDSPCAlarmRecord snSPCAlarms[SPC_ALARM_TAG_NUM];

int32 nErrorCodes[SPC_ALARM_TAG_NUM];

HDTime alarmTimes[SPC_ALARM_TAG_NUM];

int32 i = 0;

uint32 nSrcTagID = 0;

uint32 nUCLTagID = 0;

uint32 nCLTagID = 0;

uint32 nLCLTagID = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

nRet = sc_login(hServer, "admin", "admin");

// add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nSrcTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

//add statistics tag

strcpy(statsTag.szTagName, "szStatsTag");

strcpy(statsTag.szSourceTagName, normalTag.szTagName);

statsTag.nScanPeriod = 1;

statsTag.nStatsType = HD_STATS_TYPE_MAX;

statsTag.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statsTag.nSampleInerval = 1;

statsTag.nSampleStartDate = 1;

statsTag.bBeginTimeStamp = true;

nRet = st_add_tag(hServer, &statsTag, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_NAME

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE

 |TAG_PROP_STATS_BEGIN_TIME_STAMP);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statsTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statsTag.szTagName);

//add one normal tag as spc tag ucl tag

strcpy(normalTag.szTagName, "szUCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nUCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 200;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nUCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add one normal tag as spc tag cl tag

strcpy(normalTag.szTagName, "szCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 100;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add one normal tag as spc tag lcl tag

strcpy(normalTag.szTagName, "szLCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nLCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 50;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nLCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add spc alarm tag

for (i = 0; i < SPC_ALARM_TAG_NUM; i ++)

{

 memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

 sprintf(spcAlarmTagSave.szTagName, "szSPCAlarmTag_%d", i);

 strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

 spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

 strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

 strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

 strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

 spcAlarmTagSave.dUCLDefaultValue = 200;

 spcAlarmTagSave.dCLDefaultVaule = 100;

 spcAlarmTagSave.dLCLDefaultValue = 50;

 spcAlarmTagSave.bJudgeContinuous = true;

 spcAlarmTagSave.bRule1 = true;

 spcAlarmTagSave.nRule1M = 1;

 nRet = spc_add_tag(hServer, &spcAlarmTagSave,

  TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

  | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

 if (nRet != RD_SUCCESS)

 {

  printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

 nRet = spc_query_tagid(hServer, spcAlarmTagSave.szTagName, &nSPCTagIDs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query spc alarm tag id failed,  alarm spc name[%s], error code[%d]!\n", spcAlarmTagSave.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("spc alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  spcAlarmTagSave.szTagName, nSPCTagIDs[i]);

}

//reg spc alarm callback

spc_register_alarm_record_info(hServer, spc_record_callback);

//save snapshots generate spc alarm

for (i = 0; i < nRecNum; i++)

{

 snapshot.nSec =  i + 1;

 snapshot.nMsec = 0;

 snapshot.nQuality = 192;

 snapshot.value.nInt32 = 300;

 nRet = sn_save_snapshot(hServer, nSrcTagID, &snapshot);

 if (nRet != RD_SUCCESS)

 {

  printf("save snapshot failed, error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("save snapshot successful!\n");

 Sleep(10);

}

Sleep(3000);

//query alarm snapshot

nRet = spc_query_snapshots(hServer, SPC_ALARM_TAG_NUM, nSPCTagIDs,

 ALARM_REC_PROP_ALL, snSPCAlarms, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query alarm snapshots successful!\n");

}

else if (EC_HD_API_AM_QUERY_SNAPSHOTS_FAILED == nRet)

{

 for (i = 0; i < SPC_ALARM_TAG_NUM; i ++)

 {

  if (nErrorCodes[i] != RD_SUCCESS)

  {

   printf("query alarm tag[%d] snapshot failed, error code [%d]!\n", nSPCTagIDs[i], nErrorCodes[i]);

  }

 }

}

else

{

 printf("query alarm snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//ack alarms

for (i = 0; i < nRecNum; i++)

{

 alarmTimes[i].nSec = snSPCAlarms[i].tvStartTime.nSec;

 alarmTimes[i].nMsec = snSPCAlarms[i].tvStartTime.nMsec;

}

nRet = spc_acknowledge_alarms(hServer, nSPCTagIDs, alarmTimes,  SPC_ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("acknowledge alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("acknowledge alarms successful!\n");

//comment alarms

nRet = spc_comment_alarms(hServer, nSPCTagIDs, alarmTimes, "this is a comment", SPC_ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("comment alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("comment alarms successful!\n");

//query tag alarm records

queryCond.tvStart.nSec = 1;

queryCond.tvStart.nMsec = 0;

queryCond.tvEnd.nMsec =0;

queryCond.tvEnd.nSec =100;

queryCond.nAckMask = (int8)MASK_ALARM_ALL;

queryCond.nCommentMask = (int8)MASK_ALARM_ALL;

queryCond.nRestoreMask = (int8)MASK_ALARM_ALL;

nRet = spc_query_tag_records(hServer, nSPCTagIDs[0], &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags all records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query group alarm records

nRet = spc_query_group_records(hServer, 0, &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query group records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query tags alarm records

nRet = spc_query_tags_records(hServer, nSPCTagIDs, SPC_ALARM_TAG_NUM,

 &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//disconnect

nt_disconnect(hServer);

return 0;

}

?参见：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


spc_query_tags_cond

Navigation: »No topics above this level«

spc_query_tags_cond

 Return to chapter overview

spc_query_tags_cond

Glossary Item Box

函数

在一台服务器中通过查询条件查询满足条件的SPC报警点

int32 spc_query_tags_cond(

HDHANDLE hServer,

QueryTagPropItem pQueryItems[],

int32 nQueryItemNum,

int64 nPropMask,

HDHANDLE* pHIter

);

参数

hServer

[in] 服务器句柄。

pQueryItems

[in] 查询条件数组。

nQueryItemNum

[in] 查询条件个数。

nPropMask

[in] 返回报警点掩码，表明返回哪些报警点的属性。

pHIter

[out] 查询迭代器。

返回值

查询成功，返回RD_SUCCESS。查询失败返回其它错误码，见error_code.h。

说明

调用该接口成功后会获得一个查询迭代器的句柄，然后调用ut_get_item_step接口，传入迭代器句柄和分配的空间(SPCAlarmTagProp*)，返回RD_SUCCESS就可以获得第一个报警点的属性，再调用ut_get_item_step返回RD_SUCCESS就可以获得第二个报警点的属性。如此循环的查询直到调用ut_get_item_step返回错误码为EC_HD_API_QUERY_END表明所有的报警点的ID都查询完毕了。查询完毕后调用ut_free_iterator方法来释放迭代器。

举例

demo

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statsTag;

SPCAlarmTagProp spcAlarmTagSave;

SPCAlarmTagProp spcAlarmTagQuery;

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

int32 nErrCode = 0;

char (*szTagNames)[HD_LEN_TAG_NAME] = NULL;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag as stats tag source tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add statistics tag

strcpy(statsTag.szTagName, "szStatsTag");

strcpy(statsTag.szSourceTagName, normalTag.szTagName);

statsTag.nScanPeriod = 60;

statsTag.nStatsType = HD_STATS_TYPE_MAX;

statsTag.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statsTag.nSampleInerval = 3600;

statsTag.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statsTag, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_NAME

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statsTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statsTag.szTagName);

//add one normal tag as spc tag ucl tag

strcpy(normalTag.szTagName, "szUCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add one normal tag as spc tag cl tag

strcpy(normalTag.szTagName, "szCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add one normal tag as spc tag lcl tag

strcpy(normalTag.szTagName, "szLCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

//add spc alarm tag

memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

strcpy(spcAlarmTagSave.szTagName, "szSPCAlarmTag_1");

strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

spcAlarmTagSave.dUCLDefaultValue = 200;

spcAlarmTagSave.dCLDefaultVaule = 100;

spcAlarmTagSave.dLCLDefaultValue = 50;

nRet = spc_add_tag(hServer, &spcAlarmTagSave,

 TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

 | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

if (nRet != RD_SUCCESS)

{

 printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

strcpy(spcAlarmTagSave.szTagName, "szSPCAlarmTag_2");

strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

spcAlarmTagSave.dUCLDefaultValue = 200;

spcAlarmTagSave.dCLDefaultVaule = 100;

spcAlarmTagSave.dLCLDefaultValue = 50;

nRet = spc_add_tag(hServer, &spcAlarmTagSave,

 TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

 | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

if (nRet != RD_SUCCESS)

{

 printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

//query spc tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_TAG_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", TAG_TYPE_DIGITAL);

nRet = spc_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME| TAG_PROP_TIME_DEADBAND | TAG_PROP_VALUE_DEADBAND, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query spc tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query spc tag successful, tag name is %s!\n", spcAlarmTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query spc tag complete!\n");

  break;

 }

 else

 {

  printf("query spc tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you have queried %d spc alarm tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = spc_query_tagid(hServer, spcAlarmTagSave.szTagName, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query spc alarm tag id failed,  alarm spc name[%s], error code[%d]!\n", spcAlarmTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("spc alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  spcAlarmTagSave.szTagName, nTagID);

//modify tag desc

strcpy(spcAlarmTagSave.szDescriptor, "spc tag descriptor is modified");

spcAlarmTagSave.bRule1 = true;

spcAlarmTagSave.nRule1M = 10;

nRet = spc_modify_tag_prop(hServer, nTagID, &spcAlarmTagSave, TAG_PROP_DESCRIPTOR|TAG_PROP_SPC_RULE);

if (nRet != RD_SUCCESS)

{

 printf("modify spc tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify spc tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = spc_query_tag_prop(hServer, nTagID, &spcAlarmTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query spc tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query spc tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 spcAlarmTagQuery.nTagID, spcAlarmTagQuery.szTagName, spcAlarmTagQuery.szDescriptor);

//query tag names

szTagNames = new char[1][HD_LEN_TAG_NAME];

nRet = spc_query_tag_names(hServer, 1, &nTagID, szTagNames, &nErrCode);

if (RD_SUCCESS == nRet)

{

 printf("query spc alarm tag[id:%d] name[%s] successful!\n", nTagID, szTagNames[0]);

}

else if (EC_HD_API_AM_QUERY_TAG_NAMES_FAILED == nRet)

{

 printf("query spc tag names failed, tag id[%d], error code[%d]!\n", nTagID, nErrCode);

}

if (nRet != RD_SUCCESS)

{

 printf("query spc tag names failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 delete[] szTagNames;

 nt_disconnect(hServer);

 return -1;

}

delete[] szTagNames;

//delete spc tag

nRet = spc_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete spc alarm tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete spc alarm tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

?参见：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


spc_register_alarm_record_info

Navigation: »No topics above this level«

spc_register_alarm_record_info

 Return to chapter overview

spc_register_alarm_record_info

Glossary Item Box

函数

向一台服务器中注册实时报警记录通知，每当服务器有新的报警记录产生时，用户传入的回调函数就会被调用。

int32 spc_register_alarm_record_info(

HDHANDLE hServer,

void (*pFunc)(HDHANDLE hServer, uint32 nTagID, const HDSPCAlarmRecord* pRecord)

);

参数

hServer

[in] 服务器句柄。

pFunc

[in] 报警记录回调函数，回调函数的参数分别为服务器句柄、报警点ID、服务器发送过来的报警记录。

返回值

注册成功，返回RD_SUCCESS。注册失败返回其它错误码，见error_code.h。

说明

回调函数可以为NULL

在回调函数中不能调用其它的iHyperDB的API。

举例

spc_register_alarm_record_info

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

#include <windows.h>

void spc_record_callback(HDHANDLE hServer, int8 nType, const HDSPCAlarmRecord* spcAlarm)

{

printf("spc alarm occer, nType %d, tag id %d, time %d\n", nType, spcAlarm->nSPCTagID, spcAlarm->tvStartTime.nSec);

}

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "168.2.237.35";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statsTag;

SPCAlarmTagProp spcAlarmTagSave;

int32 nRecNum = 4;

const int32 SPC_ALARM_TAG_NUM = 4;

uint32 nSPCTagIDs[SPC_ALARM_TAG_NUM];

HDSPCAlarmQuery queryCond;

HDRecord snapshot;

HDHANDLE hIter = NULL;

HDSPCAlarmRecord spcAlarmRec;

HDSPCAlarmRecord snSPCAlarms[SPC_ALARM_TAG_NUM];

int32 nErrorCodes[SPC_ALARM_TAG_NUM];

HDTime alarmTimes[SPC_ALARM_TAG_NUM];

int32 i = 0;

uint32 nSrcTagID = 0;

uint32 nUCLTagID = 0;

uint32 nCLTagID = 0;

uint32 nLCLTagID = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

nRet = sc_login(hServer, "admin", "admin");

// add normal tag

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nSrcTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

//add statistics tag

strcpy(statsTag.szTagName, "szStatsTag");

strcpy(statsTag.szSourceTagName, normalTag.szTagName);

statsTag.nScanPeriod = 1;

statsTag.nStatsType = HD_STATS_TYPE_MAX;

statsTag.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statsTag.nSampleInerval = 1;

statsTag.nSampleStartDate = 1;

statsTag.bBeginTimeStamp = true;

nRet = st_add_tag(hServer, &statsTag, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_NAME

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE

 |TAG_PROP_STATS_BEGIN_TIME_STAMP);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statsTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statsTag.szTagName);

//add one normal tag as spc tag ucl tag

strcpy(normalTag.szTagName, "szUCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nUCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 200;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nUCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add one normal tag as spc tag cl tag

strcpy(normalTag.szTagName, "szCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 100;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add one normal tag as spc tag lcl tag

strcpy(normalTag.szTagName, "szLCLTag");

normalTag.nTagType = TAG_TYPE_FLOAT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &nLCLTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag[%s] id failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query tag[%s] id successful!\n", normalTag.szTagName);

snapshot.value.fFloat32 = 50;

snapshot.nSec = 1;

snapshot.nMsec = 0;

snapshot.nQuality = 192;

nRet = sn_save_snapshot(hServer, nLCLTagID, &snapshot);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//add spc alarm tag

for (i = 0; i < SPC_ALARM_TAG_NUM; i ++)

{

 memset(&spcAlarmTagSave, 0, sizeof(spcAlarmTagSave));

 sprintf(spcAlarmTagSave.szTagName, "szSPCAlarmTag_%d", i);

 strcpy(spcAlarmTagSave.szSourceTagName, "szStatsTag");

 spcAlarmTagSave.nCtrlChartType = HD_SPC_CTRL_CHART_TYPE_XBAR;

 strcpy(spcAlarmTagSave.szUCLTagName, "szUCLTag");

 strcpy(spcAlarmTagSave.szCLTagName, "szCLTag");

 strcpy(spcAlarmTagSave.szLCLTagName, "szLCLTag");

 spcAlarmTagSave.dUCLDefaultValue = 200;

 spcAlarmTagSave.dCLDefaultVaule = 100;

 spcAlarmTagSave.dLCLDefaultValue = 50;

 spcAlarmTagSave.bJudgeContinuous = true;

 spcAlarmTagSave.bRule1 = true;

 spcAlarmTagSave.nRule1M = 1;

 nRet = spc_add_tag(hServer, &spcAlarmTagSave,

  TAG_PROP_TAG_NAME | TAG_PROP_SPC_SOURCE_TAG_NAME

  | TAG_PROP_SPC_CTRL_CHART_TYPE |TAG_PROP_SPC_RULE );

 if (nRet != RD_SUCCESS)

 {

  printf("add spc tag[%s] failed, error code [%d]!\n", spcAlarmTagSave.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("add spc tag[%s] successful!\n", spcAlarmTagSave.szTagName);

 nRet = spc_query_tagid(hServer, spcAlarmTagSave.szTagName, &nSPCTagIDs[i]);

 if (nRet != RD_SUCCESS)

 {

  printf("query spc alarm tag id failed,  alarm spc name[%s], error code[%d]!\n", spcAlarmTagSave.szTagName, nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("spc alarm tag[%s] query tag id successful,  alarm tag id[%d]!\n",  spcAlarmTagSave.szTagName, nSPCTagIDs[i]);

}

//reg spc alarm callback

spc_register_alarm_record_info(hServer, spc_record_callback);

//save snapshots generate spc alarm

for (i = 0; i < nRecNum; i++)

{

 snapshot.nSec =  i + 1;

 snapshot.nMsec = 0;

 snapshot.nQuality = 192;

 snapshot.value.nInt32 = 300;

 nRet = sn_save_snapshot(hServer, nSrcTagID, &snapshot);

 if (nRet != RD_SUCCESS)

 {

  printf("save snapshot failed, error code [%d]!\n", nRet);

  nt_disconnect(hServer);

  return -1;

 }

 printf("save snapshot successful!\n");

 Sleep(10);

}

Sleep(3000);

//query alarm snapshot

nRet = spc_query_snapshots(hServer, SPC_ALARM_TAG_NUM, nSPCTagIDs,

 ALARM_REC_PROP_ALL, snSPCAlarms, nErrorCodes);

if (RD_SUCCESS == nRet)

{

 printf("query alarm snapshots successful!\n");

}

else if (EC_HD_API_AM_QUERY_SNAPSHOTS_FAILED == nRet)

{

 for (i = 0; i < SPC_ALARM_TAG_NUM; i ++)

 {

  if (nErrorCodes[i] != RD_SUCCESS)

  {

   printf("query alarm tag[%d] snapshot failed, error code [%d]!\n", nSPCTagIDs[i], nErrorCodes[i]);

  }

 }

}

else

{

 printf("query alarm snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

//ack alarms

for (i = 0; i < nRecNum; i++)

{

 alarmTimes[i].nSec = snSPCAlarms[i].tvStartTime.nSec;

 alarmTimes[i].nMsec = snSPCAlarms[i].tvStartTime.nMsec;

}

nRet = spc_acknowledge_alarms(hServer, nSPCTagIDs, alarmTimes,  SPC_ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("acknowledge alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("acknowledge alarms successful!\n");

//comment alarms

nRet = spc_comment_alarms(hServer, nSPCTagIDs, alarmTimes, "this is a comment", SPC_ALARM_TAG_NUM);

if (nRet != RD_SUCCESS)

{

 printf("comment alarms failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("comment alarms successful!\n");

//query tag alarm records

queryCond.tvStart.nSec = 1;

queryCond.tvStart.nMsec = 0;

queryCond.tvEnd.nMsec =0;

queryCond.tvEnd.nSec =100;

queryCond.nAckMask = (int8)MASK_ALARM_ALL;

queryCond.nCommentMask = (int8)MASK_ALARM_ALL;

queryCond.nRestoreMask = (int8)MASK_ALARM_ALL;

nRet = spc_query_tag_records(hServer, nSPCTagIDs[0], &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags all records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query group alarm records

nRet = spc_query_group_records(hServer, 0, &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query group all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query group records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//query tags alarm records

nRet = spc_query_tags_records(hServer, nSPCTagIDs, SPC_ALARM_TAG_NUM,

 &queryCond, SPC_ALARM_REC_PROP_ALL, &hIter);

while (true)

{

 nRet = ut_get_item_step(hIter, &spcAlarmRec);

 if (RD_SUCCESS == nRet)

 {

  printf("query alarm successful, alarm tag id [%d] start time[%d:%d]\n", spcAlarmRec.nSPCTagID,

   spcAlarmRec.tvStartTime.nSec, spcAlarmRec.tvStartTime.nMsec);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tags all records complete\n");

  nRet = RD_SUCCESS;

  break;

 }

 else

 {

  printf("query tags records failed, error code [%d]\n", nRet);

 }

}

ut_free_iterator(hIter);

//disconnect

nt_disconnect(hServer);

return 0;

}

?参见：

?am_add_group

?am_delete_group

?am_modify_group_desc

?am_modify_group_parentid

?am_query_groupid

?am_query_group_props

?am_query_group_child_groups

?am_query_group_child_tags

©2015. All Rights Reserved.


st_query_tag_prop

Navigation: »No topics above this level«

st_query_tag_prop

 Return to chapter overview

st_query_tag_prop

Glossary Item Box

函数

查询统计点属性

int32 st_query_tag_prop(

HDHANDLE hServer,

uint32 nTagID,

StatsTagProp* pTagProp);

参数

hServer

[in]服务器ID

nTagID

[in]统计点ID

pTagProp

[out]统计点属性

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

举例

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statTagSave;

StatsTagProp statTagQuery;

const char* szTagName_1 = "szStatTagName_1";

const char* szTagName_2 = "szStatTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  normalTag.szTagName, normalTag.nTagID);

//add two stat tag

strcpy(statTagSave.szTagName, szTagName_1);

statTagSave.nSourceTagID = normalTag.nTagID;

statTagSave.nScanPeriod = 60;

statTagSave.nStatsType = HD_STATS_TYPE_MAX;

statTagSave.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statTagSave.nSampleInerval = 3600;

statTagSave.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statTagSave, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_ID

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statTagSave.szTagName);

strcpy(statTagSave.szTagName, szTagName_2);

statTagSave.nSourceTagID = normalTag.nTagID;

statTagSave.nScanPeriod = 60;

statTagSave.nStatsType = HD_STATS_TYPE_MIN;

statTagSave.nSampleMode = HD_STATS_SAMPLE_MODE_EVERY_DAY;

statTagSave.nSampleBeginOffset = 0;

statTagSave.nSampleEndOffset = 24*3600;

statTagSave.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statTagSave, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_ID

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_BEGIN_OFFSET | TAG_PROP_STATS_SAMPLE_END_OFFSET

 | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_STATS_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", HD_STATS_TYPE_MIN);

nRet = st_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &statTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query tag successful, tag name is %s!\n", statTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tag complete!\n");

  break;

 }

 else

 {

  printf("query tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you queried %d stat tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = st_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, stat tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("stat tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagID);

//modify tag desc

strcpy(statTagSave.szDescriptor, "stat tag descriptor is modified");

nRet = st_modify_tag_prop(hServer, nTagID, &statTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify stat tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify stat tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = st_query_tag_prop(hServer, nTagID, &statTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query stat tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query stat tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 statTagQuery.nTagID, statTagQuery.szTagName, statTagQuery.szDescriptor);

//delete tag

nRet = st_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete stat tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete stat tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参考：

?st_query_tags_cond

?st_modify_tag_prop

?st_delete_tag

?st_query_tag_id

?st_add_tag

©2015. All Rights Reserved.


st_query_tags_cond

Navigation: »No topics above this level«

st_query_tags_cond

 Return to chapter overview

st_query_tags_cond

Glossary Item Box

函数

条件查询统计点属性

int32 st_query_tags_cond(

HDHANDLE hServer,

QueryTagPropItem pQueryItems[],

int32 nQueryItemNum,

int64 nPropMask,

HDHANDLE* pHIter

);

参数

hServer

[in]服务器句柄

pQueryItems

[in]查询条件项

nQueryItemNum

[in]查询条件项个数

nPropMask

[in]查询信息掩码，控制返回的统计点的哪些属性

pHIter

[in]查询迭代器

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

举例

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statTagSave;

StatsTagProp statTagQuery;

const char* szTagName_1 = "szStatTagName_1";

const char* szTagName_2 = "szStatTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  normalTag.szTagName, normalTag.nTagID);

//add two stat tag

strcpy(statTagSave.szTagName, szTagName_1);

statTagSave.nSourceTagID = normalTag.nTagID;

statTagSave.nScanPeriod = 60;

statTagSave.nStatsType = HD_STATS_TYPE_MAX;

statTagSave.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statTagSave.nSampleInerval = 3600;

statTagSave.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statTagSave, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_ID

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statTagSave.szTagName);

strcpy(statTagSave.szTagName, szTagName_2);

statTagSave.nSourceTagID = normalTag.nTagID;

statTagSave.nScanPeriod = 60;

statTagSave.nStatsType = HD_STATS_TYPE_MIN;

statTagSave.nSampleMode = HD_STATS_SAMPLE_MODE_EVERY_DAY;

statTagSave.nSampleBeginOffset = 0;

statTagSave.nSampleEndOffset = 24*3600;

statTagSave.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statTagSave, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_ID

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_BEGIN_OFFSET | TAG_PROP_STATS_SAMPLE_END_OFFSET

 | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_STATS_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", HD_STATS_TYPE_MIN);

nRet = st_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &statTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query tag successful, tag name is %s!\n", statTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tag complete!\n");

  break;

 }

 else

 {

  printf("query tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you queried %d stat tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = st_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, stat tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("stat tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagID);

//modify tag desc

strcpy(statTagSave.szDescriptor, "stat tag descriptor is modified");

nRet = st_modify_tag_prop(hServer, nTagID, &statTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify stat tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify stat tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = st_query_tag_prop(hServer, nTagID, &statTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query stat tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query stat tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 statTagQuery.nTagID, statTagQuery.szTagName, statTagQuery.szDescriptor);

//delete tag

nRet = st_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete stat tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete stat tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参考：

?st_query_tag_prop

?st_modify_tag_prop

?st_delete_tag

?st_query_tag_id

?st_add_tag

©2015. All Rights Reserved.


st_add_tag

Navigation: »No topics above this level«

st_add_tag

 Return to chapter overview

st_add_tag

Glossary Item Box

函数

添加统计点

int32 st_add_tag(

HDHANDLE hServer,

const StatsTagProp* pTagProp,

int64 nPropMask);

参数

hServer

[in]服务器句柄

pTagProp

[out]统计点属性

nPropMask

[in]属性掩码

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

举例

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statTagSave;

StatsTagProp statTagQuery;

const char* szTagName_1 = "szStatTagName_1";

const char* szTagName_2 = "szStatTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  normalTag.szTagName, normalTag.nTagID);

//add two stat tag

strcpy(statTagSave.szTagName, szTagName_1);

statTagSave.nSourceTagID = normalTag.nTagID;

statTagSave.nScanPeriod = 60;

statTagSave.nStatsType = HD_STATS_TYPE_MAX;

statTagSave.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statTagSave.nSampleInerval = 3600;

statTagSave.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statTagSave, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_ID

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statTagSave.szTagName);

strcpy(statTagSave.szTagName, szTagName_2);

statTagSave.nSourceTagID = normalTag.nTagID;

statTagSave.nScanPeriod = 60;

statTagSave.nStatsType = HD_STATS_TYPE_MIN;

statTagSave.nSampleMode = HD_STATS_SAMPLE_MODE_EVERY_DAY;

statTagSave.nSampleBeginOffset = 0;

statTagSave.nSampleEndOffset = 24*3600;

statTagSave.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statTagSave, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_ID

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_BEGIN_OFFSET | TAG_PROP_STATS_SAMPLE_END_OFFSET

 | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_STATS_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", HD_STATS_TYPE_MIN);

nRet = st_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &statTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query tag successful, tag name is %s!\n", statTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tag complete!\n");

  break;

 }

 else

 {

  printf("query tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you queried %d stat tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = st_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, stat tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("stat tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagID);

//modify tag desc

strcpy(statTagSave.szDescriptor, "stat tag descriptor is modified");

nRet = st_modify_tag_prop(hServer, nTagID, &statTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify stat tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify stat tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = st_query_tag_prop(hServer, nTagID, &statTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query stat tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query stat tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 statTagQuery.nTagID, statTagQuery.szTagName, statTagQuery.szDescriptor);

//delete tag

nRet = st_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete stat tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete stat tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参考：

?st_query_tags_cond

?st_query_tag_prop

?st_modify_tag_prop

?st_delete_tag

?st_query_tag_id

©2015. All Rights Reserved.


统计算法

Navigation: »No topics above this level«

统计算法

 Return to chapter overview

本章将对统计点的复杂功能进行详细说明

·统计点功能的介绍

统计点是对某Tag点进行如求和、计数等等一系列特殊算法后，所形成的点。还可设置统计的时间、频率。针对长时间才变更的点，还可采用前向或线性插值的方法。

§基本信息

ü监测点：选择被统计的点；

ü最小信任度：如果100%，代表统计区间内的必须100%全为good点，此统计点才为good; 如果0%,代表只要统计区间内有good点,此统计点均为good.

§统计类型

ü统计类型：选择被统计的点的统计方式；每种方式，在下面会详细介绍。

§统计时间

ü开始时间：开始统计的时间；

ü时间模式、统计方式、扫描周期：

v定周期：每固定扫描周期扫描一次，如果满足间隔固定的时间段，则统计一次；

v时间追溯：每扫描周期统计一次，统计间隔区间内的数据；

v持续：每固定扫描周期统计一次；

定周期等间隔和时间追溯等间隔的区别：（配置均为从0点开始，间隔30分钟，扫描周期60秒）

1、定周期的等间隔：每60秒扫描一次，如果距上次统计时间为30分钟，则统计。结果是从00:30开始，每半个小时一个数据；

2、时间追溯的等间隔：每60秒统计一次，统计30分钟区间内的数据。结果是从00:30开始，每60秒一条数据；

§采样方式

ü原始值：原始点的数值是什么值，就采什么值；

如果采样点的原始值间隔很长.如12小时，而12小时数据变化太大，无法及时调整生产方式，则可采取插值方法。插值是数学、计算机图形学等领域广泛使用的一种插值方法（具体可参考术语）

举例：0点开始，偏移量5秒，周期60秒

ü线性插值：从开始时间起5秒后，即00:00:05开始，每60秒用线性插值的方法计算出一个点，为采样点；

ü前向插值：从开始时间起5秒后，即00:00:05开始，每60秒用前向插值的方法计算出一个点，为采样点；

ü使用bad记录,如勾选使用bad记录,则将bad记录转为good记录参与统计计算.

§记录时间戳

统计点的时间标记

ü起始偏移：如偏移量为0，则以统计区域的开始时间为时间戳；如果偏移量为5秒，则以开始时间后5秒为时间戳；如偏移量是-5，则以开始时间前5秒为时间戳

ü结束偏移：如偏移量为0，则以统计区域的结束时间为时间戳；如果偏移量为5秒，则以结束时间后5秒为时间戳；如偏移量是-5，则以结束时间前5秒为时间戳

§过滤表达式

可以将超过一定范围的值剔除，不纳入统计范围。下方表达式为真，则过滤，否则，不过滤

如tag1>=100,则将大于100的点剔除，不纳入统计。

ü若选择“是”，则此点不参与运算；

ü若选择“否”，则此点参与运算。

§记录值转换系数

系数：1、放大：统计值*系数；2、缩小：统计值/系数

§统计点支持的算法

§最大值

统计区间内最大值

§最小值

统计区间内最小值

§求和

统计区间内所有数据的和

§计数

统计区间内数据的个数。

计数类型

ü值变化：如从0到10.只要数字变化时必须有0和10，不论中间是否有其他数字，即计数1。如只有0或10，则不计数；一般用于离散型的数字计数

ü从<=到>=:第一个数字必须小于第二个数字，如从<=3到>=10，代表从<=3的数字变化到>=10的数字即计数1；（如一条曲线必须向上同时穿过3和10，才计数）

ü从>=到<=:第一个数字必须大于第二个数字，如从>=10到<=3，代表从>=10的数字变化到<=3的数字即计数1；（如一条曲线必须向下同时穿过10和3，才计数）

ü在区间：如下限3，上限10，代表如果数字在[3,10)区间内，只要数字变化1次，即计数1；

ü不在区间：如下限3，上限10，代表如果数字在[3,10)区间以外，只要数字变化1次，即计数1；

§最新值

统计区间内最后一个数据

§可信度

统计区间内数据质量为good的比例

§算术平均值

统计区间内数据的算数平均值

§时间加权平均值

统计区间内的数据积分，再除以时间，比算术平均值更均匀

§积分

统计区间内点所谓围成的图形面积，通常用来计算流量。其中采样点如果是原值或线性插值，采用梯形法算积分；如果采用前向插值法，采用矩形法积分；

§差值

统计区间内最后一个值减前一个统计区间内最后一个数值

§极差

统计区间内最大值减最小值

§标准差

统计区间内标准差，反映数据偏移平均值的大小

§计时

反映数据在统计范围内的持续时间

>:如>10,则记录数据在>10的范围上持续的时间，单位为S（秒）。其他同理。


统计点

Navigation: »No topics above this level«

统计点

 Return to chapter overview

统计点

Glossary Item Box

《统计点》主要介绍一下接口：

?st_query_tags_cond

?st_query_tag_prop

?st_modify_tag_prop

?st_delete_tag

?st_query_tag_id

?st_add_tag

©2015. All Rights Reserved.


统计管理接口

Navigation: »No topics above this level«

统计管理接口

 Return to chapter overview

统计管理接口

Glossary Item Box

《统计管理接口》主要包括的接口包括：

?统计点

?st_query_tags_cond

?st_query_tag_prop

?st_modify_tag_prop

?st_delete_tag

?st_query_tag_id

?st_add_tag

?统计计算

?st_tag_max

?st_tag_min

?st_tag_time_weight_mean

?st_tag_rec_weight_mean

?st_tag_integral

?st_tag_percent_good

©2015. All Rights Reserved.


统计计算

Navigation: »No topics above this level«

统计计算

 Return to chapter overview

统计计算

Glossary Item Box

《统计计算》主要介绍介绍一下接口：

?st_tag_max

?st_tag_min

?st_tag_time_weight_mean

?st_tag_rec_weight_mean

?st_tag_integral

?st_tag_percent_good

©2015. All Rights Reserved.


st_delete_tag

Navigation: »No topics above this level«

st_delete_tag

 Return to chapter overview

st_delete_tag

Glossary Item Box

函数

删除统计点

int32 st_delete_tag(

HDHANDLE hServer,

uint32 nTagID

);

参数

hServer

[in]服务器句柄

nTagID

[in]统计点ID

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

举例

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statTagSave;

StatsTagProp statTagQuery;

const char* szTagName_1 = "szStatTagName_1";

const char* szTagName_2 = "szStatTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  normalTag.szTagName, normalTag.nTagID);

//add two stat tag

strcpy(statTagSave.szTagName, szTagName_1);

statTagSave.nSourceTagID = normalTag.nTagID;

statTagSave.nScanPeriod = 60;

statTagSave.nStatsType = HD_STATS_TYPE_MAX;

statTagSave.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statTagSave.nSampleInerval = 3600;

statTagSave.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statTagSave, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_ID

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statTagSave.szTagName);

strcpy(statTagSave.szTagName, szTagName_2);

statTagSave.nSourceTagID = normalTag.nTagID;

statTagSave.nScanPeriod = 60;

statTagSave.nStatsType = HD_STATS_TYPE_MIN;

statTagSave.nSampleMode = HD_STATS_SAMPLE_MODE_EVERY_DAY;

statTagSave.nSampleBeginOffset = 0;

statTagSave.nSampleEndOffset = 24*3600;

statTagSave.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statTagSave, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_ID

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_BEGIN_OFFSET | TAG_PROP_STATS_SAMPLE_END_OFFSET

 | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_STATS_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", HD_STATS_TYPE_MIN);

nRet = st_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &statTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query tag successful, tag name is %s!\n", statTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tag complete!\n");

  break;

 }

 else

 {

  printf("query tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you queried %d stat tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = st_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, stat tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("stat tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagID);

//modify tag desc

strcpy(statTagSave.szDescriptor, "stat tag descriptor is modified");

nRet = st_modify_tag_prop(hServer, nTagID, &statTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify stat tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify stat tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = st_query_tag_prop(hServer, nTagID, &statTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query stat tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query stat tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 statTagQuery.nTagID, statTagQuery.szTagName, statTagQuery.szDescriptor);

//delete tag

nRet = st_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete stat tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete stat tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参考：

?st_query_tags_cond

?st_query_tag_prop

?st_modify_tag_prop

?st_query_tag_id

?st_add_tag

©2015. All Rights Reserved.


st_modify_tag_prop

Navigation: »No topics above this level«

st_modify_tag_prop

 Return to chapter overview

st_modify_tag_prop

Glossary Item Box

函数

修改统计点属性

int32 st_modify_tag_prop(

HDHANDLE hServer,

uint32 nTagID,

const StatsTagProp* pTagProp,

int64 nPropMask

);

参数

hServer

[in]服务器ID

nTagID

[in]计点ID

pTagProp

[in]统计点属性

nPropMask

[in]属性掩码

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

举例

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statTagSave;

StatsTagProp statTagQuery;

const char* szTagName_1 = "szStatTagName_1";

const char* szTagName_2 = "szStatTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  normalTag.szTagName, normalTag.nTagID);

//add two stat tag

strcpy(statTagSave.szTagName, szTagName_1);

statTagSave.nSourceTagID = normalTag.nTagID;

statTagSave.nScanPeriod = 60;

statTagSave.nStatsType = HD_STATS_TYPE_MAX;

statTagSave.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statTagSave.nSampleInerval = 3600;

statTagSave.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statTagSave, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_ID

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statTagSave.szTagName);

strcpy(statTagSave.szTagName, szTagName_2);

statTagSave.nSourceTagID = normalTag.nTagID;

statTagSave.nScanPeriod = 60;

statTagSave.nStatsType = HD_STATS_TYPE_MIN;

statTagSave.nSampleMode = HD_STATS_SAMPLE_MODE_EVERY_DAY;

statTagSave.nSampleBeginOffset = 0;

statTagSave.nSampleEndOffset = 24*3600;

statTagSave.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statTagSave, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_ID

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_BEGIN_OFFSET | TAG_PROP_STATS_SAMPLE_END_OFFSET

 | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_STATS_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", HD_STATS_TYPE_MIN);

nRet = st_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &statTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query tag successful, tag name is %s!\n", statTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tag complete!\n");

  break;

 }

 else

 {

  printf("query tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you queried %d stat tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = st_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, stat tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("stat tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagID);

//modify tag desc

strcpy(statTagSave.szDescriptor, "stat tag descriptor is modified");

nRet = st_modify_tag_prop(hServer, nTagID, &statTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify stat tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify stat tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = st_query_tag_prop(hServer, nTagID, &statTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query stat tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query stat tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 statTagQuery.nTagID, statTagQuery.szTagName, statTagQuery.szDescriptor);

//delete tag

nRet = st_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete stat tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete stat tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参考：

?st_query_tags_cond

?st_query_tag_prop

?st_delete_tag

?st_query_tag_id

?st_add_tag

©2015. All Rights Reserved.


存储引擎

Navigation: »No topics above this level«

存储引擎

 Return to chapter overview

存储引擎

Glossary Item Box

©2015. All Rights Reserved.


st_query_tag_id

Navigation: »No topics above this level«

st_query_tag_id

 Return to chapter overview

st_query_tag_id

Glossary Item Box

函数

查询统计点ID

int32 st_query_tagid(

HDHANDLE hServer,

const char* szName,

uint32* pTagID);

参数

hServer

[in]服务器句柄

szName

[in]统计点名

pTagID

[in]统计点ID

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

举例

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp normalTag;

StatsTagProp statTagSave;

StatsTagProp statTagQuery;

const char* szTagName_1 = "szStatTagName_1";

const char* szTagName_2 = "szStatTagName_2";

QueryTagPropItem pQueryTagPropItem[2];

HDHANDLE hIter = NULL;

int32 nTagNum = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

//add one normal tag and get tag id

strcpy(normalTag.szTagName, "szNormalTag");

normalTag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &normalTag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tag[%s] failed, error code [%d]!\n", normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tag[%s] successful!\n", normalTag.szTagName);

nRet = pt_query_tagid(hServer, normalTag.szTagName, &normalTag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  normalTag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",  normalTag.szTagName, normalTag.nTagID);

//add two stat tag

strcpy(statTagSave.szTagName, szTagName_1);

statTagSave.nSourceTagID = normalTag.nTagID;

statTagSave.nScanPeriod = 60;

statTagSave.nStatsType = HD_STATS_TYPE_MAX;

statTagSave.nSampleMode = HD_STATS_SAMPLE_MODE_INTERVAL;

statTagSave.nSampleInerval = 3600;

statTagSave.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statTagSave, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_ID

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_INTERVAL | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statTagSave.szTagName);

strcpy(statTagSave.szTagName, szTagName_2);

statTagSave.nSourceTagID = normalTag.nTagID;

statTagSave.nScanPeriod = 60;

statTagSave.nStatsType = HD_STATS_TYPE_MIN;

statTagSave.nSampleMode = HD_STATS_SAMPLE_MODE_EVERY_DAY;

statTagSave.nSampleBeginOffset = 0;

statTagSave.nSampleEndOffset = 24*3600;

statTagSave.nSampleStartDate = 1;

nRet = st_add_tag(hServer, &statTagSave, TAG_PROP_TAG_NAME | TAG_PROP_STATS_SOURCE_TAG_ID

 |TAG_PROP_STATS_SCAN_PERIOD | TAG_PROP_STATS_TYPE | TAG_PROP_STATS_SAMPLE_MODE

 | TAG_PROP_STATS_SAMPLE_BEGIN_OFFSET | TAG_PROP_STATS_SAMPLE_END_OFFSET

 | TAG_PROP_STATS_SAMPLE_START_DATE);

if (nRet != RD_SUCCESS)

{

 printf("add stat tag[%s] failed, error code [%d]!\n", statTagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", statTagSave.szTagName);

//query tags by condition

pQueryTagPropItem[0].nPropItemID = TAG_COL_TAG_NAME;

pQueryTagPropItem[0].nRelation = RELATION_LIKE;

strcpy(pQueryTagPropItem[0].szValue, "*");

pQueryTagPropItem[1].nPropItemID = TAG_COL_STATS_TYPE;

pQueryTagPropItem[1].nRelation = RELATION_EQUAL;

sprintf(pQueryTagPropItem[1].szValue, "%d", HD_STATS_TYPE_MIN);

nRet = st_query_tags_cond(hServer, pQueryTagPropItem, 2, TAG_PROP_TAG_NAME, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query tags by condition failed, error code [%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &statTagQuery);

 if (RD_SUCCESS == nRet)

 {

  nTagNum ++;

  printf("query tag successful, tag name is %s!\n", statTagQuery.szTagName);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tag complete!\n");

  break;

 }

 else

 {

  printf("query tag failed, error code [%d]!\n", nRet);

  break;

 }

}

printf("you queried %d stat tags totally!\n", nTagNum);

ut_free_iterator(hIter);

//query tag id

uint32 nTagID = 0;

nRet = st_query_tagid(hServer, szTagName_1, &nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, stat tag name[%s], error code[%d]!\n", szTagName_1, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("stat tag[%s] query tag id successful, tag id[%d]!\n",  szTagName_1, nTagID);

//modify tag desc

strcpy(statTagSave.szDescriptor, "stat tag descriptor is modified");

nRet = st_modify_tag_prop(hServer, nTagID, &statTagSave, TAG_PROP_DESCRIPTOR);

if (nRet != RD_SUCCESS)

{

 printf("modify stat tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("modify stat tag successful, tag id[%d]!\n", nTagID);

//query tag prop

nRet = st_query_tag_prop(hServer, nTagID, &statTagQuery);

if (nRet != RD_SUCCESS)

{

 printf("query stat tag prop failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("query stat tag prop successful, tag id[%d], tag name[%s], tag description[%s]!\n",

 statTagQuery.nTagID, statTagQuery.szTagName, statTagQuery.szDescriptor);

//delete tag

nRet = st_delete_tag(hServer, nTagID);

if (nRet != RD_SUCCESS)

{

 printf("delete stat tag failed, tag id[%d], error code[%d]!\n", nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("delete stat tag successful, tag id[%d]!\n", nTagID);

nt_disconnect(hServer);

return 0;

}

参考：

?st_query_tags_cond

?st_query_tag_prop

?st_modify_tag_prop

?st_delete_tag

?st_add_tag

©2015. All Rights Reserved.


st_tag_integral

Navigation: »No topics above this level«

st_tag_integral

 Return to chapter overview

st_tag_integral

Glossary Item Box

函数

给定一段时间范围，计算一个Tag点历史数据以时间为自变量的积分

int32 st_tag_integral(

HDHANDLE hServer,

uint32 nTagID,

const HDTime* pStartTime,

const HDTime* pEndTime,

int32 nQualityMode,

float fPercentGood,

double* pValue

);

说明

以时间为纵轴，以值为横轴，该函数的计算结果就是将该事件段范围的点相连的折线下方的总面积。

参数

hServer

[in] 服务器句柄

nTagID

[in] TagID

pStartTime

[in] 起始时间

pEndTime

[in] 结束时间

nQualityMode

[in]弃坏点模式,HD_STATS_DROP_BAD_MODE_REC 弃bad记录;HD_STATS_DROP_BAD_MODE_AREA弃bad记录相邻的区域

fPencentGood

[in]置信度

pValue

[out]计算值

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

举例

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName = "szTagName";

int32 nRecNum = 3;

HDRecord records[3];

uint32 nTagIDs[3];

int32 nErrorCodes[3];

HDTime startTime;

HDTime endTime;

double dValue;

float fPercentGood = 0.0;

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add tag

strcpy(tag.szTagName, szTagName);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag id

nRet = pt_query_tagid(hServer, tag.szTagName, &tag.nTagID);

if (nRet != RD_SUCCESS)

{

printf("query tag id failed, tag name[%s], error code[%d]!\n", tag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n", tag.szTagName,tag.nTagID);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

nTagIDs[i] = tag.nTagID;

records[i].nSec = 1 + i;

records[i].nMsec = 0;

records[i].nQuality = 192;

records[i].value.nInt32 = records[i].nSec;

}

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, records, nErrorCodes);

if (nRet != RD_SUCCESS)

{

printf("save snapshots failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("save %d record successful!\n", nRecNum);

startTime.nSec = 0;

startTime.nMsec = 0;

endTime.nSec = records[nRecNum - 1].nSec + 1;

endTime.nMsec = 0;

//get max value

nRet = st_tag_max(hServer,tag.nTagID, &startTime, &endTime, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] max value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] max value successful, max value is %f!\n", tag.nTagID, dValue);

//get min value

nRet = st_tag_min(hServer,tag.nTagID, &startTime, &endTime, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] min value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] min value successful, min value is %f!\n", tag.nTagID, dValue);

//get mean value

nRet = st_tag_mean(hServer,tag.nTagID, &startTime, &endTime, HD_STATS_DROP_BAD_MODE_REC,

HD_STATS_RECORD_WEIGHT_MODE, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] mean value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] mean value successful, mean value is %f!\n", tag.nTagID, dValue);

//get sum value

nRet = st_tag_sum(hServer,tag.nTagID, &startTime, &endTime, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] sum value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] sum value successful, sum value is %f!\n", tag.nTagID, dValue);

//get integral value

nRet = st_tag_integral(hServer,tag.nTagID, &startTime, &endTime, HD_STATS_DROP_BAD_MODE_REC,

fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] integral value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] integral value successful, integral value is %f!\n", tag.nTagID, dValue);

//get good percent

nRet = st_tag_good_percent(hServer,tag.nTagID, &startTime, &endTime, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] good percent failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] good percent successful, good percent is %f!\n", tag.nTagID, dValue);

nt_disconnect(hServer);

return 0;

}

参考：

st_tag_max

st_tag_min

st_tag_time_weight_mean

st_tag_rec_weight_mean

st_tag_percent_good


st_tag_max

Navigation: »No topics above this level«

st_tag_max

 Return to chapter overview

st_tag_max

Glossary Item Box

函数

给定一段时间范围，计算一个Tag点历史数据的最大值

int32 st_tag_max(

HDHANDLE hServer,

uint32 nTagID,

const HDTime* pStartTime,

const HDTime* pEndTime,

float fPercentGood,

double* pValue

);

参数

hServer

[in] 服务器句柄

nTagID

[in] TagID

pStartTime

[in] 起始时间

pEndTime

[in] 结束时间

fPencentGood

[in]置信度

pValue

[out]计算值

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

举例

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName = "szTagName";

int32 nRecNum = 3;

HDRecord records[3];

uint32 nTagIDs[3];

int32 nErrorCodes[3];

HDTime startTime;

HDTime endTime;

double dValue;

float fPercentGood = 0.0;

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("connect to server successful!\n");

//add tag

strcpy(tag.szTagName, szTagName);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag id

nRet = pt_query_tagid(hServer, tag.szTagName, &tag.nTagID);

if (nRet != RD_SUCCESS)

{

 printf("query tag id failed, tag name[%s], error code[%d]!\n",  tag.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n",   tag.szTagName,tag.nTagID);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

 nTagIDs[i] = tag.nTagID;

 records[i].nSec = 1 + i;

 records[i].nMsec = 0;

 records[i].nQuality = 192;

 records[i].value.nInt32 = records[i].nSec;

}

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, records, nErrorCodes);

if (nRet != RD_SUCCESS)

{

 printf("save snapshots failed, error code[%d]!\n", nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("save %d record successful!\n", nRecNum);

startTime.nSec = 0;

startTime.nMsec = 0;

endTime.nSec = records[nRecNum - 1].nSec + 1;

endTime.nMsec = 0;

//get max value

nRet = st_tag_max(hServer,tag.nTagID, &startTime, &endTime, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

 printf("calc tag[id:%d] max value failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("calc tag[id:%d] max value successful, max value is %f!\n", tag.nTagID, dValue);

//get min value

nRet = st_tag_min(hServer,tag.nTagID, &startTime, &endTime, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

 printf("calc tag[id:%d] min value failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("calc tag[id:%d] min value successful, min value is %f!\n", tag.nTagID, dValue);

//get mean value

nRet = st_tag_mean(hServer,tag.nTagID, &startTime, &endTime, HD_STATS_DROP_BAD_MODE_REC,

 HD_STATS_RECORD_WEIGHT_MODE, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

 printf("calc tag[id:%d] mean value failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("calc tag[id:%d] mean value successful, mean value is %f!\n", tag.nTagID, dValue);

//get sum value

nRet = st_tag_sum(hServer,tag.nTagID, &startTime, &endTime, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

 printf("calc tag[id:%d] sum value failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("calc tag[id:%d] sum value successful, sum value is %f!\n", tag.nTagID, dValue);

//get integral value

nRet = st_tag_integral(hServer,tag.nTagID, &startTime, &endTime, HD_STATS_DROP_BAD_MODE_REC,

 fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

 printf("calc tag[id:%d] integral value failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("calc tag[id:%d] integral value successful, integral value is %f!\n", tag.nTagID, dValue);

//get good percent

nRet = st_tag_good_percent(hServer,tag.nTagID, &startTime, &endTime, &dValue);

if (nRet != RD_SUCCESS)

{

 printf("calc tag[id:%d] good percent failed, error code[%d]!\n", tag.nTagID, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("calc tag[id:%d] good percent successful, good percent is %f!\n", tag.nTagID, dValue);

nt_disconnect(hServer);

return 0;

}

参考：

st_tag_min

st_tag_time_weight_mean

st_tag_rec_weight_mean

st_tag_integral

st_tag_percent_good


st_tag_min

Navigation: »No topics above this level«

st_tag_min

 Return to chapter overview

st_tag_min

Glossary Item Box

函数

给定一段时间范围，计算一个Tag点历史数据的最小值

int32 st_tag_min(

HDHANDLE hServer,

uint32 nTagID,

const HDTime* pStartTime,

const HDTime* pEndTime,

float fPercentGood,

double* pValue

);

参数

hServer

[in] 服务器句柄

nTagID

[in] TagID

pStartTime

[in] 起始时间

pEndTime

[in] 结束时间

fPencentGood

[in]置信度

pValue

[out]计算值

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

举例

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName = "szTagName";

int32 nRecNum = 3;

HDRecord records[3];

uint32 nTagIDs[3];

int32 nErrorCodes[3];

HDTime startTime;

HDTime endTime;

double dValue;

float fPercentGood = 0.0;

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add tag

strcpy(tag.szTagName, szTagName);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag id

nRet = pt_query_tagid(hServer, tag.szTagName, &tag.nTagID);

if (nRet != RD_SUCCESS)

{

printf("query tag id failed, tag name[%s], error code[%d]!\n", tag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n", tag.szTagName,tag.nTagID);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

nTagIDs[i] = tag.nTagID;

records[i].nSec = 1 + i;

records[i].nMsec = 0;

records[i].nQuality = 192;

records[i].value.nInt32 = records[i].nSec;

}

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, records, nErrorCodes);

if (nRet != RD_SUCCESS)

{

printf("save snapshots failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("save %d record successful!\n", nRecNum);

startTime.nSec = 0;

startTime.nMsec = 0;

endTime.nSec = records[nRecNum - 1].nSec + 1;

endTime.nMsec = 0;

//get max value

nRet = st_tag_max(hServer,tag.nTagID, &startTime, &endTime, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] max value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] max value successful, max value is %f!\n", tag.nTagID, dValue);

//get min value

nRet = st_tag_min(hServer,tag.nTagID, &startTime, &endTime, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] min value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] min value successful, min value is %f!\n", tag.nTagID, dValue);

//get mean value

nRet = st_tag_mean(hServer,tag.nTagID, &startTime, &endTime, HD_STATS_DROP_BAD_MODE_REC,

HD_STATS_RECORD_WEIGHT_MODE, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] mean value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] mean value successful, mean value is %f!\n", tag.nTagID, dValue);

//get sum value

nRet = st_tag_sum(hServer,tag.nTagID, &startTime, &endTime, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] sum value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] sum value successful, sum value is %f!\n", tag.nTagID, dValue);

//get integral value

nRet = st_tag_integral(hServer,tag.nTagID, &startTime, &endTime, HD_STATS_DROP_BAD_MODE_REC,

fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] integral value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] integral value successful, integral value is %f!\n", tag.nTagID, dValue);

//get good percent

nRet = st_tag_good_percent(hServer,tag.nTagID, &startTime, &endTime, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] good percent failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] good percent successful, good percent is %f!\n", tag.nTagID, dValue);

nt_disconnect(hServer);

return 0;

}

参考：

st_tag_max

st_tag_time_weight_mean

st_tag_rec_weight_mean

st_tag_integral

st_tag_percent_good


st_tag_percent_good

Navigation: »No topics above this level«

st_tag_percent_good

 Return to chapter overview

st_tag_percent_good

Glossary Item Box

函数

给定一段时间范围，统计一个Tag点历史数据中数据质量为Good的时间占总时间的百分比

int32 st_tag_good_percent(

HDHANDLE hServer,

uint32 nTagID,

const HDTime* pStartTime,

const HDTime* pEndTime,

double* pValue

);

参数

hServer

[in] 服务器句柄

nTagID

[in] TagID

pStartTime

[in] 起始时间

pEndTime

[in] 结束时间

pValue

[out]计算值

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

举例

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName = "szTagName";

int32 nRecNum = 3;

HDRecord records[3];

uint32 nTagIDs[3];

int32 nErrorCodes[3];

HDTime startTime;

HDTime endTime;

double dValue;

float fPercentGood = 0.0;

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add tag

strcpy(tag.szTagName, szTagName);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag id

nRet = pt_query_tagid(hServer, tag.szTagName, &tag.nTagID);

if (nRet != RD_SUCCESS)

{

printf("query tag id failed, tag name[%s], error code[%d]!\n", tag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n", tag.szTagName,tag.nTagID);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

nTagIDs[i] = tag.nTagID;

records[i].nSec = 1 + i;

records[i].nMsec = 0;

records[i].nQuality = 192;

records[i].value.nInt32 = records[i].nSec;

}

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, records, nErrorCodes);

if (nRet != RD_SUCCESS)

{

printf("save snapshots failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("save %d record successful!\n", nRecNum);

startTime.nSec = 0;

startTime.nMsec = 0;

endTime.nSec = records[nRecNum - 1].nSec + 1;

endTime.nMsec = 0;

//get max value

nRet = st_tag_max(hServer,tag.nTagID, &startTime, &endTime, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] max value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] max value successful, max value is %f!\n", tag.nTagID, dValue);

//get min value

nRet = st_tag_min(hServer,tag.nTagID, &startTime, &endTime, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] min value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] min value successful, min value is %f!\n", tag.nTagID, dValue);

//get mean value

nRet = st_tag_mean(hServer,tag.nTagID, &startTime, &endTime, HD_STATS_DROP_BAD_MODE_REC,

HD_STATS_RECORD_WEIGHT_MODE, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] mean value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] mean value successful, mean value is %f!\n", tag.nTagID, dValue);

//get sum value

nRet = st_tag_sum(hServer,tag.nTagID, &startTime, &endTime, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] sum value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] sum value successful, sum value is %f!\n", tag.nTagID, dValue);

//get integral value

nRet = st_tag_integral(hServer,tag.nTagID, &startTime, &endTime, HD_STATS_DROP_BAD_MODE_REC,

fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] integral value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] integral value successful, integral value is %f!\n", tag.nTagID, dValue);

//get good percent

nRet = st_tag_good_percent(hServer,tag.nTagID, &startTime, &endTime, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] good percent failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] good percent successful, good percent is %f!\n", tag.nTagID, dValue);

nt_disconnect(hServer);

return 0;

}

参考：

st_tag_max

st_tag_min

st_tag_time_weight_mean

st_tag_rec_weight_mean

st_tag_integral


st_tag_rec_weight_mean

Navigation: »No topics above this level«

st_tag_rec_weight_mean

 Return to chapter overview

st_tag_rec_weight_mean

Glossary Item Box

函数

int32 st_tag_mean(

HDHANDLE hServer,

uint32 nTagID,

const HDTime* pStartTime,

const HDTime* pEndTime,

int32 nQualityMode,

int32 nWeightMode,

float fPercentGood,

double* pValue

);

参数

hServer

[in] 服务器句柄

nTagID

[in] TagID

pStartTime

[in] 起始时间

pEndTime

[in] 结束时间

nQualityMode

[in]弃坏点模式,HD_STATS_DROP_BAD_MODE_REC 弃bad记录;HD_STATS_DROP_BAD_MODE_AREA弃bad记录相邻的区域

nWeightMode

[in]求均值模式,HD_STATS_TIMED_WEIGHT_MODE 以时间为权值;HD_STATS_RECORD_WEIGHT_MODE 无权值

fPencentGood

[in]置信度

pValue

[out]计算值

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

举例

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName = "szTagName";

int32 nRecNum = 3;

HDRecord records[3];

uint32 nTagIDs[3];

int32 nErrorCodes[3];

HDTime startTime;

HDTime endTime;

double dValue;

float fPercentGood = 0.0;

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add tag

strcpy(tag.szTagName, szTagName);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag id

nRet = pt_query_tagid(hServer, tag.szTagName, &tag.nTagID);

if (nRet != RD_SUCCESS)

{

printf("query tag id failed, tag name[%s], error code[%d]!\n", tag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n", tag.szTagName,tag.nTagID);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

nTagIDs[i] = tag.nTagID;

records[i].nSec = 1 + i;

records[i].nMsec = 0;

records[i].nQuality = 192;

records[i].value.nInt32 = records[i].nSec;

}

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, records, nErrorCodes);

if (nRet != RD_SUCCESS)

{

printf("save snapshots failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("save %d record successful!\n", nRecNum);

startTime.nSec = 0;

startTime.nMsec = 0;

endTime.nSec = records[nRecNum - 1].nSec + 1;

endTime.nMsec = 0;

//get max value

nRet = st_tag_max(hServer,tag.nTagID, &startTime, &endTime, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] max value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] max value successful, max value is %f!\n", tag.nTagID, dValue);

//get min value

nRet = st_tag_min(hServer,tag.nTagID, &startTime, &endTime, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] min value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] min value successful, min value is %f!\n", tag.nTagID, dValue);

//get mean value

nRet = st_tag_mean(hServer,tag.nTagID, &startTime, &endTime, HD_STATS_DROP_BAD_MODE_REC,

HD_STATS_RECORD_WEIGHT_MODE, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] mean value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] mean value successful, mean value is %f!\n", tag.nTagID, dValue);

//get sum value

nRet = st_tag_sum(hServer,tag.nTagID, &startTime, &endTime, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] sum value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] sum value successful, sum value is %f!\n", tag.nTagID, dValue);

//get integral value

nRet = st_tag_integral(hServer,tag.nTagID, &startTime, &endTime, HD_STATS_DROP_BAD_MODE_REC,

fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] integral value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] integral value successful, integral value is %f!\n", tag.nTagID, dValue);

//get good percent

nRet = st_tag_good_percent(hServer,tag.nTagID, &startTime, &endTime, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] good percent failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] good percent successful, good percent is %f!\n", tag.nTagID, dValue);

nt_disconnect(hServer);

return 0;

}

参考：

st_tag_max

st_tag_min

st_tag_time_weight_mean

st_tag_integral

st_tag_percent_good


st_tag_time_weight_mean

Navigation: »No topics above this level«

st_tag_time_weight_mean

 Return to chapter overview

st_tag_time_weight_mean

Glossary Item Box

函数

给定一段时间范围，计算一个Tag点历史数据的和

int32 st_tag_sum(

HDHANDLE hServer,

uint32 nTagID,

const HDTime* pStartTime,

const HDTime* pEndTime,

float fPercentGood,

double* pValue

);

参数

hServer

[in] 服务器句柄

nTagID

[in] TagID

pStartTime

[in] 起始时间

pEndTime

[in] 结束时间

fPencentGood

[in]置信度

pValue

[out]计算值

返回值

添加成功，返回RD_SUCEESS。添加失败返回错误码，见error_code.h。

举例

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tag;

const char* szTagName = "szTagName";

int32 nRecNum = 3;

HDRecord records[3];

uint32 nTagIDs[3];

int32 nErrorCodes[3];

HDTime startTime;

HDTime endTime;

double dValue;

float fPercentGood = 0.0;

int32 i = 0;

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//add tag

strcpy(tag.szTagName, szTagName);

tag.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tag, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

printf("add tags[%s] failed, error code [%d]!\n", tag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tag.szTagName);

//query tag id

nRet = pt_query_tagid(hServer, tag.szTagName, &tag.nTagID);

if (nRet != RD_SUCCESS)

{

printf("query tag id failed, tag name[%s], error code[%d]!\n", tag.szTagName, nRet);

nt_disconnect(hServer);

return -1;

}

printf("tag[%s] query tag id successful, tag id[%d]!\n", tag.szTagName,tag.nTagID);

// save snapshots

for (i = 0; i < nRecNum; i ++)

{

nTagIDs[i] = tag.nTagID;

records[i].nSec = 1 + i;

records[i].nMsec = 0;

records[i].nQuality = 192;

records[i].value.nInt32 = records[i].nSec;

}

nRet = sn_save_snapshots(hServer, nRecNum, nTagIDs, records, nErrorCodes);

if (nRet != RD_SUCCESS)

{

printf("save snapshots failed, error code[%d]!\n", nRet);

nt_disconnect(hServer);

return -1;

}

printf("save %d record successful!\n", nRecNum);

startTime.nSec = 0;

startTime.nMsec = 0;

endTime.nSec = records[nRecNum - 1].nSec + 1;

endTime.nMsec = 0;

//get max value

nRet = st_tag_max(hServer,tag.nTagID, &startTime, &endTime, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] max value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] max value successful, max value is %f!\n", tag.nTagID, dValue);

//get min value

nRet = st_tag_min(hServer,tag.nTagID, &startTime, &endTime, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] min value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] min value successful, min value is %f!\n", tag.nTagID, dValue);

//get mean value

nRet = st_tag_mean(hServer,tag.nTagID, &startTime, &endTime, HD_STATS_DROP_BAD_MODE_REC,

HD_STATS_RECORD_WEIGHT_MODE, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] mean value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] mean value successful, mean value is %f!\n", tag.nTagID, dValue);

//get sum value

nRet = st_tag_sum(hServer,tag.nTagID, &startTime, &endTime, fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] sum value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] sum value successful, sum value is %f!\n", tag.nTagID, dValue);

//get integral value

nRet = st_tag_integral(hServer,tag.nTagID, &startTime, &endTime, HD_STATS_DROP_BAD_MODE_REC,

fPercentGood, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] integral value failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] integral value successful, integral value is %f!\n", tag.nTagID, dValue);

//get good percent

nRet = st_tag_good_percent(hServer,tag.nTagID, &startTime, &endTime, &dValue);

if (nRet != RD_SUCCESS)

{

printf("calc tag[id:%d] good percent failed, error code[%d]!\n", tag.nTagID, nRet);

nt_disconnect(hServer);

return -1;

}

printf("calc tag[id:%d] good percent successful, good percent is %f!\n", tag.nTagID, dValue);

nt_disconnect(hServer);

return 0;

}

参考：

st_tag_max

st_tag_min

st_tag_rec_weight_mean

st_tag_integral

st_tag_percent_good


系统关闭

Navigation: »No topics above this level«

系统关闭

 Return to chapter overview

系统关闭

Glossary Item Box

《系统关闭》主要介绍服务端关闭和客户端关闭：

服务端关闭：

?若iHyperDB服务端程序已被安装为Windows系统服务，关闭时，点击“开始”->“所有程序”->“iHyperDB”->“服务端应用快捷链接”->“停止iHyperDB系统服务”。

?若iHyperDB服务端程序没有被安装为系统服务，关闭时，在正在运行的hdKernel.exe，hdNegMgr.exe以及hdAlarmSvc.exe控制台程序中，输入Q即可。不区分大小写。

客户端关闭：

iHyperDB客户端程序，均可在界面上点关闭或退出


Tag点管理

Navigation: »No topics above this level«

Tag点管理

 Return to chapter overview

用户可以通过RPCServer对Tag点进行增删改查等操作：

u 接口

u 增加Tag点（addTags）

u 删除Tag点（delete Tags）

u 修改Tag点（modifyTags）

u 查询Tag点信息（queryTagsInfo）

u 查询Tag点属性（queryTagsProp）

u tag点属性字段列表

v 接口：

module IHDTag{

exception InvokeError

{

string reason;

}

sequence<byte> JsonSeq;

interface HDTagHandler{

int addTags (JsonSeq request, out JsonSeq response) throws InvokeError;

int deleteTags (JsonSeq request, out JsonSeq response) throws InvokeError;

int modifyTags (JsonSeq request, out JsonSeq response) throws InvokeError;

int queryTagsInfo (JsonSeq request, out JsonSeq response) throws InvokeError;

int queryTagsProp (JsonSeq request, out JsonSeq response) throws InvokeError;

};

};

v 增加Tag点（addTags）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | sumNum | int | 否 | tag总数
 | tagClass | int | 否 | tag点类别 0：普通点 1：报警点 2：统计点 3：计算点 4：SPC 5：系统点
 | tags | array | 否 | tag点数组
 | +tagName | string | 否 | tag点名
 | +tagType | int | 是 | tag点数据类型 0： HD3_TAG_TYPE_INT 1： HD3_TAG_TYPE_INT16, 2： HD3_TAG_TYPE_INT32, 3： HD3_TAG_TYPE_FLOAT32, 4： HD3_TAG_TYPE_FLOAT64, 5： HD3_TAG_TYPE_DIGITAL, 6： HD3_TAG_TYPE_STRING, 7： HD3_TAG_TYPE_BLOB
 | +descriptor | string | 是 | tag描述
 | …… | string | 是 |
返回值列表 |
 | response | object | 否 |
 | tags | array | 否 | tag点数组
 | +tagName | string | 是 | tag点名
 | +reason | string | 是 | 失败原因
 | +errorCode | int | 是 | 错误编号

v 删除Tag点（delete Tags）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | sumNum | int | 否 | tag总数
 | tags | array | 否 | tag点数组
 | +tagName | string | 否 | tag点名
返回值列表 |
 | response | object | 否 |
 | tags | array | 否 | tag点数组
 | +tagName | string | 是 | tag点名
 | +tagId | string | 是 | tag点ID
 | +errorCode | int | 是 | 错误编号

v 修改Tag点（modifyTags）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | sumNum | int | 否 | tag总数
 | tagClass | int | 否 | tag点类别 0：普通点 1：报警点 2：统计点 3：计算点 4：SPC 5：系统点
 | tags | array | 否 | tag点数组
 | +tagName | string | 否 | tag点名
 | +descriptor | string | 是 | tag描述
 | …… | string | 是 |
返回值列表 |
 | response | object | 否 |
 | tags | array | 否 | tag点数组
 | +tagName | string | 是 | tag点名
 | +tagId | string | 是 | tag点ID
 | +errorCode | int | 是 | 错误编号

v 查询Tag点信息（queryTagsInfo）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 | 查询条件参考ihd系统管理工具
 | userName | string | 否 | 用户名
 | limit | int | 否 | 分页大小
 | offset | int | 否 | 分页起始位置
 | conditions | array | 否 | 查询条件数组
 | +field | string | 否 | 查询字段
 | +operator | int | 否 | 操作符 0：= 1：<> 2：> 3：>= 4：< 5：<= 6：like
 | +value | string | 否 | 字段对应值
返回值列表 |
 | response | object | 否 |
 | totalCount | int | 否 | tag点总数
 | tags | array | 是 | tag点id数组
 | +tagId | int | 是 | tag点id
 | +tagName | string | 是 | tag点名
 | +tagType | int | 是 | tag点数据类型 0： HD3_TAG_TYPE_INT 1： HD3_TAG_TYPE_INT16, 2： HD3_TAG_TYPE_INT32, 3： HD3_TAG_TYPE_FLOAT32, 4： HD3_TAG_TYPE_FLOAT64, 5： HD3_TAG_TYPE_DIGITAL, 6： HD3_TAG_TYPE_STRING, 7： HD3_TAG_TYPE_BLOB
 | +tagClass | int | 是 | tag点类别 0：普通点 1：报警点 2：统计点 3：计算点 4：SPC 5：系统点
 | +descriptor | string | 是 | tag点描述

v 查询Tag点属性（queryTagsProp）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | tagClass | int | 否 | tag点类别 0：普通点 1：报警点 2：统计点 3：计算点 4：SPC 5：系统点
 | tags | array | 否 | tag点名数组
 | +tagName | string | 否 | tag点名
返回值列表 |
 | response | object | 否 |
 | tags | array | 否 | tag点数组
 | +tagName | string | 否 | tag点名
 | +descriptor | string | 是 | tag描述
 | …… | string | 是 |

v tag点属性字段列表

公共属性 | 说明 | 普通点特有属性 | 说明 | 计算点特有属性 | 说明 | 统计点特有属性 | 说明
"tagName" |  | "instrumentAddress" |  | "caCalcMode" |  | "statsType" |
"archiving" |  | "instrumentAddressType" |  | "calcPeriod" |  | "sampleStartDate" |
"changeDate" |  | "collectorName" | 采集器名 | "calcExpr" |  | "sampleMode" | enum，统计点采样模式/统计方式，HD3_STATS_SAMPLE_MODE
"changer" |  | "collectorID" |  | "calcHistory" | 是否设置开始时间，bool | "sampleInterval" |
"compDev" | float，存储压缩-误差 | "deviceName" |  | "calcStartDate" |  | "sampleBeginOffset" | 基本-每天时段-开始
"compMaxTime" | 基本-存储压缩-超时 | "deviceID" |  | "calcEndDate" |  | "sampleEndOffset" | 基本-每天时段-结束
"compType" | bool，存储-压缩 | "scanGroupName" |  | "haveEndTime" | 是否设置结束时间，bool | "sampleMonthBeginDay" | 基本-定周期-每月时段-开始
"creationDate" |  | "scanGroupID" |  | "caSourceTagName" |  | "sampleMonthEndDay" | 基本-定周期-每月时段-结束
"creator" |  | "dataOrder" | enum，modbus专用，dataType与类型关系见TagConfig.cpp中SetCurrentDataAddr方法 |  |  | "beginTimeStamp" | bool，其他-记录时间戳-起始（1）/结束（0）
"recAccess" | int，详见iHD的权限管理-记录和Tag编辑权限配置说明 |  |  |  |  | "timeStampOffset" | 其他-记录时间戳-起始/结束偏移
"recNormalGroup" |  |  |  |  |  | "scanPeriod" | 基本-扫描周期
"recOwnerGroup" | 不能为不存在的组 |  |  |  |  | "pctGood" | 最小信任度
"descriptor" |  |  |  |  |  | "filterExpr" |
"digitalSet" |  |  |  |  |  | "dropBadMode" | 统计类型为时间加权平均值（INDEX_STATISTIC_TYPE_MEAN_TIME）和积分（INDEX_STATISTIC_TYPE_INTEGRAL）的时候，设成1(HD3_STATS_DROP_BAD_MODE_AREA)，其他都是0(HD3_STATS_DROP_BAD_MODE_REC)
"engUnits" | 工程单位 |  |  |  |  | "countParam1" | 统计类型-计数类型下的两个参数
"excMaxTime" |  |  |  |  |  | "countParam2" | 统计类型-计数类型下的两个参数
"excDev" | 采集过滤误差 |  |  |  |  | "sampleType" | enum，统计采样类型，HD_SAMPLE_TYPE
"tagID" |  |  |  |  |  | "interpOffset" |
"tagType" |  |  |  |  |  | "interpPeriod" |
"tagAccess" | int，转二进制，只看高位，表示是否 |  |  |  |  | "conversionType" |
"tagNormalGroup" |  |  |  |  |  | "conversion" |
"tagOwnerGroup" |  |  |  |  |  | "filterFailMode" |
"scan" |  |  |  |  |  | "stCalcPeriod" | 计算周期
"span" |  |  |  |  |  | "reset" |
"minValue" |  |  |  |  |  | "useBadValue" | 使用bad记录
"tagClass" |  |  |  |  |  | "stSourceTagName" | 监测点
"tagAvaliable" |  |  |  |  |  |  |
"param1" |  |  |  |  |  |  |
"param2" |  |  |  |  |  |  |
"param3" |  |  |  |  |  |  |
"param4" |  |  |  |  |  |  |
"param5" |  |  |  |  |  |  |
"opcState" |  |  |  |  |  |  |
"iMVString" | 旧组态，作废 |  |  |  |  |  |
"extString1" |  |  |  |  |  |  |
"extString2" |  |  |  |  |  |  |


启动备份服务

Navigation: »No topics above this level«

启动备份服务

 Return to chapter overview

开始菜单->iHyperDB->客户端应用快捷连接->数据库备份工具。

点击工具栏中“启动服务”图标按钮，将备份服务打开，如下图，可根据需要安装为windows服务，然后启动服务。


配置和数据恢复

Navigation: »No topics above this level«

配置和数据恢复

 Return to chapter overview

配置恢复

1.用于恢复数据的机器需要是全新的环境，全新安装实时数据库且需与备份的实时数据库同版本，同配置（内存缓冲区大小，硬盘数据文件大小，数据文件个数，三个参数必须一致）。用于恢复数据的机器硬件环境（内存、硬盘）也应不小于原机器配置。

2.停止当前备份数据库服务器的各项iHyperDB服务之后，将之前备份的ConfigCenter.db配置文件拷贝到新安装实时数据库的config文件夹内，覆盖config文件。

3.拷贝备份目录的ConfigCenter.db的最新配置到新装的config目录，覆盖ConfigCenter.db后，重新启动配置中心服务。恢复过来的数据节点的IP如果变化，需要根据本地环境进行修改，在客户端的“系统管理平台-数据节点配置”界面进行修改，参见数据节点配置。

数据恢复

4.打开“数据节点服务管理工具”，启动全部服务。注意需要等待数据节点同步服务同步所有的点至各个数据节点。如果需要查看Tag点是否同步成功，可以打开各个数据节点安装目录下config/Config.db中是否有恢复过来的Tag点，如果有说明已经同步成功。

5.启动客户端的备份与恢复服务，打开备份与恢复工具。

6.在备份与恢复工具中新建备份库，选择备份库路径，备份库路径是拷贝过来的文件的路径。

7.界面左侧树选择“恢复”节点。点击“测试连接”确认是否和配置中心联通。然后单击“立即恢复”。

§目标服务器配置：表示数据要恢复的目标服务器，包括IP、端口号、用户名和密码的配置。单击“测试连接”可以测试与该服务器是否连接。

§备份库路径：表示当前备份库的数据所在位置。

§备份数据起始时间：

§进度条：表示恢复的进度；

§“立即恢复”和“停止恢复”按钮控制恢复动作的启动和停止；

§优先显示恢复数据的起始和结束时间，其次显示用户配置的起始和结束时间（即配置文件中的时间）。

8.恢复成功后，弹出提示对话框。这时再启动之前数据未启动的其他服务。若要查看数据是否恢复成功，可以打开系统管理平台，查询Tag点的历史记录，如下图所示。

1.恢复的机器部署结构和备份的分布结构需一致，如数据节点数量。

2.用于备份和恢复的两个iHyperDB服务端的版本要一致。


部署双机热备

Navigation: »No topics above this level«

部署双机热备

 Return to chapter overview

windows平台部署实时数据库冗余

本文以最典型的双机热备冗余为例。双机热备网络结构说明请参考“iHyperDB常见网络结构”。

环境：2台windows服务器（例如主机地址为168.2.9.94和备机地址168.2.237.54）， 实时数据库安装程序版本3.2.0及以上。

1、主机上安装配置中心，配置中心程序名称为iHyperDB_ServerInstall.exe。

网络检测IP是可选项，建议勾选，它配置为网络上主备服务器都能Ping的第三方地址，一般为网关。网络检测IP的作用是主备服务器网络断开后通过Ping此网络检测IP来判断是主服务器网络断开还是备服务器网络断开。如果不勾选网络检测IP，出现主备服务器网络断开时会出现双主的情况，网络恢复后恢复正常，出现双主的情况下冗余功能不会受到影响。

对于双网卡配置的服务器，增加双IP配置，可以让管理网和现场采集层都可以访问实时数据库。如下图：

添加数据节点时也设置双IP，如下图：

2、主机上安装数据节点，数据节点程序名称为iHyperDB_DataNode.exe。

勾选安装为系统服务的话需要重启生效，点击完成。

3、主机上安装客户端，客户端程序名称为iHyperDB_Client.exe。

4、备机上安装配置中心，配置中心程序名称为iHyperDB_ServerInstall.exe。

同步骤1

5、备机上安装数据节点，数据节点程序名称为iHyperDB_DataNode.exe。

同步骤2

6、备机上安装客户端，客户端程序名称为iHyperDB_Client.exe。

同步骤3

7、在主机和备机上打开数据节点服务管理工具，启动主机和备机上的所有服务。数据节点管理工具在开始菜单可以找到。

注意第一次启动hdKernel的启动状态会一直处于正在启动状态，这是因为第8步添加数据节点还没有完成，完成第8步hdKernel的启动就会完成。

8、打开主机或者备机上的的系统管理工具，连接到主备服务器，添加数据节点，配置数据节点主备为168.2.9.94和168.2.237.54。

点击状态，弹出登陆框

输入admin/admin 点击确定

点击系统管理平台的数据节点配置图标

点击数据节点配置的添加按钮，添加一个数据节点，设置数据节点的主机地址和备机地址，点击确定数据节点test添加成功。

点击确定，冗余数据节点添加成功。查看数据节点的hdKernel状态正常（注意第一次启动时需要创建文件，根据配置的文件大小从几十秒到几分钟不等）。

冗余双机热备部署完成。

多数据节点如何部署冗余

1、选择2台机器安装主备配置中心，安装步骤参见双机热备的第一步。

2、在每个数据节点的机器上安装数据节点，安装步骤参见双机热备第二步。

3、开启所有机器的后台服务，步骤参见双机热备第七步。

4、在系统管理平台的数据节点管理界面添加多个主备数据节点，参见双机热备的第八步。

双网卡服务器如何部署冗余

以双机冗余为例，主机地址为168.2.9.94和192.168.128.1备机地址168.2.9.95和192.168.128.2。配置过程与上面最典型的双机热备冗余一样。

需要注意的是

1.第1步的“主备冗余配置中心设置”中主服务器IP配置为168.2.9.94/192.168.128.1。备服务器IP配置为168.2.9.95/192.168.128.2。

2. 第8步添加数据节点时，数据节点配置为主IP 168.2.9.94/192.168.128.1，备IP168.2.9.95/192.168.128.2


大数据采集转发服务

Navigation: »No topics above this level«

大数据采集转发服务

 Return to chapter overview

功能：采集实时数据库中的数据上传到xinsight大数据平台中。

安装：

有两个安装途径：

1.安装iHyperDB的过程中，选择安装，详见整体安装说明；

2.选择大数据采集器安装包安装，详见单独安装说明；

整体安装：

安装iHyperDB数据节点的时候选择安装大数据采集器(iHyperDB安装过程请参考帮助文件：安装和卸载下的相关章节)，在安装过程中出现下图，点选“大数据采集转发服务”，并点击“下一步”。

进入“大数据平台参数设置”画面，如下图：

填写大数据采集器连接的“URI，Token，identifier”三个连接参数，具体参数请咨询大数据平台产品的应用支持人员。

点击“安装”，开始安装。

单独安装：

在iHyperDB安装包里双击“BigdataCollector.exe”，这是大数据采集转发服务的安装包。

如下图，出现安装向导画面，点击下一步：

如下图，选择安装位置，并点击“下一步”：

iHyperDB3.5版本及以前会如下图，进入“配置中心服务设置”画面。iHyperDB3.6版本会跳过此步骤，直接进入下一个步骤。

iHyperDB配置服务参数：

Ø设置本机IP:由于安装机器可能有多块网卡，请于此处选择计划与大数据平台系统网络通讯用网卡IP；

Ø配置中心服务端口：通讯端口缺省“5673”，如无必要请勿修改；

如果没有安装过PostgreSQL,请先点击安装，再填写连接参数。如果已安装，可填写PostgreSQL关系库连接参数后，点击“下一步”。

进入“大数据平台参数设置”画面，如下图：

填写大数据采集器连接的“URI，Token，identifier”三个连接参数，具体参数请咨询大数据平台产品的应用支持人员。

点击“安装”，开始安装。

注：如果在安装过程没有填写配置项，也可在采集器安装目录下的executable文件夹中（Unix版本在ihyperdb\runtime下），配置BigDataConfig.xml。如下图：

修改BigData下的URI，Token，identifier三个配置项，对应大数据平台。Threadpoolnum是大数据采集器内部并发的工作线程数，默认是5，可根据现场tag点数和机器性能来修改，最小为1，最大为20；可以根据“tag总点数\2万点”，来计算得到该线程数的值。

启用：

v启动大数据平台采集服务。

完整安装后，点击目录下的“数据节点服务管理工具”，如下图。

在数据节点服务管理工具的进程管理中可查看大数据采集器服务（hdBigdataCollector）状态，以及启动/停止服务，如下图

独立安装大数据采集器方式，需运行安装目录executable文件夹下hdBigdataServiceManager.exe，进行安装服务、启停服务等操作。

v配置数据源Tag点：

1)在管理工具的进程管理中，确认大数据采集服务已正常启动。

2)使用系统管理工具（hdSysMgrTool.exe）和OPC采集器配置工具（hdCollectorConfigTool.exe）配置tag点和OPC采集

采集的步骤参见OPC采集tag点经典案例

v相关OPC配置的tag点自动在大数据平台中注册。

v在大数据平台中，如果是pds则需要新建实例，并关联或者勾选上传Tag点。具体步骤参见大数据平台用户手册；

如果是tsdb，不需要新建实例，已默认上传，可在大数据平台直接修改tag压缩等属性。

v此时OPC采集的数据会自动上传到大数据平台。在平台的实时数据查看页面和历史数据查看页面都可以查看。

v大数据采集器支持计算点和统计点。


超时问题

Navigation: »No topics above this level«

超时问题

 Return to chapter overview

ihd的数据存储服务会定期将内存缓存中的数据保存到硬盘中，在这个过程中如果有乱序数据插入或者历史数据查询可能导致数据存储服务响应客户端性能下降，

严重时会导致客户端响应超时，以下措施会改善这种情况下客户端响应的性能：

打开数据节点上的iHyperDB/config目录的ServerCfg.xml,修改iHyperDBSrv-Kernel-ArchiveFile节点下的元素ArchiveWindowSize的值，将这个值改小可以提升

内存缓存写硬盘时响应客户端的速度，该值最小为1，默认值为2000，最大值建议不要超过2000.


部署实时数据库单机双网

Navigation: »No topics above this level«

部署实时数据库单机双网

 Return to chapter overview

环境：1台有双网卡的windows服务器（例如地址为168.2.9.94和168.2.237.54）和1台window客户端机器，客户端机器能同时连接到168.2.9.94和168.2.237.54， 实时数据库安装程序版本3.5.0及以上。

1?服务器上安装配置中心，配置中心程序名称为iHyperDB_ServerInstall.exe。

请注意在这一步将主服务器IP和备服务器IP配置分别配置为服务器的2个IP地址168.2.9.94和168.2.237.54， 并且不要勾选网络检测IP。

2?服务器上安装数据节点，数据节点程序名称为iHyperDB_DataNode.exe。

本机IP选择168.2.9.94和168.2.237.54中的其中一个。

3?客户端机器上安装实时数据库客户端，客户端程序名称为iHyperDB_Client.exe。

4?在服务器上打开数据节点服务管理工具，启动所有服务。数据节点管理工具在开始菜单可以找到。

注意第一次启动hdKernel的启动状态会一直处于正在启动状态，这是因为第5步添加数据节点还没有完成，完成第5步hdKernel的启动就会完成。

5?打开客户端机器上的系统管理工具，连接到服务器的主备2个IP地址，添加数据节点，配置数据节点主备为服务器的2个IP地址168.2.9.94和168.2.237.54。

点击状态，弹出登陆框

输入admin/admin 点击确定

点击系统管理平台的数据节点配置图标

点击数据节点配置的添加按钮，添加一个数据节点，设置数据节点的主机地址和备机地址，点击确定数据节点test添加成功。

点击确定，冗余数据节点添加成功。查看数据节点的hdKernel状态正常（注意第一次启动时需要创建文件，根据配置的文件大小从几十秒到几分钟不等）。

单机双网冗余部署完成，其它客户端只要连接服务器时同时连接服务器的2个地址即可实现双网冗余的功能。


典型案例12-计算点采集 电量计算案例

Navigation: »No topics above this level«

典型案例12-计算点采集 电量计算案例

 Return to chapter overview

本案例的场景：

原始采集信号：电表计量值（到达该表量程最大值或因现场换新表，该数据会被清零，并重新开始计数。）

计算需求：根据电表计量值，做定时差值运算，将结果累加，但需对原始数据清零重计的例外进行处理。

假设：

 | Tag类别 | Tag名称
电表计量值 | 普通点 | Tag
电量计算值 | 计算点 | Ca

计算表达式：

IF(NoneRecord('Ca'))THEN('Tag')ELSE IF('Tag'>=PrevVal('Tag'))THEN('Ca'+'Tag'-PrevVal('Tag'))ELSE('Ca'+'Tag')

该计算表达式所引用的内置函数，请参阅计算点内置函数说明。


上云配置更新及状态查询

Navigation: »No topics above this level«

上云配置更新及状态查询

 Return to chapter overview

上云配置更新及状态查询：

接口说明：

u接口

u上云配置更新/新增

u上云配置删除

u配置状态查询

u上云服务状态查询

json示例：

u配置更新

u配置删除

u状态查询

u上云服务状态查询

接口说明：

v 接口：

module IHDConfig

{

exception InvokeError

{

string reason;

}

sequence<byte> JsonSeq;

interface HDConfigHandler

{

int updateConfig(JsonSeq request, out JsonSeq response) throws InvokeError;

int deleteConfig(JsonSeq request, out JsonSeq response) throws InvokeError;

int queryState(JsonSeq request, out JsonSeq response) throws InvokeError;

int queryServiceState(out JsonSeq response) throws InvokeError;

}

}

使用EiInfo类组织上云配置二进制数据，在调用ConfigUpdate接口前：

1) 调用SerializeEIClassToJSonV2接口将EiInfo转换为json字符串，该json字符串二进制数据作为ConfigUpdate接口的传入参数；

2) 调用EiInfo类提供的Serialize接口将EiInfo对象序列化，作为传入参数传入ConfigUpdate。

成功返回0，失败返回错误码。

v 上云配置新增/更新

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | type | int | 否 | 0为增量导入，1为全量导入
 | sumNum | int | 否 | 导入点数个数（单次导入点位上限为999）
 | tags | array | 否 | 导入点数信息列表，详见下表
返回值列表 |
 | response | object | 否 |
 | updatedTags | int | 否 | 导入tag个数
 | invalidTags | int | 否 | 未导入tag个数
 | reasons | array | 是 | 未导入原因列表
 | +reason | string | 是 | 未导入原因

序号 | 字段 | 英文名 | 是否必填项 | 定义 | 示例
1 | 机组号 | UNIT_NUMBER | 必填 | 边缘节点所在机组号，由运营中心牵头统一整理并提供规范，并在平台上提供录入和维护，在平台未上线前，线下获取。 | H032
2 | 边缘字段英文名称 | TAG_NAME | 必填 | ihd数据库中的tag点名 | BCU_FLAME-CURRENT_AA_BCM2
3 | 云上英文字段 | TAG_CLOUD_EN_NAME | 必填 | 按照字段规范，以数据元英文名称为基础进行扩展 | RADIA_PIPE_IGN_CON_CUR_AA_BCM2
4 | 云上中文字段 | TAG_CLOUD_CH_NAME | 选填 | 按照字段规范，以数据元英文名称为基础进行扩展 | BCM2辐射管点火控制器电流
5 | 引用数据元英文 | TAG_REFERENCE_EN_NAME | 选填 | 按照字段规范，以数据元中文名称为基础进行扩展 | HF_CHGMCH_ARM_ROUTE_ACT
6 | 引用数据元中文 | TAG_REFERENCE_CH_NAME | 选填（根据D列引用大数据中心数典功能，不需要人工填写） | 按照字段规范，以数据元中文名称为基础进行扩展 | 辐射管点火控制器电流
7 | 引用数据元标识符 | TAG_REFERENCE_SOURCE_IDENTIFIER | 选填（根据D列引用大数据中心数典功能，不需要人工填写） | 必填，数据元标识ID在数据元导出时会一并带上 | DEBG000000081721
8 | 工厂 | FACTORY | 选填 |  | baoshan
9 | 区域 | AREA | 选填 |  | cold-rolling
10 | 设备 | TAG_EQUIPMENT | 选填 | 设备名称 | CHGMCH_ARM
11 | 同步方式 | TAG_SYNC_TYPE | 必填 | 必填，填写0或者1，同步上云方式，0代表注册推送方式，1代表周期发送 | 1
12 | 数据采集间隔 | TAG_COLLECT_INTERVAL | 选填 | 针对PLC/传感器，表示数据分辨率，单位为ms | 1000
13 | 数据采样间隔(同步周期) | TAG_PERIOD | 必填 | 边缘采样的数据间隔，单位为ms，同步方式为1时该字段有效 | 1000
14 | 数据发送频率 | TAG_SEND_FREQUENCY | 必填 | 边缘向大数据中心发送采样数据的间隔，单位为ms，数据发送模式为DM时，该字段有效，其余发送模式，该字段无效 | 20
15 | 数据发送模式 | TAG_SEND_MODE | 必填 | D：单tag点单值 DM：单tag点多值 DMM：多tag点单值（时间不对齐） DMA：多tag点单值（时间对齐） 同步方式设置为周期式同步方式时该字段有效。同步方式为注册式同步方式时，该字段填写"DMM"。 | DMM
16 | 压缩率 | TAG_COMPDEV | 选填 | 默认为0，即不压缩 |
17 | 整数位 | TAG_INTEGER_NUMBER | 选填 | 表示上云数据的总位数(包括整数位数和小数位数)不能超出该值，非零值时该字段才生效，当tagvalue超出设置的整数位数时，会截断后面的数据。 | 整数位设置为3，有效数位为2，系数设置为1，ihd中tag点tagvalue为83.3421， 最终上云数据为83.3
18 | 有效数位 | TAG_EFFECTIVE_NUMBER | 选填 | 表示小数位位数不能超出该值，为非零值时该字段才生效，当tagvalue小数位超出设置的位数时，会截断后面的数据 | 整数位设置为5，有效数位为1，系数设置为1，ihd中tag点tagvalue为8343.3421， 最终上云数据为8343.3
19 | 系数 | TAG_COEFFICIENT | 选填 | 用于单位转换，把iHperDB中存储数据转换成符合云上存储的单位，为非零值时该字段有效。上云服务依次进行系数、有效数位、整数位的处理。 | 整数位设置为5，有效数位为1，系数设置为0.5，ihd中tag点tagvalue为100， 最终上云数据为50

v上云配置删除

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | tags | array | 否 | 待删除tag点名列表
 | +tagName | string | 否 | tag点名
返回值列表 |
 | response | object | 否 |
 | deletedTags | int | 否 | 待删除tag个数
 | invalidTags | int | 否 | 未删除tag个数
 | reasons | array | 是 | 未删除原因列表
 | +tagName | string | 是 | 未删除tag点名
 | +reason | string | 是 | 未删除原因

v配置状态查询

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | startTime | string | 否 | 查询开始时间，形如：2023-07-04T00:00:00
 | sendMode | string | 是 | tag点发送方式，如"DM"，不填时返回所有
返回值列表 |
 | response | object | 否 |
 | syncedTags | int | 否 | 上云发送点数
 | configedTags | int | 否 | 上云配置点数
 | bugTags | array | 是 | 问题点位列表
 | +tagName | string | 是 | 问题tag点名
 | +cloudEnName | string | 是 | 问题tag点云上英文名
 | +lastSyncTime | string | 是 | Unix时间（ms），如1689736706000

v上云服务状态查询

返回值列表 | 名称 | 类型 | 是否可空 | 备注
 | response | object | 否 |
 | result | int | 否 | 服务状态，0表示正在运行，1表示正在启动，2表示已停止
 | startTime | string | 否 | 服务启动时间，形如：2023-07-04T00:00:00
 | stopTime | string | 是 | 服务停止时间，形如：2023-07-04T00:00:00
 | reason | string | 是 | 服务停止原因

json示例：

v配置更新

输入示例：

{

"type": 0,

"sumNum": 2,

"tags": [

{

"UNIT_NUMBER": "0",

"TAG_NAME": "TagName0",

"TAG_CLOUD_EN_NAME": "tag0",

"TAG_CLOUD_CH_NAME": "标签0",

"TAG_REFERENCE_EN_NAME": "tag0",

"TAG_REFERENCE_CH_NAME": "refTag0",

"TAG_REFERENCE_SOURCE_IDENTIFIER": "",

"FACTORY": "factory",

"AREA": "area",

"TAG_EQUIPMENT": "Tag",

"TAG_SYNC_TYPE": 0,

"TAG_COLLECT_INTERVAL": 1,

"TAG_PERIOD": 1,

"TAG_SEND_FREQUENCY": 1,

"TAG_SEND_MODE": "D",

"TAG_COMPDEV": 0,

"TAG_INTEGER_NUMBER": 0,

"TAG_EFFECTIVE_NUMBER": 0,

"TAG_COEFFICIENT": 0

},

{

"UNIT_NUMBER": "1",

"TAG_NAME": "TagName1",

"TAG_CLOUD_EN_NAME": "tag1",

"TAG_CLOUD_CH_NAME": "标签1",

"TAG_REFERENCE_EN_NAME": "tag1",

"TAG_REFERENCE_CH_NAME": "refTag1",

"TAG_REFERENCE_SOURCE_IDENTIFIER": "",

"FACTORY": "factory",

"AREA": "area",

"TAG_EQUIPMENT": "Tag",

"TAG_SYNC_TYPE": 0,

"TAG_COLLECT_INTERVAL": 1,

"TAG_PERIOD": 1,

"TAG_SEND_FREQUENCY": 1,

"TAG_SEND_MODE": "D",

"TAG_COMPDEV": 0,

"TAG_INTEGER_NUMBER": 0,

"TAG_EFFECTIVE_NUMBER": 0,

"TAG_COEFFICIENT": 0

}

]

}

输出示例：

{

"updatedTags": 2,

"invalidTags": 2,

"reasons": [

{

"tagName": "TagName0",

"reason": "Invalid json field: TAG_SEND_MODE"

},

{

"tagName": "TagName1",

"reason": "Invalid json field: TAG_SEND_MODE"

}

]

}

v 配置删除：

输入示例：
{

"tags": [

{

"tagName": "TagName0"

},

{

"tagName": "TagName1"

}

]

}

输出示例：

{

"deletedTags": 2,

"invalidTags": 2,

"reasons": [

{

"tagName": "TagName0",

"reason": "No such tag."

},

{

"tagName": "TagName1",

"reason": "No such tag."

}

]

}

v状态查询：

输入示例：

{

"startTime": "2023-07-05T09:00:00",

"sendMode": "D"

}

输出示例：

{

"syncedTags": 3,

"configedTags":10，

"bugTags": [

{

"tagName": "TagName0",

"cloudEnName": "TagName0"，

"lastSyncTime": "1689736706000"，

},

{

"tagName": "TagName1",

"cloudEnName": "TagName1"，

"lastSyncTime": "1689736706000"，

}

]

}

v 上云服务状态查询：
输出示例：

{

"result": 2,

"startTime":"2023-07-13T09:00:00",

"stoptime":"2023-07-13T09:00:00"，

"reason": "Disk full."

}


数字状态集管理

Navigation: »No topics above this level«

数字状态集管理

 Return to chapter overview

数字状态集管理：

u接口

u新增数字状态集(addDigitalSet)

u修改数字状态集(modifyDigitalSet)

u删除数字状态集(deleteDigitalSet)

u查询所有数字状态集(queryAllDigitalSets)

u根据数字量查状态名称（queryDigitalStateName）

u查询某个数字状态集的所有状态信息(queryDigitalAllStateInfos)

v 接口：

module IHDDigital

{

exception InvokeError

{

string reason;

}

sequence<byte> JsonSeq;

interface HDDigitalHandler

{

int addDigitalSet (JsonSeq request)throws InvokeError;

int modifyDigitalSet (JsonSeq request)throws InvokeError;

int deleteDigitalSet (JsonSeq request)throws InvokeError;

int queryAllDigitalSets (out JsonSeq response)throws InvokeError;

int queryDigitalStateName (JsonSeq request, out JsonSeq response)throws InvokeError;

int queryDigitalAllStateInfos (JsonSeq request, out JsonSeq response)throws InvokeError;

}

}

请求应答均为json字符串。成功返回0，失败返回错误码。

v新增数字状态集(addDigitalSet)

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | digitalSetName | string | 否 | 数字状态集名称

v修改数字状态集(modifyDigitalSet)

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | digitalSetName | string | 否 | 数字状态集名称
 | stateInfos | array | 否 | 状态信息数组
 | +value | int | 否 | 状态值
 | +name | string | 否 | 状态名

v删除数字状态集(deleteDigitalSet)

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | digitalSetName | string | 否 | 数字状态集名称

v查询所有数字状态集(queryAllDigitalSets)

参数列表 | 名称 | 类型 | 是否可空 | 备注
返回值列表 |
 | response | object | 否 |
 | digitalSets | array | 否 | 数字状态集数组
 | +digitalSetName | string | 是 | 数字状态集名称

v根据数字量查状态名称（queryDigitalStateName）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | digitalSetName | string | 否 | 数字状态集名称
 | value | int | 否 | 状态值
返回值列表 |
 | response | object | 否 |
 | name | string | 否 | 状态名

v查询某个数字状态集的所有状态信息(queryDigitalAllStateInfos )

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | digitalSetName | string | 否 | 数字状态集名称
返回值列表 |
 | response | object | 否 |
 | stateInfos | array | 否 | 状态信息数组
 | +value | int | 否 | 状态值
 | +name | string | 否 | 状态名


数据操作

Navigation: »No topics above this level«

数据操作

 Return to chapter overview

数据操作：

u接口

u新增快照(saveSnapShots)

u实时数据查询(querySnapShots)

u历史数据总数查询(queryRawRecordsNum)

u历史数据查询(queryRawRecords)

u前向或后向查询（queryRawRecordsByDirection）

u插值查询(queryInterpRecords)

v 接口：

module IHDData{

exception InvokeError{

string reason;

}

sequence<byte> JsonSeq;

sequence<string> StringSeq;

struct Record {

string value;

int recordTime;

int recordTimeMs;

int quality;

}

sequence<Record> RecordSeq;

struct Tag {

string tagName;

int tagId;

int recordNum;

int tagType;

int errorCode;

RecordSeq records;

}

sequence<Tag> TagSeq;

interface HDDataHandler{

int saveSnapShots (TagSeq request, out TagSeq response)throws InvokeError;

int querySnapShots (TagSeq request, out TagSeq response)throws InvokeError;

int queryRawRecordsNum (JsonSeq request, out JsonSeq response)throws InvokeError;

int queryRawRecords (JsonSeq request, out TagSeq response)throws InvokeError;

int queryRawRecordsByDirection (JsonSeq request, out TagSeq response)throws InvokeError;

int queryInterpRecords (int queryMode, TagSeq request, out TagSeq response)throws InvokeError;

};

};

v 增加快照(saveSnapShots)

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | tags | array<Tag> | 否 | tag点数组
 | +tagName | string | 否 | tag点名（只需填写tagName和records，其余字段可空）
 | +records | array<Record> | 否 | record数组
 | ++value | string | 否 | 快照值
 | ++recordTime | int | 否 | 记录时间，Unix时间（1970年1月1日至今的秒数）
 | ++recordTimeMs | int | 否 | 记录时间（毫秒）
 | ++quality | int | 否 | 数据质量，192为Good，65343为Bad
返回值列表 |
 | tags | array<Tag> | 否 | tag点数组
 | +tagNames | string | 是 | tag点名
 | +tagId | int | 是 | tag点ID
 | +tagType | int | 是 | tag点数据类型 0： HD3_TAG_TYPE_INT 1： HD3_TAG_TYPE_INT16, 2： HD3_TAG_TYPE_INT32, 3： HD3_TAG_TYPE_FLOAT32, 4： HD3_TAG_TYPE_FLOAT64, 5： HD3_TAG_TYPE_DIGITAL, 6： HD3_TAG_TYPE_STRING, 7： HD3_TAG_TYPE_BLOB
 | +errorCode | int | 是 | 错误编号

v实时数据查询(querySnapShots)

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | tags | array<Tag> | 否 | tag点数组
 | +tagName | string | 否 | tag点名（只需填写tagName和records，其余字段可空）
返回值列表 |
 | tags | array<Tag> | 否 | tag点数组
 | +tagNames | string | 是 | tag点名
 | +tagId | string | 是 | tag点ID
 | +tagType | int | 是 | tag点数据类型 0： HD3_TAG_TYPE_INT 1： HD3_TAG_TYPE_INT16, 2： HD3_TAG_TYPE_INT32, 3： HD3_TAG_TYPE_FLOAT32, 4： HD3_TAG_TYPE_FLOAT64, 5： HD3_TAG_TYPE_DIGITAL, 6： HD3_TAG_TYPE_STRING, 7： HD3_TAG_TYPE_BLOB
 | +errorCode | int | 是 | 错误编号
 | +records | array<Record> | 否 | record数组，大小为1
 | ++value | string | 否 | 快照值
 | ++recordTime | int | 否 | 快照时间，Unix时间（1970年1月1日至今的秒数）
 | ++recordTimeMs | int | 否 | 快照时间（毫秒）
 | ++quality | int | 否 | 数据质量，192为Good，65343为Bad

v历史数据总数查询(queryRawRecordsNum)

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 | Json字符串
 | tags | array | 否 | tag点数组
 | +startTime | string | 否 | 起始时间，格式为"YYYY-MM-ddThh:mm:ss.SSS"
 | +endTime | string | 否 | 结束时间，格式为"YYYY-MM-ddThh:mm:ss.SSS"
 | +tagName | string | 否 | tag点名
返回值列表 |
 | response | object | 否 | Json字符串
 | tags | array | 否 | tag点数组
 | +tagName | string | 是 | tag点名
 | +recordNum | int | 否 | 查到总数
 | +errorCode | int | 是 | 错误编号

v历史数据查询(queryRawRecords)

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 | Json字符串
 | tags | array | 否 | tag点数组
 | +expectedNum | int | 否 | 待查总数
 | +startTime | string | 否 | 起始时间，格式为"YYYY-MM-ddThh:mm:ss.SSS"
 | +endTime | string | 否 | 结束时间，格式为"YYYY-MM-ddThh:mm:ss.SSS"
 | +tagName | string | 否 | tag点名
返回值列表 |
 | tags | array<Tag> | 否 | tag点数组
 | +tagName | string | 是 | tag点名
 | +tagId | string | 是 | tag点ID
 | +tagType | int | 是 | tag点数据类型 0： HD3_TAG_TYPE_INT 1： HD3_TAG_TYPE_INT16, 2： HD3_TAG_TYPE_INT32, 3： HD3_TAG_TYPE_FLOAT32, 4： HD3_TAG_TYPE_FLOAT64, 5： HD3_TAG_TYPE_DIGITAL, 6： HD3_TAG_TYPE_STRING, 7： HD3_TAG_TYPE_BLOB
 | +recordNum | int | 否 | 查到总数
 | +errorCode | int | 是 | 错误编号
 | +records | array<Record> | 否 | record数组
 | ++value | string | 否 | 记录值
 | ++recordTime | int | 否 | 记录时间，Unix时间（1970年1月1日至今的秒数）
 | ++recordTimeMs | int | 否 | 记录时间（毫秒）
 | ++quality | int | 否 | 数据质量，192为Good，65343为Bad

v前向或后向查询（queryRawRecordsByDirection）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 | Json字符串
 | tags | array | 否 | tag点数组
 | +expectedNum | int | 否 | 待查总数
 | +startTime | string | 否 | 起始时间，格式为"YYYY-MM-ddThh:mm:ss.SSS"
 | +direction | int | 否 | 1表示向后查，0表示向前查
 | +tagName | string | 否 | tag点名
返回值列表 |
 | tags | array<Tag> | 否 | tag点数组
 | +tagName | string | 是 | tag点名
 | +tagId | string | 是 | tag点ID
 | +tagType | int | 是 | tag点数据类型 0： HD3_TAG_TYPE_INT 1： HD3_TAG_TYPE_INT16, 2： HD3_TAG_TYPE_INT32, 3： HD3_TAG_TYPE_FLOAT32, 4： HD3_TAG_TYPE_FLOAT64, 5： HD3_TAG_TYPE_DIGITAL, 6： HD3_TAG_TYPE_STRING, 7： HD3_TAG_TYPE_BLOB
 | +recordNum | int | 否 | 查到总数（不超过65535）
 | +errorCode | int | 是 | 错误编号
 | +records | array<Record> | 否 | record数组
 | ++value | string | 否 | 记录值
 | ++recordTime | int | 否 | 记录时间，Unix时间（1970年1月1日至今的秒数）
 | ++recordTimeMs | int | 否 | 记录时间（毫秒）
 | ++quality | int | 否 | 数据质量，192为Good，65343为Bad

v插值查询(queryInterpRecords)

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | queryMode | int | 否 | 插值模式: 0：线性插值 1：前向插值 2：最大值
 | tags | array<Tag> | 否 | tag点数组
 | +tagName | string | 是 | tag点名
 | +records | array<Record> | 否 | record数组
 | ++recordTime | int | 否 | 记录时间，Unix时间（1970年1月1日至今的秒数）
返回值列表 |
 | tags | array<Tag> | 否 | tag点数组
 | +tagName | string | 是 | tag点名
 | +tagId | string | 是 | tag点ID
 | +tagType | int | 是 | tag点数据类型 0： HD3_TAG_TYPE_INT 1： HD3_TAG_TYPE_INT16, 2： HD3_TAG_TYPE_INT32, 3： HD3_TAG_TYPE_FLOAT32, 4： HD3_TAG_TYPE_FLOAT64, 5： HD3_TAG_TYPE_DIGITAL, 6： HD3_TAG_TYPE_STRING, 7： HD3_TAG_TYPE_BLOB
 | +recordNum | int | 否 | 查到总数
 | +errorCode | int | 是 | 错误编号
 | +records | array<Record> | 否 | record数组
 | ++value | string | 否 | 记录值
 | ++recordTime | int | 否 | 记录时间，Unix时间（1970年1月1日至今的秒数）
 | ++recordTimeMs | int | 否 | 记录时间（毫秒）
 | ++quality | int | 否 | 数据质量，192为Good，65343为Bad


权限管理

Navigation: »No topics above this level«

权限管理

 Return to chapter overview

权限管理：

u接口

u查询接口

u管理接口

u绑定接口

u其他

v 接口：

module IHDSecurity

{

exception InvokeError

{

string reason;

}

sequence<byte> JsonSeq;

interface HDSecurityHandler

{

int queryAllGroups (out JsonSeq response) throws InvokeError;

int queryAllUsers (out JsonSeq response) throws InvokeError;

int queryMembersOfGroup (JsonSeq request, out JsonSeq response) throws InvokeError;

int queryGroupsOfUser (JsonSeq request, out JsonSeq response) throws InvokeError;

int queryAllResourceGroups (out JsonSeq response) throws InvokeError;

int queryResourceGroupsOfGroup (JsonSeq request, out JsonSeq response) throws InvokeError;

int queryGroupsOfResourceGroup (JsonSeq request, out JsonSeq response) throws InvokeError;

int queryResourceGroupsOfTag (JsonSeq request, out JsonSeq response) throws InvokeError;

int queryTagsOfResourceGroup (JsonSeq request, out JsonSeq response) throws InvokeError;

int queryTagsResourceGroupAccessOfUser (JsonSeq request, out JsonSeq response) throws InvokeError;

int queryAllTrusts (out JsonSeq response) throws InvokeError;

int querySecurity (JsonSeq request, out JsonSeq response) throws InvokeError;

int manageUser (JsonSeq request) throws InvokeError;

int manageGroup (JsonSeq request) throws InvokeError;

int manageResourceGroup (JsonSeq request) throws InvokeError;

int manageTrust (JsonSeq request) throws InvokeError;

int manageSecurity (JsonSeq request) throws InvokeError;

int bindUser2Group (JsonSeq request) throws InvokeError;

int bindResourceGroup2Group (JsonSeq request) throws InvokeError;

int bindTag2ResourceGroup (JsonSeq request, out JsonSeq response) throws InvokeError;

int checkAuth (JsonSeq request) throws InvokeError;

}

}

使用EiInfo类组织上云配置二进制数据，在调用接口前：

1)调用SerializeEIClassToJSonV2接口将EiInfo转换为json字符串，该json字符串二进制数据作为接口的传入参数。

2)调用EiInfo类提供的Serialize接口将EiInfo对象序列化，作为传入参数传入。

成功返回0，失败返回错误码或错误信息。

v 查询接口：

queryAllGroups （查询所有用户组）

返回值列表 | 名称 | 类型 | 是否可空 | 备注
 | response | object | 否 |
 | groups | array | 否 | 组数组
 | +groupName | string | 是 | 组名
 | +groupDescription | string | 是 | 组描述

queryAllUsers （查询所有用户）

返回值列表 | 名称 | 类型 | 是否可空 | 备注
 | response | object | 否 |
 | users | array | 否 | 用户数组
 | +userName | string | 是 | 用户名
 | +userDescription | string | 是 | 用户描述
 | +password | string | 是 | 用户密码

queryMembersOfGroup （查询组内用户）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | groupName | string | 否 | 组名
返回值列表 |
 | response | object | 否 |
 | users | array | 否 | 用户数组
 | +userName | string | 是 | 用户名
 | +userDescription | string | 是 | 用户描述
 | +password | string | 是 | 用户密码

queryGroupsOfUser （查询用户所属组）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | userName | string | 否 | 用户名
返回值列表 |
 | response | object | 否 |
 | groups | array | 否 | 组数组
 | +groupName | string | 是 | 组名
 | +groupDescription | string | 是 | 组描述

queryAllResourceGroups （查询所有资源组）

返回值列表 | 名称 | 类型 | 是否可空 | 备注
 | response | object | 否 |
 | resource_groups | array | 否 | 资源组数组
 | +name | string | 是 | 资源组名
 | +description | string | 是 | 组描述
 | +accessType | int | 是 |
 | +parentId | int | 是 |
 | +level | int | 是 |

queryResourceGroupsOfGroup （查询组所属资源组）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | groupName | string | 否 | 组名
返回值列表 |  | int | 是 |
 | response | object | 否 |
 | resource_groups | array | 否 | 资源组数组
 | +name | string | 是 | 资源组名
 | +description | string | 是 | 组描述
 | +accessType | int | 是 |
 | +parentId | int | 是 |
 | +level | int | 是 |

queryGroupsOfResourceGroup （查询资源组包含的组）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | resourceGroupName | string | 否 | 资源组名
返回值列表 |  | int | 是 |
 | response | object | 否 |
 | groups | array | 否 | 组数组
 | +groupName | string | 是 | 组名
 | +groupDescription | string | 是 | 组描述

queryResourceGroupsOfTag （查询tag点所属资源组）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | tagId | int | 否 | tag点id
返回值列表 |
 | response | object | 否 |
 | resource_groups | array | 否 | 资源组数组
 | +name | string | 是 | 资源组名
 | +description | string | 是 | 组描述
 | +accessType | int | 是 |
 | +parentId | int | 是 |
 | +level | int | 是 |

queryTagsOfResourceGroup （查询资源组包含的tag点）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | resourceGroupName | string | 否 | 资源组名
返回值列表 |
 | response | object | 否 |
 | tags | array | 否 | tag点id数组
 | +tagId | int | 是 | tag点id
 | +tagName | string | 是 | tag点名

queryTagsResourceGroupAccessOfUser （查询用户可操作的tag点的权限）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | userName | string | 否 | 用户名
返回值列表 |
 | response | object | 否 |
 | tagNum | int | 否 | tag点总数
 | tags | array | 是 | tag点id数组
 | +tagId | int | 是 | tag点id
 | accessResults | array | 是 | 资源组权限数组
 | +accessResult |  | 是 | 资源组权限

queryAllTrusts （查询所有信任）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | response | object | 否 |
 | trusts | array | 否 | 信任数组
 | +trustName | string | 是 | 信任名
 | +startIp | string | 是 | 起始IP
 | +endIp | string | 是 | 结束IP
 | +userName | string | 是 | 信任用户名

querySecurity （查询安全数据库项）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | type | int | 否 | 权限项类型，0为所有类型，1为tag点，2为组，3为分发
返回值列表 |
 | response | object | 否 |
 | securities | array | 否 | 安全数组
 | type | int | 否 | 权限项类型，1为tag点，2为组，3为分发
 | ownGroupName | string | 否 | 拥有组名
 | operateGroupName | string | 否 | 操作组名
 | security | int | 否 | 权限参数

v管理接口

manageUser （管理用户）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | action | int | 否 | 0表示新增，1表示删除（仅需name参数），2表示修改
 | userName | string | 否 | 用户名
 | userDescription | string | 是 | 用户描述
 | password | string | 是 | 用户密码

manageGroup （管理组）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | action | int | 否 | 0表示新增，1表示删除（仅需name参数），2表示修改
 | groupName | string | 否 | 组名
 | groupDescription | string | 是 | 组描述

manageResourceGroup （管理资源组）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | action | int | 否 | 0表示新增，1表示删除（仅需name参数），2表示修改
 | resourceGroupName | string | 否 | 资源组名
 | resourceGroupDescription | string | 是 | 资源组描述
 | accessType | int | 否 | 1 记录读权限 2 记录写权限 3 记录读/写权限 4 记录无权限 5 点配置读权限 6 点配置写权限 7 点配置读/写权限 8 点配置无权限
 | parentId | int | 是 | 资源树预留字段
 | level | int | 是 | 资源树预留字段

manageTrust （管理信任）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | action | int | 否 | 0表示新增，1表示删除（仅需name参数），2表示修改
 | trustName | string | 否 | 信任名
 | startIp | string | 是 | 起始IP
 | endIp | string | 是 | 结束IP
 | userName | string | 是 | 信任用户名

manageSecurity （管理安全数据库项）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | type | int | 否 | 权限项类型，1为tag点，2为组，3为分发
 | ownGroupName | string | 否 | 拥有组名
 | operateGroupName | string | 否 | 操作组名
 | security | int | 否 | 权限参数

v绑定接口

bindUser2Group （绑定/解绑用户到组）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | isBind | int | 否 | 1表示绑定， 0表示解绑
 | userName | string | 否 | 用户名
 | groupName | string | 是 | 组名

bindResourceGroup2Group（绑定/解绑资源组到组）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | isBind | int | 否 | 1表示绑定， 0表示解绑
 | resourceGroupName | string | 否 | 资源组名
 | groupName | string | 否 | 组名

bindTag2ResourceGroup（绑定/解绑tag点到资源组）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | isBind | int | 否 | 1表示绑定， 0表示解绑
 | tags | array | 是 | tag点数组
 | +tagName | string | 是 | tag点名
 | +resourceGroupName | string | 是 | 资源组名
返回值列表 |
 | response | object | 否 |
 | tags | array | 否 | tag点数组
 | +tagName | string | 是 | tag点名
 | +errorCode | int | 是 | 错误编号

v其他

checkAuth（校验用户名密码）

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | userName | string | 否 | 用户名
 | password | string | 否 | 密码（明文经过base64后，将首字符插入第三位，如base64字符串为YWRtaW4=，传入参数为YWYRtaW4=)


统计计算接口

Navigation: »No topics above this level«

统计计算接口

 Return to chapter overview

统计计算接口：*统计计算(calculate)接口为全功能接口，可定制化统计计算。

u接口

u统计计算扩展接口(calculateEx)

u统计计算接口(calculate)

v 接口：

module IHDStats{

exception InvokeError{

string reason;

}

sequence<byte> JsonSeq;

interface HDStatsHandler{

int calculateEx (JsonSeq request, out JsonSeq response) throws InvokeError;

int calculate (JsonSeq request, out JsonSeq response) throws InvokeError;

};

};

v 统计计算扩展接口(calculateEx)：

参数列表 | 名称 | 类型 | 是否必填 | 备注
 | tags | array | 是 | tag点数组
 | +tagName | string | 是 | tag点名
 | +statsType | int | 是 | 统计类型 0：最大值 1：最小值 2：求和 3：最新值 4：可信度 5：算术平均值 6：时间加权平均值 7：积分 8：值变化 9：区间变化,从<=到>= 10：区间变化，从>=到<= 11：差值统计 12：值在区间 13：值不在区间 14：极差 15：标准差 16：大于某个值的时间 17：大于等于某个值的时间 18：等于某个值的时间 19：不等于某个值的时间 20：小于某个值的时间 21：小于等于某个值的时间 22：在某个值区间的时间 23：不在某个值区间的时间
 | +timeRegions | array | 是 | 统计区间数组
 | ++startTime | string | 是 | 起始时间，格式为"YYYY-MM-ddThh:mm:ss.SSS"
 | ++endTime | string | 是 | 结束时间，格式为"YYYY-MM-ddThh:mm:ss.SSS"
 | +percentGood | float | 否 | 信任度(Good的数据个数百分比大于或等于该比例时认为计算出的结果是可信的)，0-100
 | +sampleType | int | 否 | 统计类型 0：原始点 1：线性插值 2：前向插值
 | +filterExpr | string | 否 | 数据过滤表达式
 | +filterFailMode | int | 否 | 过滤失败时对采样数据的处理，0为过滤采样数据，1为不过滤采样数据
 | +extParam1 | float | 否 | 计数和计时的参数, 值变化的参数，区间变化的第一个参数，在区间不在区间的第一个参数
 | +extParam2 | float | 否 | 计数和计时的参数，区间变化的第二个参数，在区间不在区间的第二个参数
 | +offset | int | 否 | 采样模式为插值时，插值点为startTime+nOffset,startTime+nOffset+nPeriod, 单位为秒
 | +period | int | 否 | 采样模式为插值时，插值点的间隔为nPeriod, 单位为秒
 | +useBadValue | int | 否 | bad值是否参与统计，1表示bad值参与统计，0表示不参与
返回值列表 |
 | tags | array | 否 | tag点数组
 | +tagName | string | 是 | tag点名
 | +tagId | int | 是 | tag点ID
 | +value | double | 是 | 统计值
 | +errorCode | int | 是 | 错误编号

v统计计算接口(calculate)

参数列表 | 名称 | 类型 | 是否必填 | 备注
 | tags | array | 是 | tag点数组
 | +tagName | string | 是 | tag点名
 | +statsType | int | 是 | 统计类型 0：最大值 1：最小值 2：求和 3：最新值 4：可信度 5：算术平均值 6：时间加权平均值 7：积分 8：值变化 9：区间变化,从<=到>= 10：区间变化，从>=到<= 11：差值统计 12：值在区间 13：值不在区间 14：极差 15：标准差 16：大于某个值的时间 17：大于等于某个值的时间 18：等于某个值的时间 19：不等于某个值的时间 20：小于某个值的时间 21：小于等于某个值的时间 22：在某个值区间的时间 23：不在某个值区间的时间
 | +timeRegions | array | 是 | 统计区间数组
 | ++startTime |  | 是 | 起始时间，格式为"YYYY-MM-ddThh:mm:ss.SSS"
 | ++endTime |  | 是 | 结束时间，格式为"YYYY-MM-ddThh:mm:ss.SSS"
返回值列表 |
 | tags | array | 是 | tag点数组
 | +tagName | string | 是 | tag点名
 | +tagId | int | 是 | tag点ID
 | +value | double | 是 | 统计值
 | +errorCode | int | 是 | 错误编号


运维信息查询

Navigation: »No topics above this level«

运维信息查询

 Return to chapter overview

运维信息查询：

u接口

u查询数据节点(queryAllDataNodes)

u查询客户端信息(queryClientInfo)

u查询系统信息(querySystemInfo)

u查询系统参数(querySystemParams)

v 接口：

module IHDMonitor{

exception InvokeError{

string reason;

}

sequence<byte> JsonSeq;

interface HDMonitorHandler{

int queryAllDataNodes (out JsonSeq response)throws InvokeError;

int queryClientInfo (JsonSeq request, out JsonSeq response)throws InvokeError;

int querySystemInfo (JsonSeq request, out JsonSeq response)throws InvokeError;

int querySystemParams (JsonSeq request, out JsonSeq response)throws InvokeError;

};

};

请求应答均为json字符串。成功返回0，失败返回错误码

v 查询数据节点(queryAllDataNodes)

参数列表 | 名称 | 类型 | 是否可空 | 备注
返回值列表 |
 | response | object | 否 |
 | dataNodes | array | 否 | 数据节点数组
 | +nodeName | string | 否 | 节点名

v查询客户端信息(queryClientInfo)

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | nodeName | string | 否 | 数据节点名
返回值列表 |
 | response | object | 否 |
 | clients | array | 否 | client数组
 | +clientIp | string | 是 | 客户端IP
 | +mac | string | 是 | 客户端MAC
 | +totalSockets | int | 是 | socket连接数
 | sockets | array | 是 | socket数组
 | +mac | string | 是 | 客户端MAC
 | +socket | string | 是 | socket值
 | +startTime | string | 是 | 连接起始时间，格式为"YYYY-MM-ddThh:mm:ss"
 | +packetCount | string | 是 | 发送数据包数
 | +latestTime | string | 是 | 最新发包时间，格式为"YYYY-MM-ddThh:mm:ss"
 | +userName | string | 是 | 用户名

v查询系统信息(querySystemInfo)

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | nodeName | string | 否 | 数据节点名
返回值列表 |
 | response | object | 否 |
 | dataNode | object | 否 | 数据节点信息
 | +cpuUsage | int | 否 | 系统CPU利用率（%）
 | +memoryUsage | int | 否 | 系统内存利用率（%）
 | +kernelCpuUsage | int | 否 | 内核服务进程CPU利用率（%）
 | +kerneMemoryUsage | int | 否 | 内核服务进程内存使用量（KB）
 | +netManagerCpuUsage | int | 否 | 网络服务进程CPU利用率（%）
 | +netManagerMemoryUsage | int | 否 | 网络服务进程内存使用量（KB）
 | +netIn | float | 否 | 系统网络流入（KB/s）
 | +netOut | float | 否 | 系统网络流出（KB/s）
 | +netManagerIn | float | 否 | 网络服务进程网络流入（KB/s）
 | +netManagerOut | float | 否 | 网络服务进程网络流出（KB/s）
 | +archiveUsed | float | 否 | 归档分区空间使用量（GB）
 | +archiveLeft | float | 否 | 归档分区空间剩余量（GB）
 | +dataNodeTime | string | 否 | 数据节点机器时间
 | +systemInfoUpdateTime | string | 否 | 系统信息更新时间
 | +enableRedundancy | int | 否 | 是否启用冗余（0表示单机，1表示冗余）
 | +ryTagCount | int | 否 | 节点允许最大点数
 | +primaryIp | string | 否 | 主机IP
 | +primaryStatus | int | 否 | 主机状态（0表示非活动，1表示活动）
 | +backupIp | string | 是 | 备机IP
 | +backupStatus | int | 是 | 备机状态（0表示非活动，1表示活动）
 | configCenter | object | 否 | 配置中心信息
 | +errCode | int | 否 | 配置中心信息查询错误码，0为成功，非0为失败
 | +primaryIp | string | 否 | 主机IP
 | +primaryStatus | int | 否 | 主机状态（0表示非活动，1表示活动）
 | +backupIp | string | 是 | 备机IP
 | +backupStatus | int | 是 | 备机状态（0表示非活动，1表示活动）
 | license | object | 否 | 许可证信息
 | +licenseType | int | 否 | 许可证状态 0：未知 1：有效 2：无效或过期 3：试用许可证（2小时） 4：无限期
 | +validTime | string | 否 | 许可证有效期，格式为"YYYY-MM-dd"
 | +version | string | 否 | 版本信息
 | +enableSPC | int | 否 | 支持SPC（0：不支持，1：支持）
 | +enableZT | int | 否 | 支持组态（0：不支持，1：支持）
 | +connectionCapacity | int | 否 | 最大连接数
 | +clientsConnected | int | 否 | 当前连接数
 | +tagCapacity | int | 否 | 最大tag点数
 | +tagUsed | int | 否 | 当前tag点数

v查询系统参数(querySystemParams)

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | nodeName | string | 否 | 数据节点名
返回值列表 |
 | response | object | 否 |
 | ihdPort | int | 否 | 网络服务端口
 | seqCacheFileSize | int | 否 | 缓存序列文件大小（MB）
 | archivedFileSize | int | 否 | 单个归档文件大小（MB）
 | archiveFileNum | int | 否 | 归档文件个数
 | flushFrequency | int | 否 | 序列缓存刷新频率（s）
 | needCheck | int | 否 | 自动断开无数据交互的连接（0表示否，1表示是）
 | interDataTimeout | int | 否 | 超时时间（秒）
 | needCollect | int | 否 | 采集系统信息（0表示否，1表示是）
 | updateInterval | int | 否 | 采集间隔（秒）
 | needMaxTime | int | 否 | 丢弃超过服务器时间戳的数据（0表示否，1表示是）
 | deltaTime | int | 否 | 时间偏差（秒）


采集器管理

Navigation: »No topics above this level«

采集器管理

 Return to chapter overview

采集器管理：

u接口

u查询所有采集器(queryAllCollectors)

u查询采集器下设备(queryDevicesOfCollector)

u查询设备下扫描组(queryScanGroupsOfDevice)

v 接口：

module IHDCollector

{

exception InvokeError

{

string reason;

}

sequence<byte> JsonSeq;

interface HDCollectorHandler

{

int queryAllCollectors (out JsonSeq response)throws InvokeError;

int queryDevicesOfCollector (JsonSeq request, out JsonSeq response)throws InvokeError;

int queryScanGroupsOfDevice (JsonSeq request, out JsonSeq response)throws InvokeError;

int queryOPCItems (JsonSeq request, out JsonSeq response)throws InvokeError;

}

}

请求应答均为json字符串。成功返回0，失败返回错误码

v 查询所有采集器(queryAllCollectors)：

参数列表 | 名称 | 类型 | 是否可空 | 备注
返回值列表 |
 | response | object | 否 |
 | collectors | array | 否 | 采集器数组
 | +collectorName | string | 否 | 采集器名
 | +collectorId | int | 否 | 采集器ID
 | +type | int | 否 | 采集器类型 0：OPC 1：Modbus

v查询采集器下设备(queryDevicesOfCollector)：

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | collectorId | int | 否 | 采集器ID
返回值列表 |
 | response | object | 否 |
 | devices | array | 否 | 设备数组
 | +deviceName | string | 否 | 设备名
 | +deviceId | int | 否 | 设备ID

v查询设备下扫描组(queryScanGroupsOfDevice)：

参数列表 | 名称 | 类型 | 是否可空 | 备注
 | request | object | 否 |
 | deviceId | int | 否 | 设备ID
返回值列表 |
 | response | object | 否 |
 | scanGroups | array | 否 | 扫描组数组
 | +scanGroupName | string | 否 | 扫描组名
 | +scanGroupId | int | 否 | 扫描组ID


用户与组

Navigation: »No topics above this level«

用户与组

 Return to chapter overview

用户与组

Glossary Item Box

《用户与组》中的主要接口包括：

?sc_login

?sc_add_user

?sc_modify_password

?sc_reset_password

?sc_modify_user_desc

?sc_delete_user

?sc_add_group

?sc_add_user_to_group

?sc_modify_group_desc

?sc_delete_group

?sc_query_all_users

?sc_query_members_of_group

?sc_query_all_groups

?sc_query_current_user_name

?sc_query_groups_of_user

?sc_delete_user_from_group

用户与组权限管理包含iHyperDB数据库系统权限管理中用户与组的管理。

数据结构

/** iHyperDB 权限管理: 用户 */

typedef struct _HDSecUser

{

char szUserName[HD_LEN_SEC_USER_NAME];

char szPasswd[HD_LEN_SEC_PASSWORD];

char szUserDesc[HD_LEN_SEC_USER_DESC];

}HDSecUser;

/** iHyperDB 权限管理: 组 */

typedef struct _HDSecGroup

{

char szGroupName[HD_LEN_SEC_GROUP_NAME];

char szGroupDesc[HD_LEN_SEC_GROUP_DESC];

}HDSecGroup;

注意：

1.创建用户与组的所有信息均可以自行设定，但是最大长度由相应的限制，具体HD_LEN_SEC_USER_NAME、HD_LEN_SEC_PASSWORD、HD_LEN_SEC_USER_DESC、HD_LEN_SEC_GROUP_NAME、HD_LEN_SEC_GROUP_DESC指定。

2.密码字段由于安全考虑最短有效长度为5位字符，且限定为字母、数字、以及0~9按键对应的特殊字符(英文半角模式)。

3.除描述字段外，其余字段均不可以为空。

4.一个用户可以包含在一个或多个组中，默认的超级用户“admin”包含在“admin”组中。


ut_free_iterator

Navigation: »No topics above this level«

ut_free_iterator

 Return to chapter overview

ut_free_iterator

Glossary Item Box

函数

释放迭代器

void ut_free_iterator(

HDHANDLE hIter

);

参数

HDHANDLE

[in] 迭代器句柄。

返回值

无

说明

调用某些接口获得迭代器，再调用ut_get_item_setp，最后需要调用ut_free_iterator来释放迭代器。

相关接口 | pItem指向的类型
am_query_group_child_groups | 组ID(uint32)
am_query_group_child_tags | 报警点ID(uint32)
am_query_tags_cond | 报警点属性(AlarmTagProp)
pt_query_digitalset_names | 数字量状态集名称(char[HD_LEN_DIGITAL_SET_NAME])
pt_query_digital_state_names | 数字量状态集的状态名称(char[HD_LEN_DIGITAL_SET_STATE_NAME])
pt_query_tags_cond | 普通点属性(TagProp)

举例

ut_free_iterator

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tagSave;

TagProp tagQuery;

HDRecord snapshotsSaved;

QueryTagPropItem queryTagPropItem;

HDHANDLE hIter = NULL;

int32 i = 0;

//set mode, enable buffer. hdbuffer.exe must be running in this machine

nRet = ut_set_mode(ENABLE_BUFFER);

if (nRet != RD_SUCCESS)

{

 printf("set mode failed, error code[%d]!\n", nRet);

 return -1;

}

printf("set mode successful!\n");

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("connect to server successful!\n");

//set time out

nTimeOut = 5;

nRet = ut_set_timeout(hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("set timeout failed, error code[%d]!\n", nRet);

 return -1;

}

printf("set timeout successful!\n");

//add tag

strcpy(tagSave.szTagName, "szNormalTag");

tagSave.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

//query tags by condition

queryTagPropItem.nPropItemID = TAG_COL_TAG_NAME;

queryTagPropItem.nRelation = RELATION_EQUAL;

strcpy(queryTagPropItem.szValue, tagSave.szTagName);

nRet = pt_query_tags_cond(hServer, &queryTagPropItem, 1, TAG_PROP_TAG_NAME | TAG_PROP_TAGID, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query tags by condition failed!\n");

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &tagQuery);

 if (RD_SUCCESS == nRet)

 {

  printf("query tag successful, tag name is %s, tag id is %d!\n", tagQuery.szTagName, tagQuery.nTagID);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tag complete!");

  break;

 }

 else

 {

  printf("query tag failed, error code [%d]!", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//save one snapshot

snapshotsSaved.nSec = 3600;

snapshotsSaved.nMsec = 0;

snapshotsSaved.nQuality = 192;

snapshotsSaved.value.nInt32 = 111;

nRet = sn_save_snapshot(hServer, tagQuery.nTagID, &snapshotsSaved);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, tag id [%d], error code [%d]!\n", tagQuery.nTagID, nRet);

}

printf("save snapshot successful, tag id[%d]!\n", tagQuery.nTagID);

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

am_query_group_child_groups

am_query_group_child_tags

am_query_tags_cond

pt_query_digitalset_names

pt_query_digital_state_names

pt_query_tags_cond

ut_get_item_step

ut_free_iterator


ut_get_item_step

Navigation: »No topics above this level«

ut_get_item_step

 Return to chapter overview

ut_get_item_step

Glossary Item Box

函数

获取迭代器指向的内容并后移

int32 ut_get_item_step(

HDHANDLE hIter,

void* pItem

);

参数

HDHANDLE

[in] 迭代器句柄。

pItem

[in] 数据访问超时时间，单位为秒。

返回值

查询成功，返回RD_SUCCESS，迭代器指向的内容通过参数pItem传出。EC_HD_API_QUERY_END,表明查询结束，失败返回其它错误码，见error_code.h

说明

该接口需要配合其它查询接口一起使用，某些查询的接口如果查询成功会返回一个迭代器，不断的调用ut_get_item_step可以将要查询的内容一个一个全部取出来直到返回EC_HD_API_QUERY_END或者其它错误码。

参数pItem，根据调用的查询接口的不同，pItem指向不同的类型。例如调用am_query_group_child_groups得到一个迭代器句柄，再调用ut_get_item_step查询子组ID时，pItem为一个指向uint32类型的指针。调用am_query_tags_cond得到一个迭代器句柄，再调用ut_get_item_step查询报警点属性时，pItem为一个指向AlarmTagProp结构的指针。

使用完成后需要调用ut_free_iterator来释放迭代器。

相关接口 | pItem指向的类型
am_query_group_child_groups | 组ID(uint32)
am_query_group_child_tags | 报警点ID(uint32)
am_query_tags_cond | 报警点属性(AlarmTagProp)
pt_query_digitalset_names | 数字量状态集名称(char[HD_LEN_DIGITAL_SET_NAME])
pt_query_digital_state_names | 数字量状态集的状态名称(char[HD_LEN_DIGITAL_SET_STATE_NAME])
pt_query_tags_cond | 普通点属性(TagProp)

举例

ut_get_item_step

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tagSave;

TagProp tagQuery;

HDRecord snapshotsSaved;

QueryTagPropItem queryTagPropItem;

HDHANDLE hIter = NULL;

int32 i = 0;

//set mode, enable buffer. hdbuffer.exe must be running in this machine

nRet = ut_set_mode(ENABLE_BUFFER);

if (nRet != RD_SUCCESS)

{

 printf("set mode failed, error code[%d]!\n", nRet);

 return -1;

}

printf("set mode successful!\n");

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("connect to server successful!\n");

//set time out

nTimeOut = 5;

nRet = ut_set_timeout(hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("set timeout failed, error code[%d]!\n", nRet);

 return -1;

}

printf("set timeout successful!\n");

//add tag

strcpy(tagSave.szTagName, "szNormalTag");

tagSave.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

//query tags by condition

queryTagPropItem.nPropItemID = TAG_COL_TAG_NAME;

queryTagPropItem.nRelation = RELATION_EQUAL;

strcpy(queryTagPropItem.szValue, tagSave.szTagName);

nRet = pt_query_tags_cond(hServer, &queryTagPropItem, 1, TAG_PROP_TAG_NAME | TAG_PROP_TAGID, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query tags by condition failed!\n");

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &tagQuery);

 if (RD_SUCCESS == nRet)

 {

  printf("query tag successful, tag name is %s, tag id is %d!\n", tagQuery.szTagName, tagQuery.nTagID);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tag complete!");

  break;

 }

 else

 {

  printf("query tag failed, error code [%d]!", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//save one snapshot

snapshotsSaved.nSec = 3600;

snapshotsSaved.nMsec = 0;

snapshotsSaved.nQuality = 192;

snapshotsSaved.value.nInt32 = 111;

nRet = sn_save_snapshot(hServer, tagQuery.nTagID, &snapshotsSaved);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, tag id [%d], error code [%d]!\n", tagQuery.nTagID, nRet);

}

printf("save snapshot successful, tag id[%d]!\n", tagQuery.nTagID);

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

am_query_group_child_groups

am_query_group_child_tags

am_query_tags_cond

pt_query_digitalset_names

pt_query_digital_state_names

pt_query_tags_cond

ut_get_item_step

ut_free_iterator


管理功能接口

Navigation: »No topics above this level«

管理功能接口

 Return to chapter overview

管理功能接口

Glossary Item Box

《管理功能接口》主要内容包括

?ut_set_timeout

?ut_get_item_step

?ut_free_iterator

?ut_set_mode

©2015. All Rights Reserved.


ut_set_mode

Navigation: »No topics above this level«

ut_set_mode

Return to chapter overview

ut_set_mode

Glossary Item Box

函数

ut_set_mode设置API模式

void ut_set_mode(

int32 nMode

);

参数

nMode

[in] API模式，可以设置是否启用Buffer。

nMode的值 | 含义
ENABLE_BUFFER | 启用buffer，仅对sn_save_snapshot和sn_save_snapshots起作用

返回值

无

说明

该接口在调用nt_connect之前调用。

举例

ut_set_mode

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tagSave;

TagProp tagQuery;

HDRecord snapshotsSaved;

QueryTagPropItem queryTagPropItem;

HDHANDLE hIter = NULL;

int32 i = 0;

//set mode, enable buffer. hdbuffer.exe must be running in this machine

nRet = ut_set_mode(ENABLE_BUFFER);

if (nRet != RD_SUCCESS)

{

 printf("set mode failed, error code[%d]!\n", nRet);

return -1;

}

printf("set mode successful!\n");

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

return -1;

}

printf("connect to server successful!\n");

//set time out

nTimeOut = 5;

nRet = ut_set_timeout(hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("set timeout failed, error code[%d]!\n", nRet);

return -1;

}

printf("set timeout successful!\n");

//add tag

strcpy(tagSave.szTagName, "szNormalTag");

tagSave.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

//query tags by condition

queryTagPropItem.nPropItemID = TAG_COL_TAG_NAME;

queryTagPropItem.nRelation = RELATION_EQUAL;

strcpy(queryTagPropItem.szValue, tagSave.szTagName);

nRet = pt_query_tags_cond(hServer, &queryTagPropItem, 1, TAG_PROP_TAG_NAME | TAG_PROP_TAGID, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query tags by condition failed!\n");

 nt_disconnect(hServer);

return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &tagQuery);

if (RD_SUCCESS == nRet)

 {

  printf("query tag successful, tag name is %s, tag id is %d!\n", tagQuery.szTagName, tagQuery.nTagID);

 }

else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tag complete!");

  break;

 }

else

 {

  printf("query tag failed, error code [%d]!", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//save one snapshot

snapshotsSaved.nSec = 3600;

snapshotsSaved.nMsec = 0;

snapshotsSaved.nQuality = 192;

snapshotsSaved.value.nInt32 = 111;

nRet = sn_save_snapshot(hServer, tagQuery.nTagID, &snapshotsSaved);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, tag id [%d], error code [%d]!\n", tagQuery.nTagID, nRet);

}

printf("save snapshot successful, tag id[%d]!\n", tagQuery.nTagID);

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

ut_connect

ut_disconnect

ut_test_connection


ut_set_timeout

Navigation: »No topics above this level«

ut_set_timeout

 Return to chapter overview

ut_set_timeout

Glossary Item Box

函数

设置数据访问超时时间

int32 ut_set_timeout(

HDHANDLE hServer,

int32 nTimeOut

);

参数

hServer

[in] 服务器句柄。

nTimeOut

[in] 数据访问超时时间，单位为秒。

返回值

设置成功，返回RD_SUCCESS。失败返回其它错误码，见error_code.h

说明

凡是与iHyperDB服务器交互的接口都有一个超时时间，已便网络或者服务器出现异常时能等待指定时间后退出。iHyperDB超时时间分为两种，一种是连接超时，一种是数据访问超时。

连接超时是指连接iHyperDB服务器时的超时时间，与网络相关的接口的超时时间是连接超时，它们只与服务器的网络模块相关，与服务器的其它模块没有数据交互，接口nt_connect和nt_test_connection 的超时时间是连接超时，该超时时间由用户自己指定。单位为秒。

与iHyperDB服务器端的除网络模块外的其它模块有数据交互的接口的超时时间都是数据访问超时，如pt_add_tag等接口，调用ut_set_timeout设置超时时间(如3秒)后，再调用pt_add_tag向服务器添加一个tag，如果网络异常或者服务器忙碌无法提供服务时，在该超时时间结束(3秒)后，接口返回一个超时的错误码。

与服务器有数据交互的接口都有受到该超时时间的影响。

如果不调用该接口，会有一个默认的数据超时时间，超时时间为10秒。

举例

ut_set_timeout

!MISSING PHRASE 'COPYCODE'!

#include "hdAPI.h"

#include "error_code.h"

#include "data_types.h"

#include "ihyperdb.h"

#include <stdio.h>

#include <string.h>

int32 main()

{

int32 nRet = RD_SUCCESS;

const char* szIP = "127.0.0.1";

uint16 nPort = 5678;

HDHANDLE hServer = NULL;

int32 nTimeOut = 3;

TagProp tagSave;

TagProp tagQuery;

HDRecord snapshotsSaved;

QueryTagPropItem queryTagPropItem;

HDHANDLE hIter = NULL;

int32 i = 0;

//set mode, enable buffer. hdbuffer.exe must be running in this machine

nRet = ut_set_mode(ENABLE_BUFFER);

if (nRet != RD_SUCCESS)

{

 printf("set mode failed, error code[%d]!\n", nRet);

 return -1;

}

printf("set mode successful!\n");

//connect

nRet = nt_connect(szIP, nPort, &hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("connect to server failed, error code[%d]!\n", nRet);

 return -1;

}

printf("connect to server successful!\n");

//set time out

nTimeOut = 5;

nRet = ut_set_timeout(hServer, nTimeOut);

if (nRet != RD_SUCCESS)

{

 printf("set timeout failed, error code[%d]!\n", nRet);

 return -1;

}

printf("set timeout successful!\n");

//add tag

strcpy(tagSave.szTagName, "szNormalTag");

tagSave.nTagType = TAG_TYPE_INT32;

nRet = pt_add_tag(hServer, &tagSave, TAG_PROP_TAG_NAME | TAG_PROP_TAG_TYPE);

if (nRet != RD_SUCCESS)

{

 printf("add tags[%s] failed, error code [%d]!\n", tagSave.szTagName, nRet);

 nt_disconnect(hServer);

 return -1;

}

printf("add tags[%s] successful!\n", tagSave.szTagName);

//query tags by condition

queryTagPropItem.nPropItemID = TAG_COL_TAG_NAME;

queryTagPropItem.nRelation = RELATION_EQUAL;

strcpy(queryTagPropItem.szValue, tagSave.szTagName);

nRet = pt_query_tags_cond(hServer, &queryTagPropItem, 1, TAG_PROP_TAG_NAME | TAG_PROP_TAGID, &hIter);

if (nRet != RD_SUCCESS)

{

 printf("query tags by condition failed!\n");

 nt_disconnect(hServer);

 return -1;

}

while (true)

{

 nRet = ut_get_item_step(hIter, &tagQuery);

 if (RD_SUCCESS == nRet)

 {

  printf("query tag successful, tag name is %s, tag id is %d!\n", tagQuery.szTagName, tagQuery.nTagID);

 }

 else if (EC_HD_API_QUERY_END == nRet)

 {

  printf("query tag complete!");

  break;

 }

 else

 {

  printf("query tag failed, error code [%d]!", nRet);

  break;

 }

}

ut_free_iterator(hIter);

//save one snapshot

snapshotsSaved.nSec = 3600;

snapshotsSaved.nMsec = 0;

snapshotsSaved.nQuality = 192;

snapshotsSaved.value.nInt32 = 111;

nRet = sn_save_snapshot(hServer, tagQuery.nTagID, &snapshotsSaved);

if (nRet != RD_SUCCESS)

{

 printf("save snapshot failed, tag id [%d], error code [%d]!\n", tagQuery.nTagID, nRet);

}

printf("save snapshot successful, tag id[%d]!\n", tagQuery.nTagID);

//disconnect

nt_disconnect(hServer);

return 0;

}

参见：

nt_connect

nt_test_connection


webblank.html

Navigation: »No topics above this level«

webblank.html

 Return to chapter overview


webfavorites.html

Navigation: »No topics above this level«

webfavorites.html

 Return to chapter overview


iHyperDB????????????

Navigation: »No topics above this level«

iHyperDB????????????

 Return to chapter overview

This page uses frames, but your browser doesn't support them.


webindex.html

Navigation: »No topics above this level«

webindex.html

 Return to chapter overview

index


webnav.html

Navigation: »No topics above this level«

webnav.html

 Return to chapter overview


websearch.html

Navigation: »No topics above this level«

websearch.html

 Return to chapter overview

搜索结果 结果发现。

查找：

[TEditFormControlObj]

（字可以组合使用OR和AND）

[TCheckBoxFormControlObj]标明搜索字词

搜索...


webtoc.html

Navigation: »No topics above this level«

webtoc.html

 Return to chapter overview

index


webtoolbar.html

Navigation: »No topics above this level«

webtoolbar.html

 Return to chapter overview


组态画面管理

Navigation: »No topics above this level«

组态画面管理

 Return to chapter overview

组态管理->“组态画面”Tap页，进行组态画面管理。组态画面是指现场中使用的构成现场监控画面的图形。本节内容如下：

导入画面

导入画面

单击界面上的“导入画面”按钮，弹出打开文件对话框。如下图所示：

选中需要导入的组态画面（可多选），点击打开按钮，系统管理平台将选中的画面导入至服务端，组态画面主界面上显示这些导入的画面。如下图所示：

点击列名，可对所有文件、文件夹按字母排序。只允许导入扩展名为“bsp”的文件；

签出

签出

勾选一个或多个未签出的组态画面，单击“签出”按钮，签出这些组态画面。被签出的组态画面信息中显示状态、操作者、操作者信息。

签入

签入

勾选一个或多个已签出的组态画面，单击“签入”按钮，将这些组态画面文件变更保存至服务端。签入后，表格中对应的状态、操作者、操作者信息为空。

取消签出

勾选一个或多个已签出的组态画面，单击“取消签出”按钮，取消客户端对这些组态画面的变更。取消签出后，表格中对应的状态、操作者、操作者信息为空。

修改画面描述

§修改画面描述

表格中选中已签出的画面，右键选择“修改”，弹出修改描述界面。输入新的描述，单击确定完成修改。

新建画面

选择“新建画面”，弹出新增的画面

编辑画面

编辑画面

选中已签出的组态画面，单击“编辑画面”按钮，打开该组态画面进行编辑。

如果当前画面正在编辑时，发生了分发画面的操作，会导致这个画面的属性变成了只读，此时，请先从组态画面管理中，取消签出，然后再次签出，这样，画面属性就是可读状态了，在组态编辑态中，这个画面就可以继续保存了。

在组态画面上显示实时数据库tag数据值

1.在组态配置客端运行组态画面编辑

2.在组态画面插入Text文本动画显示实时数据库的快照数据

勾选“动画”，双击输入框可选择tag变量. （注：第一次配置时可能出现iCV变量选择界面，这时需要点击界面右上角的“切换数据源”按钮，可进入实时数据库变量选择界面如下）

再“确定”，“保存”。

完成画面编辑后，将保存的画面在组态配置客户端签入，然后部署到iHD-HMI客户端，在客户端就可以运行组态画面了。

注意

1）iHD的tag变量只能查看，不能控制或写值。由于iCV界面限制，在组态中展示的tag变量名称有限制，如不能包含"+"、"."、"-"等符号以及min、max等关键字,具体参考iCV用户手册。

2）如果需要使用组态查看iCV数据，需要配置HMI关联对应的SCADA，具体参见iCV配置说明。

3）部署HMI需要有hdccagent启动，查看客户端进程是否存在该进程。

4）如果需要权限控制，iHD-HMI客户端需要在服务端的信任列表添加客户端IP，对应的映射用户需要有读数据权限。

4）先配置实时数据库节点并部署分发到客户端，iWebview的趋势图才能够选点。

添加文件夹

§添加文件夹

我们通过文件夹的方式来对组态画面进行分组浏览。单击“添加文件夹”按钮，输入文件夹名称，单击确定，服务端在指定目录下创建该文件夹，组态画面管理主界面上显示已添加的文件夹。

添加的文件夹在表格中浏览，双击文件夹所在行进入该文件夹。

返回上级目录

§返回上级目录

浏览文件夹内组态画面时，可点击“返回上级目录”按钮，返回上级目录。

删除

§删除

选中一个或多个文件夹/未签出画面，单击“删除”按钮，从服务端删除这些文件。

§分发：请参阅“分发/全部分发”章节。

注：

1、画面名称：非空，最大长度255字节；

2、画面描述：可为空，最大长度63字节；

文件夹名称：非空，最大长度255字节；


仪表图

Navigation: »No topics above this level«

仪表图

 Return to chapter overview

仪表图

Glossary Item Box

仪表图控件

仪表图为 SemiCircleMeter Control，如下图：

2. 插入：

3.右键点击特殊属性，配置当前数据、标题、背景、刻度、量程等。如下图：

当前数据：双击弹出变量选择对话框，可以选择一个变量，运行时仪表指针会指向变量的值。

4. 运行组态画面，就可以显示出仪表图：


组态运行

Navigation: »No topics above this level«

组态运行

 Return to chapter overview

组态运行

Glossary Item Box

运行组态

在iHD-HMI节点的开始菜单有组态运行客户端的快捷方式，

点击启动即运行组态系统，将打开配置的初始画面。


组态展示

Navigation: »No topics above this level«

组态展示

 Return to chapter overview

组态展示

Glossary Item Box

©2015. All Rights Reserved.