​TestStand API 编程【4】

TestStand​架构​与​TestStand API


精心设计​的​模​块​化​测试​架构​可​提供​极大​的​价值。​灵活​的​通用​架构​可​应用​到​多种​测试​系统​上，​以​延长​测试​系统​的​使用​寿命​并​降低​测试​开发​成本。​TestStand​提供​了​基于​模​块​化​的​平台，​可​简化​测试​系统​及​相应​测试​的​开发​过程。​TestStand​的​强大​之​处​在于​其​开放​式​架构，​用户​可​通过​该​架构​创建​复杂​且​灵活​的​测试​解决​方案。

TestStand​引擎​提供​TestStand​组​件​所需​的​功能，​组​件​通过​TestStand API​与​引擎​进行​通信


TestStand​的​表示​层​（用户​看到​的​内容）​和​业务​逻辑​层​（用户​动作​背后​的​操作）​之间​存在​明确​的​分隔。​不同​层​之间​通过​TestStand API​进行​通信。​通过​这种​方法，​用户​可​创建​通过​TestStand API​调​用​TestStand​引擎​的​附加​组​件​（例如，​创建​自​定义​用户​界面、​动态​控制​测试​流、​在​运行​时​创建​序列​以及​开发​其他​高级​解决​方案），​从而​扩展​TestStand​的​功能。

TestStand API​架构

TestStand​引擎​是​一个​ActiveX/​COM​自动​化​服务​器，​可​通过​API​访问​其​功能。​Microsoft​开发​的​ActiveX​应用​程序​通信​标准​提供​了​应用​程序​间​的​通信​方法。​ActiveX​基于​COM​技术，​多年​来​在​业界​得到​了​广泛​应用。​TestStand​同样​基于​COM，​因此​能够​超出​ActiveX​的​生命​周期​并​在​未来​的​Windows​操作​系统​版本​上​继续​运行。

ActiveX​采用​的是​客户​端/​服务​器​架构。​ActiveX​服务​器​是​将​特定​功能​开放​给​遵循​ActiveX​标准​的​客户​端的​应用​程序。​此外，​ActiveX​应用​程序​采用​的是​面向​对象​编​程​（OOP）​方法。

ActiveX​服务​器​架构​允许​任何​可​调​用​ActiveX​代码​的​编​程​语言​（例如​LabVIEW、​LabWindows™/​CVI™、​C#、​VB .NET​或​C​+​+）​与​TestStand​引擎​进行​交互。​使用​TestStand API​编​程​时，​具体​实现​方法​取决​于​用户​使用​的​语言。​例如：

  • LabVIEW​使用“属性”和“调​用”节点​来​调​用​API。
  • LabWindows/​CVI​使用​仪器​驱动​wrapper​来​对​API​调​用​进行​包装。
  • C#​或​VB .NET​使用​TestStand​提供​的​互​操作​程序​集​调​用​API。
  • TestStand​本身​也​提供​了​用于​访问​API​的​ActiveX/​COM​适​配​器，​用户​还​可以​通过​表达​式​直接​访问​API。

无论​使用​哪​种​方式​访问​API，​在​任何​环境​中​引发​的​行为​都是​相同​的，​因为​具体​功能​在​TestStand​引擎​中​实现，​与​使用​的​接口​无关。

API类

TestStand API​定义​了​多种​类​来​表示​TestStand​对象​的​类型，​例如​SequenceFile​类​或​Execution​类。​每​个​类​都​定义​了​属性​和​方法，​可​用于​访问​相关​数据​或​执行​操作。​例如，​SequenceFile​类​定义​了​Path​属性​以​存储​序列​文件​在​磁盘​中的​路径，​还​定义​了​Save​方法​以​保存​序列​文件。

类​继承

TestStand​中的​许多​类​通过​继承​相互​关联：​较​为​具体​的​类​可​继承​通用​类​的​属性​或​方法。​例如，​SequenceFile​类​是​PropertyObject​类​的​更​具体​版本。​TestStand API​所​定义​的​类​之间​的​继承​关系​允许​较​具体​的​类​对象​访问​通用​类​的​属性​和​方法。

SequenceFile​类​继承​了​更​通用​的​PropertyObjectFile​类​和​PropertyObject​类​的​属性​和​方法。

 

几乎​所有​的​TestStand API​类​都​继承​自​PropertyObject​基​类，​该​基​类​中​包含​TestStand​对象​共享​的​常见​方法​和​属性。​PropertyObject​类​定义​了​通用​属性​（例如​Name​和​Numeric Format），​并​提供​了​常用​的​对象​管理​方法​（例如​复制、​设置/​获取​值、​创建/​删除​对象​及​操作​数​组）。​由于​大​多数​TestStand API​类​继承​自​PropertyObject​类，​因此​可以​访问​通用​属性​和​方法。​例如，​您​可以​使用​PropertyObject.Clone()​方法​创建​步骤、​序列​或​序列​文件​对象。

许多​开发​环境​会​阻止​您​直接​访问​父​类​的​属性。​同样​的，​在​TestStand​中，​SequenceFile​对象​无法​直接​调​用​Clone()​方法。​但​TestStand API​提供​的​强制​转换​方法​可​允许​对象​访问​通用​类​的​属性​和​方法。​如需​访问​PropertyObject​类​所​定义​的​属性​和​方法，​可​调​用​AsPropertyObject​方法​将​对象​强制​转换​为父​类。​例如，​如需​在​序列​文件​对象​上​访问​Clone()​方法，​应​使用
SequenceFile.AsPropertyObject.Clone()。

关于API​继承和PropertyObject类​属性​及​方法​的​详细​信息，​详​见​NI TestStand​帮助。

动态​属性​与​内​置​属性

TestStand​对象​有​两​种​不同​的​属性​类型：

  • 内​置​属性​（API​属性）​由​对象​的​类​定义，​适用​于​特定​类​的​所有​对象。
  • 动态​属性​（子​属性）​由​对象​定义，​同​一个​类​的​不同​对象​之间​可能​会​有​差异。

步骤​对象​具有​动态​属性​（因​步骤​类型​而​异）​和​静态​属性​（由​TestStand API​中的​步骤​类​定义）


这​两​种​不同​的​属性​类型​均可​在​TestStand​表达​式​中​使用“.”操作​符​进行​访问， 因此​很​容易​混淆。​但在​其他​编​程​语言​中​使用​API​时，​通过​直接​访问​方法​只能​访问​内​置​属性，​例如​在​LabVIEW​中​使用​属性​节点。


如需​访问​动态​属性，​需​使用​PropertyObject API​方法，​例如​GetValString()​和​GetValNumber()，​并​通过​LookupString​指定​动态​属性​的​名称：



在​某些​情况​下，​可​使用​动态​属性​或​内​置​属性​以​多种​方式​对​属性​进行​访问。​在​代码​模​块​中​使用​TestStand API​时，​最好​使用​内​置​属性，​因为​内​置​属性​可​直接​访问，​无​需​维护​查找​字符​串。 

TestStand​对象​关系

TestStand​对象​可​包含​不同​类​中的​其他​对象，​这​称为API​包含​(API Containment)。​例如，​SequenceFile​对象​包含​序列​文件​中​定义​的​序列​所​对应​的​Sequence​对象。​每​个​Sequence​对象​又​包含​Step​对象。

TestStand API​中的​对象​通常​包含​另外​一个​类​的​其他​对象

理解​对象​之间​的​包含​关系​有助​于​查找​具体​的​对象。​如​父​对象​包含​多个​属于​特定​类​的​子​对象，​如果​要​查找​所需​的​子​对象，​必须​提供​属性​名称​或​索引。​对于​大​多数​子​对象，​可​使用​特定​的​getter​方法，​通过​父​对象​访问​被​包含​的​对象，​getter​方法​可​接受​对象​名称​或​索引​作为​参数。​例如，​如需​访问​序列​文件​中的​某​个​步骤，​可​使用：

SequenceFile.getSequenceByName(“MainSequence”).GetStepByName(“RAM Test”, StepGroup_Main)

此外，​子​对象​可​通过​API​访问​其​父​对象。​由于​子​对象​只能​有​一个​父​对象，​可​使用​属性​直接​访问​父​对象，​无​需​使用​getter​方法。​例如，​如需​访问​SequenceContext​对象​的​父​对象​execution，​可​使用：

ThisContext.Thread.Execution

在​多数​情况​下，​内​置​属性​可​用于​访问​关系​较​远​的​祖先​类。​例如，​可​从​Sequence Context​对象​中​直接​访问​execution​对象：

ThisContext.Execution

 

通过​TestStand API​对象​进行​导航

除了​通过​包含​关系​进行​导航​之外，​许多​类​还​提供​了​用于​访问​其他​相关​对象​的​属性​或​方法。​例如，​Module​类​提供​的​Adapter​属性​可​用于​访问​正在​运行​的​相应​适​配​器。 

TestStand API​参考帮助​提供​了​所需​的​图表，​来​帮助​您​确定​通过​当前​对象​访问​目标​对象​的​方法。​下表​为​该​表格​的​一部分。
 

可​根据​对象​关系​从​sequenceContext​对象​访问​其他​对象

 

访问​TestStand API

根据​要​创建​的​应用​程序​类型，​有​两​种​常见​的​访问​API​的​方法：

  • 对于​独立​应用​程序，​需要​创建​一个​新的​TestStand​引擎​实例​(instance)。
  • 对于​从​现有​应用​程序​中​调​用​的​代码​模​块​或​其他​工具，​必须​传递​TestStand​引擎​的​现有​引用。

 

创建​独立​TestStand​应用​程序

如需​在​新的​应用​程序​中​使用​TestStand API，​必须​首先​创建​一个​TestStand​引擎​实例。​任何​TestStand​应用​程序​或​进程​（例如​TestStand​用户​界面、​序列​编辑​器​或​自​定义​工具）​需要​维护​引擎​的​一个​实例，​也​称为​单​例​（singleton），​才能​执行​任意​TestStand​功能。​引擎​将​维护​内存​中​所有​对象​的​引用、​设置/​控制​执行​并​存储​TestStand​会话​的​上下文​数据​以及​站​点​全局​变量​和​用户​信息。

TestStand​引擎​提供​了​创建​其他​TestStand​对象​的​方法，​以​关键​字“new”表示，​示例​如下：

  • Engine.NewSequenceFile()
  • Engine.NewStep()
  • Engine.NewExecution()
  • Engine.NewPropertyObject()

关于​引擎​对象​的​可用​属性​和​方法​的​完整​列表，​详​见“TestStand​引擎”主题。

应用​程序​完成后，​必须​先​关闭​TestStand​引擎，​然后​再​退出​应用​程序。​关闭​需要​两​个​步骤，​以​确保​用户​能够​终止​任何​正在​运行​的​执行​过程，​具体​说明​见​TestStand​帮助​中的关闭​引擎主题。

NI​建议​使用​TestStand UI​控​件​开发​TestStand​应用​程序​和​用户​界面，​以​降低​程序​的​复杂​度，​而​非​直接​创建​TestStand​引擎​对象。​TestStand UI​控​件​在​TestStand API​之上​提供​了​一个​抽象​层，​使得​独立​TestStand​应用​程序​的​开发​变得​更加​容易。​关于​使用​UI​控​件​的​更多​信息，​见​本文​档​的​[UI​控​件​API]​部分。


从​现有​应用​程序​调​用​代码​模​块​或​工具

在​从​其他​TestStand​应用​程序​中​调​用​的​代码​模​块​或​工具​中​使用​API​时，​可​使用​顶​层​应用​程序​所​创建​的​TestStand​引擎。​如​从​正在​执行​的​序列​（例如​代码​模​块）​中​调​用​代码，​最好​使用​SequenceContext​的​输入​参数​来​完成​操作。​相​对于​直接​传递​TestStand​引擎，​该​方法​更​具​优势，​因为​通过​sequence context​不仅​可以​访问​TestStand​引擎​对象，​还​可以​访问​当前​执行​状态。

SequenceContext​表示​序列​的​当前​执行​状态，​可​提供​正在​执行​的​特定​序列​的​所有​数据​快照。​任何​线​程​中的​每​个​执行​序列​都有​自己​的​SequenceContext。

浏览“变量”视图​时​看到​的​列表为Sequence Context​一​级​属性，​其中​包括​全部​变量​类型、​当前​步骤​及​RunState​属性。​SequenceContext​还​提供​了​许多​其他​对象​的​引用，​并​将​其​作为​内​置​属性。

 

RunState​与​SequenceContext


RunState​属性​和​SequenceContext​均可​用于​访问​大​多数​同类​对象，​例如​当前​执行、​线​程、​序列​文件​以及​序列。​但​RunState​属性​包含​这些​对象，​且​将​其​视为​动态​属性，​而​SequenceContext​将​其​视为​内​置​属性。

因此，​访问​TestStand​表达​式​中的​状态​相关​信息​时​应​使用​RunState​属性；​SequenceContext​更​适用​于​无法​直接​访问​动态​属性​的​代码​模​块。


 SequenceContext​同时​使用​内​置​属性​和​动态​属性​提供​执行​状态​信息，​而​RunState​属性​仅​使用​动态​属性​提供​状态​信息。

序列​数据​的​存在​时间

执行​序列​中的​步骤​之前，​TestStand​将​为​序列​创建​运行​时​副本​（run-​time copy），​以便​为​每​个​序列​调​用​维护​单独​的​局部​变量​和​步骤​属性​值。​在​多数​情况​下，​通过​执行​序列​内部​的​Runstate​或​SequenceContext​访问​对象​时，​实际​访问​的​对象​为​运行​时​副本。​这​意味​着，​用户​对​这些​对象​所作​的​改​动​在​执行​结束​后​将​不​复​存在。​例如，​更改​局部​变量​的​值​或​以​编​程​方式​为​参数​创建​子​属性​均​不会​影响​磁盘​中的​序列​文件：

Locals.SetValString("RuntimeVariable",​1, "value")

继承​自​PropertyObjectFile​类​的​对象​（如​SequenceFile​对象）​不​具有​单独​的​运行​时​副本，​因此​通过​这些​对象​所​做的​改​动​在​执行​结束​后​仍​将​存在。​例如，​通过​SequenceFile​对象​访问​Locals​属性​可​创建​持续​存在​的​局部​变量。

RunState.sequencefile.GetSequenceByName("MainSequence").Locals.SetValString("PersistantVariable",​1, "value")

 

TestStand API​的​常见​应用

虽然​TestStand API​能够​实现​所有​TestStand​功能​自动​化，​但​API​常用​于​下列​应用：

  • 创建​自​定义​属性
  • 创建​新​序列​文件
  • 修改​现有​序列

 

创建​自​定义​属性

可​使用​TestStand API​在​运行​时​动态​创建​自​定义​属性，​例如，​在​特定​组​件​测试​失败​时​向​测试​结果​添加​特定​诊断​数据，​或​向​报告​表​头​添加​自​定义​数据。 

可​通过​多种​方式​使用​API​创建​自​定义​属性。​对于​原生​数据​类型，​创建​新​属性​最​简单​的​方法​是​使用​具有​InsertIfMissing​选项​的“SetVal”方法。​例如，​可​使用​下列​表达​式​向​数值​限制​测试​步骤​添加​新​属性：

RunState.Sequence.Main["Numeric Limit Test"].AsPropertyObject.SetValString(
"Result.extraResult",
PropOption_InsertIfMissing,
"this string is an extra result")

如需​向​报告​添加​自​定义​属性，​必须​同时​设置​对象​的​IncludeInReport​参数，​报告​生成​器​通过​该​参数​选择​要​记录​的​结果​属性：

RunState.Sequence.Main["Numeric Limit Test"].AsPropertyObject.SetFlags(
"Result.extraResult",
0,
PropFlags_IncludeInReport)

关于​使用​API​向​测试​报告​添加​数据​的​详细​信息，​详见Adding Custom Data to a Report范​例。

对于​较​复杂​的​属性​（例如​容器），​需​使用​NewSubProperty()​方法​直接​创建​属性，​该​方法​可​用于​创建​容器、​数据​类型​实例​以及​数​组。​例如，​可​使用​下列​表达​式​创建​类型​为​Error​的​新​局部​变量：

Locals.NewSubProperty("ComplexContainer.Error",PropValType_NamedType, False, "Error",​0)

关于​使用​API​创建​属性​的​详细​信息，​详​见​[Creating new properties using API]​范​例。

 

创建​新​序列

如需​根据​用户​输入​自动​创建​序列​文件，​可​使用​TestStand API​生成​新的​序列​文件​或​创建​现有​文件​的​修改​副本。​例如，​可​创建​自​定义​工具​使​其​根据​特定​用户​输入​生成​初始​序列​文件，​或​对​现有​序列​文件​的​步骤​执行​特定​的​修改。

关于​使用​API​创建​新​序列​文件​的​详细​信息，​详见 Building a Sequence Using the API 范​例。

也可以​使用​TestStand API​开发​序列​文件​转换​器，​生成​自​定义​文件​格式​的​序列​文件。​创建​序列​文件​转换​器​时，​可​通过​TestStand API​根据​指定​文件​中的​数据​生成​序列​文件、​序列、​步骤​及​属性。​用户​可​通过​转换​器​架构​将​上述​代码​集成​至​TestStand，​并​直接​以​自​定义​格式​打开​文件。 

关于​使用​序列​文件​转换​器​的​详细​信息，​详​见​TestStand​帮助​中的序列​文件​转换器主题


修改​序列

可在​自​定义​工具​中​使用​TestStand API​对​现有​的​序列​文件​进行​修改。​例如，​可​创建​工具​对​由​绝对​路径​指定​的​代码​模​块​进行​检查，​并​将​其​替换​为​相对​路径。 

详细​信息见Creating a Sequence File Iteration Tool范​例。

 

其他​TestStand API

除了​核心​TestStand API​以外，​TestStand​的​其他​API​可​用于​扩展​性能​及​提供​额外​功能：

  • UI​控​件​API
  • 适​配​器​API
  • 同步​服务​器​API

与​核心​TestStand API​不同，​这些​API​不能​通过​表达​式​直接​访问，​必须​通过​ActiveX​步骤​或​单独​的​代码​模​块​才能​使用。


UI​控​件​API

TestStand​包含​一​组​用户​界面​控​件，​可​用于​快速​开发​TestStand​用户​界面。​这些​控​件​包括​用于​显示​TestStand​数据​的​可见​控​件​（例如​步骤​视图​或​变量​视图）​以及​在​TestStand​用户​界面​中​处理​与​TestStand​引擎​API​之间​大部分​通信​的​不​可见​管理​程序​控​件。

开发​独立​的​TestStand​应用​程序​时，​NI​建议​用户​使用​UI​控​件​来​开发​应用​程序，​而​非​直接​创建​TestStand​引擎​实例。

用户​可​使用​UI​控​件​API​通过​管理​程序​控​件​实现​常见​的​用户​界面​任务，​例如​打开​和​执行​序列​文件、​响应​UI​消息​及​处理​应用​程序​关闭。​UI​控​件​API​还​提供​了​用于​配置​UI​控​件​的​连接​方法。 

关于​使用​UI​控​件​和​UI​控​件​API​的​详细​信息，​详​见​下列​帮助​主题：


可​将​TestStand UI​控​件​想象​为​TestStand​引擎​API​之上​的​一个​软件​层。​这些​控​件​对​用户​界面​中的​许多​常用​功能​包装​起来，​例如​打开​序列、​运行​测试、​显示​测试​进度​等。​TestStand UI​控​件​功能​丰富，​且​包含​自身​的​API。​尽管​本文​档​的​范围​并不​涵​盖​用户​界面​控​件​的​功能，​但​应​指出​的是，​这些​控​件​所​提供​的​功能​是​建立​在​TestStand​引擎​API​的​基础​之上。

 

适​配​器​API

适​配​器​API​能够​为​TestStand​中​包含​的​不同​适​配​器​提供​专用​的​类。​通常，​在​核心​API​中​使用​适​配​器​或​模​块​类​时，​可​使用​适​配​器​API​来​获取​适​配​器​特有的​信息​或​功能。​此时，​对象​将会​被​强制​转换​为​合适​的​适​配​器​API​类。​例如，​可​使用​LabVIEWModule​类​访问​用于​LabVIEW​步骤​中的​模​块​对象​的​LabVIEW​特有​属性​和​方法。

使用​适​配​器​API​访问​模​块​或​适​配​器​类​的​适​配​器​特有​属性​和​方法

关于​适​配​器​API​中​提供​的​类​列表，​详见TestStand​适​配​器​API​参考

同步​服务​器​API

同步​服务​器​API​可​提供​直接​访问​TestStand​同步​对象​（例如，​队列、​锁定​或​通知）​的​方法。​要​使用​该​API，​首先​需​通过​Engine.GetSyncManager​方法​获取​同步​管理​器​的​引用。​将​该​对象​强制​转换​为​同步​服务​器​API​中​所​定义​的​同步​管理​器​类​之后，​可用​其​访问​或​创建​新的​同步​对象。


使用​SyncManager​和​同步​服务​器​API​在​代码​中​创建​并​访问​TestStand​同步​对象

 

该​API​适用​于​开发​与​TestStand​测试​同时​运行​且​需​访问​执行​状态​信息​的​应用​程序，​例如，​状态​监​控​应用​程序。

关于​可用​的​类​的​详细​信息，​详见同步​服务​器​API​参考主题。

 

原文地址：https://www.ni.com/zh-cn/support/documentation/supplemental/08/programming-with-the-teststand-api.html

posted @ 2020-02-14 09:06  NiKaFace  阅读(3714)  评论(2)  编辑  收藏  举报