PolyScope 5 URCap

Enhanced flexibility and customization

Developing a URCap allows you to tailor the robot’s functionality to meet specific application requirements. Whether it's integrating specialized tools, creating custom motion sequences, or developing intuitive user interfaces, URCaps provide the flexibility to customize the robot’s capabilities.

Integration of third-party devices

URCaps make it easier to integrate third-party devices and peripherals with UR robots. This can be crucial for applications that require specific sensors, actuators, or other hardware components to be controlled and monitored seamlessly.

Improved user experience

With URCaps, you can create custom user interfaces that simplify the operation of complex robotic processes. This can lead to improved productivity and reduced training times, making it easier for operators to use the robots effectively.

Enhanced automation capabilities

By extending the functionality of UR robots with URCaps, you can automate more complex tasks and processes. This can lead to increased efficiency, reduced downtime, and improved overall performance of your automation system.

Development efficiency

The URCap SDK provides API tools, libraries, and documentation that streamline the development process. This allows developers to quickly create and deploy custom solutions, reducing development time and costs.

Examples of URCap applications

Custom Grippers: Integrate and control custom-designed grippers directly from the Polyscope interface.
Vision Systems: Add support for vision systems to enable advanced functionalities like object recognition and inspection.
Specialized Motion Control: Develop custom motion control algorithms for applications requiring precise movements.
Operator Guidance Systems: Create interfaces that guide operators through complex assembly or inspection tasks.

Key components of URCap development

PolyScope 5 URCaps are developed using Java. The development of URCaps relies on the URCap Software Development Kit (SDK) provided by Universal Robots, which includes tools and libraries for creating custom extensions and plugins that integrate seamlessly with the PolyScope interface.

Java programming language

Primary Language: Java is the primary programming language used to develop URCaps. The choice of Java ensures a robust, object-oriented, and platform-independent environment for creating sophisticated and reliable plugins.

Java SDK: The URCap SDK provides a set of Java APIs that allow developers to interact with the robot's system, create custom user interfaces, and extend the functionality of PolyScope.

OSGi framework

Modular Architecture: The URCap platform uses the OSGi (Open Service Gateway initiative) framework, which is a dynamic module system for Java. OSGi allows URCaps to be developed as modular bundles that can be installed, started, stopped, and updated independently. Service Management: OSGi facilitates service management within the URCap, enabling components to interact with each other and with the PolyScope system dynamically.

XML configuration

Component Configuration: URCaps require XML configuration files to define metadata, such as the bundle name, version, and dependencies. These configuration files help manage the lifecycle and integration of the URCap within the PolyScope environment.

Daemon processes

Background Execution: URCaps can create background processes (daemons) that run alongside the main PolyScope interface. These daemons can perform various tasks such as data processing, communication with external devices, or running complex algorithms that require continuous operation independently of the main robot program execution.

Each URCap can contribute multiple new functionalities to PolyScope – such functionality is generally referred to as a service. A service could be a Program Node, an Installation Node or a Toolbar.

The general principle of how a URCap is integrated into PolyScope, is shown in the diagram below.

When PolyScope starts up, it looks for any installed URCaps. PolyScope then calls the Activator in each URCap, and the Activator will then register the services that should be available to PolyScope. The Activator has two overwritten methods – start() and stop(). The start() method is called when PolyScope starts, and the stop() method is called when PolyScope stops. The service sets some general properties of the URCap, such as the name of the node shown in the user interface. The Service also exposes some methods that PolyScope uses to create respectively the user interface (UI) and the contribution of each node.

In general, the settings present in the service are considered static, as they are only called at startup, and are not available for changes during runtime.

When a user inserts a type of service into a program, PolyScope calls the methods in the service in order to create this node. This will create a user interface, and a contribution. The user interface contains the visual elements, such as styling for PolyScope layouts and user interactions.

The contribution is the logic, or controller code, of the active node. There is a new instance of the contribution, for each instance of the node, active in the program. The contribution has a DataModel object, which is used to store the configuration of the node. When the user performs an action in the UI, the UI will report this to the active contribution, and the setting gets stored in the DataModel from the contribution. When the user executes the program, the contribution is responsible for generating the URScript based on the configuration of the DataModel.

When the nodes are created, and the user is interacting with it, the general activity is happening between the UI and the Contribution.

URCap key principles

Java methods for URCap development

My first URCap