Skip to content

Universal Robots integration

Understanding Universal Robots capabilities and workflow gaps

Universal Robots has deployed collaborative robots (cobots) across manufacturing facilities worldwide. Their PolyScope X software provides programming capabilities and URCaps enable hardware integration, but the platform uses static programming approaches that create challenges for enterprise workflow management.

Current Universal Robots ecosystem

What Universal Robots provides today

Hardware platforms:

  • UR3e: 3kg payload for precision assembly
  • UR5e: 5kg payload for light assembly and pick-and-place
  • UR10e: 12.5kg payload for palletizing and machine tending
  • UR16e: 16kg payload for heavy material handling
  • UR20: 20kg payload with 1750mm reach for large parts
  • UR30: 30kg payload for heavy industrial applications

Software ecosystem:

  • PolyScope X: Latest platform with enhanced UI and progressive disclosure design
    • Available in 22 languages
    • Works from any device with a browser
    • Supports modular programming with reusable functions
    • Includes Smart Skills for precise positioning
    • Features Teach Mode for recording complete paths
    • OptiMove for dynamic speed and acceleration optimization
  • PolyScope 5: Supported on existing deployments (documentation being phased out as of release 5.19)
  • URCaps: Plugin ecosystem for third-party integrations
  • UR+: Marketplace for certified accessories and software
  • URSim: Offline simulation environment
  • AI Accelerator: NVIDIA Isaac integration for computer vision and path planning

Programming capabilities:

  • Visual programming with Program Tree interface
  • URScript scripting language for custom control
  • Multi-copy/paste of nodes
  • Nested functions (unlimited depth)
  • Operator Screen for simplified changeover management
  • New program nodes: Halt, Timer, Process move, Circular move, Direction until, Switch case
  • World-centric and tool-centric coordinate frames

Critical gaps in Universal Robots’ workflow system

1. No dynamic knowledge lookup

Current state: UR cobots execute pre-programmed routines stored locally:

  • Programs are static files on the controller
  • No ability to query external procedures
  • Changes require manual reprogramming
  • Each robot maintains isolated program library

Example problem: A UR10e performing quality inspection encounters a new product variant. The robot has no program for this variant and stops production. An engineer must create a new program, test it in URSim, and deploy to the robot.

How Tallyfy could address this: A workflow management layer could allow robots to query standardized procedures for different product variants, reducing the need for individual programs per variant.

2. No continuous improvement mechanism

Current state: Each cobot operates with its own programs:

  • Optimizations remain local to individual robots
  • No systematic capture of best practices
  • Programs don’t evolve based on experience
  • Knowledge lost when operators leave

Example problem: An operator discovers that a slight wrist rotation improves connector insertion for a UR5e in electronics assembly. This improvement stays locked in that single robot’s program unless manually propagated to other units.

How Tallyfy could address this: When an optimization is discovered, it could be documented in Tallyfy’s SOP management system, making the knowledge accessible across robot deployments rather than remaining isolated in individual programs.

3. Limited compliance and traceability

Current state: PolyScope logs robot movements but not procedural compliance:

  • No record of which SOP version was followed
  • Limited context for operator interventions
  • Difficult to prove adherence to quality standards
  • Manual documentation for audits

Example problem: A medical device manufacturer uses UR16e robots for sterile packaging. FDA auditors require proof that validated procedures were followed for each batch. PolyScope shows robot logs but can’t demonstrate SOP compliance.

How Tallyfy could address this: Workflow management could provide version-controlled SOPs with electronic documentation of process steps, creating audit trails that link robot operations to validated procedures.

How Universal Robots ACTUALLY receive and execute instructions

The reality of UR “collaborative” programming

Despite the marketing about “easy programming,” here’s what actually happens:

  1. Programs are static .urp files stored on the controller:

    # This is what a UR program actually looks like
    def pick_and_place():
      movej([1.5, -1.2, 1.0, -0.5, 1.5, 0], a=1.2, v=0.25)  # Hardcoded joint positions
      set_digital_out(0, True)  # Activate gripper
      sleep(0.5)                 # Hope part is gripped
      movej([0.5, -0.8, 0.5, -0.2, 1.0, 0], a=1.2, v=0.25)  # More hardcoded positions
      # New part variant? Manually edit all positions

    From Universal Robots documentation (RoboDK UR Documentation ↗):

    • “Save the generated URP file(s) to a USB memory disk and connect to the robot teach pendant”
    • “URP files are saved in binary format by PolyScope” - not editable without teach pendant
    • Each robot stores programs locally with no central management
    • File naming conventions serve as primitive version control

  2. The “intuitive” programming is still rigid:

    • Teach pendant lets you create programs visually
    • But output is still static URScript
    • Programs can’t adapt to variations
    • IF statements are hardcoded logic, not intelligence
    • Robot has zero understanding of what it’s doing

  3. No improvement or learning mechanism:

    • Cobot discovers optimal force for insertion? Stays on that one robot
    • Process improvement? Manually update every robot’s program
    • No feedback from production to programming
    • Each robot’s experience is isolated

What happens in production reality

Scenario: UR10e assembling products with new component variant

What marketing says: “Flexible automation” and “Easy reprogramming”

What actually happens:

  1. Robot reaches pick position for new component
  2. Component is 2mm different height (not in program)
  3. Robot either:
    • Crashes into component (emergency stop)
    • Grips air (drops part later)
    • Uses wrong force (damages component)
  4. Production stops while engineer:
    • Edits program on teach pendant
    • Tests new positions (30-60 minutes)
    • Saves as “program_v2_new_component.urp”
    • Manually copies to other robots via USB
    • Realizes 3 robots still running old version next week

The real-time tracking joke

What you can see:

  • Robot is running “program_42.urp”
  • Current line number: 47
  • I/O status: Output 2 is HIGH

What you actually need for operations:

  • “Robot completing step 3 of 8 in assembly process”
  • “Quality check passed for batch #1234”
  • “Cycle time trending 5% above target”
  • “SOP version 2.3 being followed”

Actual UR log data:

2024-03-15 09:15:23 - movej complete
2024-03-15 09:15:24 - digital_out_0 = TRUE
2024-03-15 09:15:25 - wait 0.5

What compliance auditors need:

2024-03-15 09:15:23 - Positioned for component pickup (ISO-9001-5.2.1)
2024-03-15 09:15:24 - Gripper activated at 45N force (spec: 40-50N)
2024-03-15 09:15:25 - Grip validation per QA-PROC-7.2

The URCap illusion

URCaps promise: “Extend robot capabilities!”

URCaps reality:

  • Plugins for specific hardware (grippers, cameras)
  • Still generate static URScript
  • No dynamic procedure management
  • No cross-robot communication
  • Each URCap is another thing to maintain on each robot

Scaling nightmare with cobots

10 UR robots: Weekly USB stick tours to update programs 50 UR robots: Full-time job managing program versions 100+ UR robots: Complete chaos

Real customer quote: “We have 47 URs and honestly don’t know which version of which program is on which robot anymore.”

Critical limitations from UR forums and documentation:

  • Program size limitations ↗: “The robot is unable to cope with programs much larger than 5000 lines”
  • Programs that work in URSim may fail on physical robots with “ValueStack Full Capacity” errors
  • Memory constraints ↗: Limited controller memory affects complex applications
  • No built-in fleet management or central program repository in PolyScope

Conceptual integration architecture

Theoretical system design

Diagram

What to notice:

  • URCap acts as bridge between robot and workflow system
  • Gateway handles protocol translation
  • Status updates flow back for tracking and compliance

Integration architecture concept

A workflow integration would likely involve:

URCap plugin layer:

  • Custom URCap developed using Universal Robots SDK
  • Program nodes that query external workflow system
  • Installation nodes for workflow system configuration
  • URScript generation based on workflow definitions

Communication middleware:

  • REST API communication between robot and workflow system
  • Translation of workflow steps to URScript commands
  • Handling of network failures and offline scenarios
  • Real-time status updates to workflow platform

Data synchronization:

  • Robot telemetry sent to workflow system
  • Task completion reporting
  • Quality metrics and sensor data capture
  • Process step verification and documentation

Workflow management challenges in robotics

High-mix manufacturing environments

Organizations running multiple product variants face challenges with static robot programming:

  • Each variant requires separate program development and testing
  • Program libraries grow large and difficult to manage
  • Changes to procedures require updating programs across all robots
  • Knowledge about optimal approaches stays isolated to individual programs

Regulated industries

Medical device and pharmaceutical manufacturers need comprehensive documentation:

  • Validated procedures must be followed consistently
  • Audit trails must link robot operations to approved SOPs
  • Process deviations require documentation and investigation
  • Manual batch record creation is time-consuming

Multi-site operations

Companies with robot fleets across facilities encounter scaling issues:

  • Program version management becomes complex
  • Process improvements at one site don’t automatically propagate
  • Inconsistent practices develop across locations
  • Training new sites requires significant effort

Complementary system capabilities

Robot control system strengths

PolyScope X provides:

  • Real-time robot motion control
  • Safety system monitoring and management
  • Digital I/O and sensor integration
  • Force/torque sensing and control
  • Vision system integration via URCaps
  • Local program execution and storage
  • Teach pendant programming interface

Workflow management system potential

Workflow platforms could provide:

  • Centralized procedure library management
  • Version control for standard operating procedures
  • Cross-site knowledge sharing
  • Compliance audit trail generation
  • Process deviation documentation
  • Human task coordination with robot operations
  • Analytics across robot fleet performance

Potential integration approach

A workflow management integration for Universal Robots would need to address several technical challenges:

  • URCap development compatible with PolyScope X architecture
  • Translation layer between workflow steps and URScript commands
  • Real-time communication between robot controllers and workflow system
  • Handling of network connectivity and failure scenarios
  • Integration with existing robot safety systems

Organizations considering such integration should evaluate:

  • Current pain points with static programming approaches
  • Volume of product variants requiring different robot programs
  • Compliance and traceability requirements
  • Scale of robot deployments across facilities
  • Availability of network infrastructure

Technical considerations

A theoretical integration would require:

  • Universal Robots cobots with PolyScope 5.11+ or PolyScope X
  • Network connectivity for real-time communication
  • Custom URCap development for PolyScope integration
  • Translation layer between workflow definitions and URScript
  • Workflow management system with API capabilities

Organizations interested in exploring workflow management for robotics should assess their specific use cases and technical requirements before evaluating integration feasibility.

Robotics > KUKA Robotics integration

KUKA robots ranging from collaborative systems to heavy-duty 1300kg units can integrate with Tallyfy through OPC UA or KUKA.Connect protocols to add workflow management capabilities for procedure documentation process tracking audit trails and fleet visibility that complement their robust motion control and programming tools.

Integrations > Robotics

This section explores robotics workflow management challenges including communication protocols like OPC UA and ROS integration architecture security requirements human-robot collaboration patterns safety compliance technical readiness organizational considerations and industry applications across manufacturing logistics healthcare and food sectors while addressing protocol complexity network security latency sensitivity and legacy system limitations.

Robotics > Unitree Robotics integration

Unitree Robotics manufactures quadruped and humanoid robots with SDK capabilities for various applications but lacks centralized workflow management and knowledge sharing capabilities that Tallyfy could provide through API integration enabling dynamic procedure management fleet-wide learning propagation and comprehensive compliance tracking for scalable robotic operations.

Robotics > AppTronik Apollo integration

AppTronik’s Apollo humanoid robot designed for industrial applications is currently in pilot deployment phase with Mercedes-Benz and GXO Logistics but faces workflow management gaps that Tallyfy could address through dynamic procedure querying centralized fleet knowledge sharing and automatic compliance documentation to enable enterprise-scale operations beyond static task programming.
Get in touch
About Tallyfy