Release of URCap SDK 1.9.0, PolyScope 5.6 and 3.12

[jbm]

Dear valued developers,

Universal Robots is delighted to announce, that we are now releasing a new software, to continuously deliver more value to you and our customers.The new release consist of:

• PolyScope 5.6.0 for e-Series
• PolyScope 3.12.0 for CB3
• URCap SDK 1.9.0 including URCap API 1.9.0 for both platforms

Key features

The key features in this release is:

Drivers

• URCap Gripper Drivers
  • Support for Grip Detection and Release Detection
    • See updated example “Advanced Gripper” for implementation example.
  • Support for inserting and configuring Gripper Drivers in templates
    • See example “Grip or Release Swing” on how to use a Gripper Driver in a template
  • Support for existing URCaps to become “Grippers” - aka “conformant devices”
• URCap Screwdriver Drivers
  • Screwdrivers can now create a Screwdriver Contribution to integrate seamlessly into the PolyScope screwdriving wizard.
  • See the 3 examples “Simple Screwdriver”, “Advanced Screwdriver” and “Custom Screwdriver” for implementation examples.

General API

• URCaps can create Features
  • See example “Create Feature Swing” for implementation example.
• ProgramNodes can decide whether they support breakpoints, single stepping and start-from-selection for themselves and their children. See improved debugging functions below.
  • See examples “Ellipse”, “Ellipse Swing”, “Cycle Counter” and “Cycle Counter Swing” for implementation examples.

Other relevant features

• Online Path Offset
  • Ability in URScript to define dynamic offsets to motion, i.e. for weaving operations in welding.
  • See the Online Path Offset article on the Support Site
• New Dashboard server commands, including support for reading local/remote control mode, or operational mode.
• Improved debugging features
  • In 5.5 we released support for starting a program fron the current selection in a program
  • In 5.6 debugging is improved, with ability to set breakpoints in the program tree
  • Furthermore, the “Single Step” functionality is improved, and will now include preamble code from the installation.
  • URCaps have reasonable defaults, for what they support. But we recommend all developers to consult the
• Remote TCP and Toolpath import
  • Using the Remote TCP & Toolpath URCap, it is possible to import complex toolpaths, such as G-Code for the robot to follow.
  • The Remote TCP & Toolpath feature comes with a new subset of URScript commands to programatically use this functionality.

Get started with the new API

You can download the latest URCaps SDK and URCaps Starter Package under the Download Center .
Find the latest PolyScope software on the UR Support Site .

URCap SDK and API release notes

Please find the release notes related to the URCap API and SDK 1.9 below:

URCaps API

• URCaps can implement Screwdriver driver contributions to add functionality for screwdriver devices to PolyScope.
  Note: Screwdrivers are only supported on e-Series.

  • Support for Screwdriver driver contributions provides the following benefits:

    • It makes extremely easy and fast to create URCaps supporting screwdrivers in PolyScope by reducing development complexity and time significantly
    • Allows URCap developers to focus on the specific functionality related to their product, instead of spending time on implementing, e.g. UIs, handling of defined/undefined program node state and handling storing/retrieving data.
    • Provides users a simplified and uniform user experience when working with screwdrivers in PolyScope

  • A Screwdriver driver contribution will integrate into the following parts of PolyScope:

    • The built-in Screwdriving installation screen, where the screwdriver driver will be selectable together with the built-in user-defined screwdriver. When the screwdriver driver is selected, the screwdriver will be used by the built-in Screwdriving program node and an optional custom UI (only if the URCap chooses to define one) will be displayed which allows the user to setup the screwdriver.
      
      
    • The built-in Screwdriving program node can use the screwdriver driver for programming screwing operations (when the screwdriver driver is selected in the installation). The configuration options available to the user are based on what functionality the screwdriver driver supports.
      
      

  • A Screwdriver driver contribution enables the URCap to:

    • Specify a name for the Screwdriver driver contribution. The name is displayed in the Screwdriving program node and Screwdriving installation screen (when the screwdriver driver is selected)
    • Optionally provide a custom logo. The logo is displayed in the Screwdriving program node and Screwdriving installation screen (when the screwdriver driver is selected)
    • Optionally contribute a TCP for the screwdriver to PolyScope
    • Optionally read the settings of the Tool I/O Interface as well as request exclusive control of the configuration of the Tool I/O Interface resource and exclusively configure the settings of this interface if the control request is granted to the URCap.
    • Support “default” start and stop screwdriver operations. This is mandatory for all Screwdriver driver contributions.
    • Optionally support one or more screwdriver capabilities:
      • Supported types of regular capabilities:
        • Program selection: The screwdriver supports selecting between a set of screwdriver programs (typically defined on an external control box for the screwdriver)
        • Prepare To Drive Screw: The screwdriver needs to generate script code for preparing the screwdriver for a screwdriving operation
        • Feed Screw: The screwdriver supports automatic screw feeding
        • Operation Type: The screwdriver supports the two types of screwdriving operations, i.e. tighten and loosen
      • Supported types of feedback capabilities:
        • Drive Screw OK: The screwdriver can inform whether an ongoing screwdriving operation ended successfully, i.e. ended in OK-state
        • Drive Screw Not OK: The screwdriver can inform whether an ongoing screwdriving operation failed, i.e. ended in Not OK (NOK) state
        • Screwdriver Ready: The screwdriver can inform whether the screwdriver device is ready to operate
      • All capabilities are based on execution of script code (generated by the URCap)
      • See the new ‘contribution.driver.screwdriver.capability’ Java package
    • Optionally generate script code necessary for initializing the screwdriver. The script code is added to the preamble section of a robot program.
    • Generate script code for the registered screwdriver capabilities and for performing the mandatory start and stop screwdriver operations executed when a program (with a Screwdriving program node) is run
    • Optionally define a custom UI in the Screwdriving installation screen using a general framework for building UIs to allow the user to setup the screwdriver (identical to the UI framework for Gripper driver contributions):
      • See the content in the existing ‘contribution.driver.general.userinput’ Java package
        
    • See all the content including the ‘ScrewdriverContribution’ main interface in the new ‘contribution.driver.screwdriver’ Java package

  • The following functionality is automatically handled for the URCap:

    • Retrieving and storing of data
    • The defined/undefined state of the Screwdriving program node
• Improved support for grippers:
  • Added support for the Grip Detected and Release Detected feedback capabilities for Gripper driver contributions:
    • These two capabilities can optionally be registered, if the gripper can inform whether it has detected that an object has been gripped/released after a grip/release action has been triggered
    • See new the ‘GripperFeedbackCapabilities’ interface in the ‘contribution.driver.gripper.capability’ Java package
    • When one or both of these capabilities are registered, the user will be able to enable handling of grip/release detection in the Gripper program node. This provides the possibility of:
      • Specifying a timeout value for the grip/release action (in the Grip/Release Timeout Node)
      • Defining the processing steps to perform when the grip/release action timed out (under the Grip/Release Timeout Node)
      • Defining the processing steps to perform when the a grip/release was detected (under the Grip/Release Detected Node)
        
        
        
  • Introduced the concept of PolyScope devices:
    • The new ‘Device’ base interface represents a physical device supported by PolyScope
    • Currently, gripper devices are the only supported type of device
    • See new ‘domain.device’ Java package
  • Added support for getting the list of installed gripper devices available in PolyScope:
    • See the ‘getGrippers()’ method in the new ‘GripperManager’ interface in the ‘domain.device.gripper’ Java package
  • Added support for Gripper Nodes:
    • URCaps can create and insert a Gripper Node for a selected gripper device into the Program Tree
    • URCaps can read and configure the gripper action selection (i.e. grip or release) of the configuration for a Gripper Node
    • See the ‘getGripperProgramNodeFactory()’ method in the new ‘GripperManager’ interface in the ‘domain.device.gripper’ Java package
    • See the new ‘domain.program.nodes.contributable.device.gripper’ Java package
  • Added support for storing gripper devices in the data model:
    • URCaps can store and retrieve ‘GripperDevice’ objects and other device types (‘Device’ objects) in the data model
    • A URCap program node holding a reference to an unresolved gripper device in its data model automatically becomes undefined. A gripper device can be unresolved if the URCap that added the device is not installed.
    • See new methods ‘set(String, Device)’ and ‘get(String, T, Class)’ in the ‘DataModel’ interface in the ‘domain.data’ Java package
  • Added support for registering a “regular” URCap as conformant with a PolyScope gripper device:
    • A URCap can register its program node contribution/service as conformant with a PolyScope gripper device
    • This allows the URCap to act as well as be treated and seen the same way as a URCap implementing the ‘GripperContribution’ interface
    • Registering as a PolyScope gripper device will enable other program node contributions (could be contributed by a different 3rd party URCap) to use the conformant program node contribution for e.g. creating a template node
    • The registered conformant program node contribution will get the following abilities:
      • It will be included as a device in the list of installed PolyScope grippers
      • It can be inserted as a Gripper Node into the Program Tree by another program node contribution
      • It can have the gripper action configured by another program node contribution
    • See new ‘contribution.gripper.conformant’ Java package
    • For URCaps with a Swing-based UI, see the new ‘getDeviceRegistrationManager(Class)’ method in the ‘ContributionConfiguration’ interface in the ‘contribution.program’ Java package
    • For URCaps with a HTML-based UI, see the new ‘getDeviceRegistrationManager(Class)’ method in the ‘ProgramNodeConfiguration’ interface in the ‘contribution’ Java package. Note that the program node service must additionally implement the ‘ProgramNodeServiceConfigurable’ interface.
  • Improved user feedback for Gripper driver contributions:
    • Introduced new dialog displayed when loading an old installation on a robot with a newer version of a Gripper URCap where some of the registered custom user inputs are deprecated (using the ‘deprecateUserInput(UserInput)’ method in the ‘CustomUserInputConfiguration’ interface). The intention of the dialog is to inform the user that the configuration “format” for the setup of the gripper has changed and that the old setup potentially has been adapted.
      
    • Added warning message in the Gripper Node to inform the user when the custom setup of the gripper in the Installation is incomplete or contains error, e.g. because no selection has been made in a combo box input
      
    • The “Robot needs to be powered ON to Proceed” tooltip is now displayed (in the footer) if the robot is powered off when:
      • The Test, Grip Now or Release Now button is pressed in Gripper Node
      • The Grip or Release button is pressed when operating the gripper from the toolbar
        
• Improved support for Features:
  • Added support for contribution of Features to PolyScope:
    • URCaps can add their own Features with a suggested name to the installation in PolyScope
    • URCaps can remove their own Features from the installation in PolyScope
    • URCaps can update the pose for the position of their own Features
    • See new ‘FeatureContributionModel’ interface in the ‘domain.feature’ Java package
    • PolyScope integration:
      • Features added by URCaps are displayed in the new URCap section in the Features installation screen
      • A selected URCap Feature cannot be modified in any way by the user or other URCaps (i.e., it cannot be removed, renamed, or have its position changed)
      • Features contributed by URCaps are grouped by the URCap “owner” in terms of the name of the URCap and its developer in all drop-down lists in programs Nodes where a Feature can be selected, e.g. ‘Move’ Nodes. User-defined Features are listed in the top of the feature drop-down lists followed by features added by URCaps.
      • Note: Removing a Feature or updating the pose of a Feature while loading an installation is not allowed. Such attempts are ignored. This is to ensure the original Feature configuration in the installation is always properly loaded
        
        
  • Added support for storing Features in the data model:
    • A URCap program node holding a reference to an unresolved Feature in its data model automatically becomes undefined. A Feature can be unresolved if a different installation (that does not contain the feature) is loaded or if the Feature is removed.
    • See new methods ‘set(String, Feature)’ and ‘get(String, Feature)’ in the ‘DataModel’ interface in the ‘domain.data’ Java package
• Added support for getting a corresponding ‘TreeNode’ instance for child program node (‘ProgramNode’ instance) in the sub-tree under a ‘TreeNode’ instance:
  • This can for instance be used to gain access to the sub-tree under a child program node encountered while traversing the sub-tree of the parent node using the program node visitor
  • See new method ‘locateDescendantTreeNode(ProgramNode)’ method in the ‘TreeNode’ interface in the ‘domain.program.structure’ Java package
• Added support for configuring a program node contribution’s ability to be used in the built-in PolyScope program debugging/execution control functionality:
  • URCaps can configure whether or not the user is allowed to single step or set a breakpoint (pause) on its own URCap program node as well as any of the child nodes in the sub-tree under it
  • URCaps can configure whether or not the user is allowed to start the program directly from its own URCap program node as well as any selected child node in the sub-tree under it
  • See the new ‘ProgramDebuggingSupport’ interface in the new ‘contribution.program.configuration.debugging’ Java package
  • For URCaps with a Swing-based UI, see the new ‘getProgramDebuggingSupport()’ method in the ‘ContributionConfiguration’ interface in the ‘contribution.program’ Java package
  • For URCaps with a HTML-based UI, see the new ‘getProgramDebuggingSupport()’ method in the ‘ProgramNodeConfiguration’ interface in the ‘contribution’ Java package. Note that the program node service must additionally implement the ‘ProgramNodeServiceConfigurable’ interface.
• Extended the ‘URCapInfo’ interface with new methods for getting information about the name of the URCap and the name of the vendor of the URCap
• Made various updates and improvements to Javadoc
• Reduced the amount of disk space taken up by an installed URCap

URCaps SDK

• URCap samples:
  • Added new URCap samples:
    • ‘Grip and Release Swing’: Demonstrates how to use gripper devices in a template program node. The sample shows how to use the following new API features:
      • Getting the list of installed grippers available in PolyScope
      • Inserting a Gripper program node for a specific gripper device
      • Configuring a Gripper program node for grip and release actions
    • ‘Simple Screwdriver’: Demonstrates how to create a screwdriver driver contribution for a basic screwdriver that only supports the mandatory start and stop screwdriver operations
    • ‘Advanced Screwdriver’: Demonstrates how to create a screwdriver driver contribution for a more advanced screwdriver that supports several optional screwdriver capabilities
    • ‘Custom Screwdriver’: Demonstrates how to define a custom UI for setting up the screwdriver in the Screwdriving installation screen as well as how to add a TCP for the screwdriver to PolyScope
    • ‘Create Feature Swing’: Demonstrates how to contribute a Feature to PolyScope as well as how to store a Feature in the data model
  • Updated URCap samples:
    • Updated the ‘Advance Gripper’ URCap sample:
      • Updated the sample to demonstrate how to support the new Grip Detected and Release Detected feedback capabilities
      • Changed the implementation of the methods that generates script code for performing grip and release actions to print out the gripper action parameters to the console instead of showing them in a popup (through script code)
    • Updated the following URCap samples to demonstrate how to allow the user to use the built-in PolyScope program debugging/execution control support for starting from and pausing/breaking on a selected program node in the program tree:
      • ‘Ellipse’ and ‘Ellipse Swing’
      • ‘Cycle Counter’ and ‘Cycle Counter Swing’
    • Extracted strings used as ids for registering custom user inputs into constant fields in the ‘Custom Gripper Setup’ sample
    • Simplified the code for clearing the program sub-tree in the ‘Ellipse’, ‘Ellipse Swing’, ‘Pick or Place’ and ‘Pick or Place Swing’ samples
    • Simplified the code that provides the node title for the Program Tree in the ‘Tool Changer Swing’ sample
• Added document “URCap Screwdriver Driver” which describes the properties of Screwdriver driver contributions and how they work inside of PolyScope (screwdriver_driver.pdf file)
• Added document “Registering a Regular Contribution as a Conformant Device” which describes how to register a regular URCap contribution as conformant with a PolyScope device (registering_conformant_device.pdf file)
• Added document “Using a Device in a Template” which describes how to use a PolyScope device in a template program node (using_device_in_template.pdf file)

Dashboard Server e-Series

• New dashboard server commands
  • get operational mode - allows to determine if robot is in automatic or manual mode
  • is in remote control - allows to determine if robot can be controlled remotely
  • get serial number - reads robot serial number
  • get robot model - reads robot model
• Changed dashboard server commands
  • unlock protective stop - unlocking a protective stop is not possible until 5 seconds after occurrence.

Dashboard Server CB3

• New dashboard server commands
  • get serial number - reads robot serial number
  • get robot model - reads robot model
  • getUserRole - provides the active user role such as PROGRAMMER, OPERATOR, NONE, LOCKED. User role can be set or cleared by “setuserrole”.

Bugfixes

• Fixed issue where a Gripper contribution could define a custom UI in the Installation that did not fit on the screen. This could occur, because any added non user input UI element, such as a text component or a filler, was not taken into account in the maximum limit of 10 UI elements allowed and hence the ‘TooManyUserInputsRegistered’ exception was not always thrown. Now, the ‘TooManyUserInputsRegistered’ exception will be thrown when appropriate.
• Fixed issue where the “Unhandled exception in URCap” dialog was not displayed, when a Java exception occurred within the scope of a call to the implementation of the overridden ‘configureContribution(ProgramNodeConfiguration)’ method in a HTML-based URCap with a program node service, that implemented the ‘ProgramNodeServiceConfigurable’ interface.
• Fixed issue where pressing the Test or Grip Now/Release Now buttons in the Gripper program node, or the Grip or Release buttons in the toolbar could result in a runtime exception. This would occur, if the corresponding script code for the preamble, grip or release actions (the result of calls to the ‘generatePreambleScript(ScriptWriter)’, generateGripActionScript(ScriptWriter)‘’ and ‘generateReleaseActionScript(ScriptWriter)’ methods) generated by a gripper contribution made use of conditional statements, such if- and while-statements.
• Fixed issue where the URCap title displayed in the left-hand side of the Installation and Program tab was truncated in PolyScope for the some of URCap SDK samples with Swing-based UIs. Now, the word “Swing” is not included in the URCap titles.
• Fixed issue where the “There is an error with the URCap that contributes this node” screen, which is displayed instead of the UI for an Installation node contribution when an error occurs while entering the URCap installation screen, would incorrectly be shown, if a Java exception had occurred while the Installation contribution generated script code for the program preamble. Now, the URCap UI will be shown instead.
• Fixed issue where the “Unhandled exception in URCap” dialog displayed during startup of PolyScope, if the code of an Installation contribution or Gripper contribution generated an unhandled Java exception, would not remain on the screen (because it was quickly closed).

You can find the complete and general release notes here:
Release Notes 5.6
Release Notes 3.12

Happy development,
The Universal Robots+ Team