Arctos Studio Pro User Guide

Introduction

Welcome to the Arctos Studio Pro User Guide. This document will provide you with a comprehensive overview of the Arctos Studio Pro software, from initial setup to advanced features. Arctos Studio Pro is a powerful tool for robot simulation, programming, and control, designed for professionals and enthusiasts who require advanced capabilities and a flexible workflow.

This guide is written from the perspective of a new user, and it will walk you through all the features of the application. By the end of this guide, you will be able to confidently operate Arctos Studio Pro and create complex robotic applications.

What’s New in Arctos Studio Pro?

Arctos Studio Pro builds upon the foundation of the standard Arctos Studio, adding a host of powerful features designed for advanced users and industrial applications. Here are some of the key features you’ll find in the Pro version:

Advanced UI: A modern, ribbon-based interface that provides quick access to all features.
Multi-Robot Control: Simulate and control multiple robots in the same environment.
Conveyor Belts & PLC: Integrate conveyor belts and use the built-in PLC to create complex automation systems.
Advanced Vision: Connect to cameras, including depth sensors, and use vision to guide your robot.
3D Printing & Path Following: Slice 3D models and generate toolpaths for 3D printing, or have your robot follow paths from SVG files.
Python Scripting: Write and execute Python scripts for ultimate control and flexibility.
Joystick Control: Directly control your robot with a joystick for intuitive and responsive manipulation.
Reinforcement Learning: Train your robot using reinforcement learning to perform complex tasks.
ROS Integration: Connect to the Robot Operating System (ROS) to integrate with a wider ecosystem of robotics tools.
Physics Simulation: A realistic physics engine for simulating robot-object interactions.

Let’s get started!

Getting Started

This section will guide you through the initial setup of Arctos Studio Pro.

System Requirements

To ensure a smooth experience with Arctos Studio Pro, please make sure your system meets the following requirements:

Operating System: Windows 10 or later
Processor: Intel Core i5 or equivalent (Intel Core i7 or equivalent recommended for complex simulations)
Memory (RAM): 8 GB (16 GB recommended)
Graphics Card: A dedicated graphics card that supports OpenGL 4.0 or higher.
Disk Space: 1 GB of free disk space.

Installation

Download the Arctos Studio Pro installer from the official website.
Run the installer and follow the on-screen instructions. IMPORTANT: Install for all users (to have seamless updates)
Once the installation is complete, you can launch Arctos Studio Pro from the Start Menu or the desktop shortcut.

First Run and Logging In

Upon launching Arctos Studio Pro for the first time, you will be greeted with the main interface. Many of the advanced “Pro” features require you to be logged into your Arctos Robotics account. From Robot tab click on the Account icon to access the account panel.

To log in:

Locate the Account panel. If it’s not visible, you can open it from the Robot tab in the ribbon menu.
Enter your username and password.
Click the “Login” button.

Once you are logged in, all the Pro features will be unlocked and available for you to use.

Interface Overview

The Arctos Studio Pro interface is designed for efficiency and customization. The main window is composed of several key components: the Ribbon Menu, the 3D Viewer, the Program Tree, and various Dockable Panels.

The Ribbon Menu

The Ribbon Menu is located at the top of the window and provides access to all of the tools and features of Arctos Studio Pro. It’s organized into several tabs, each focused on a different aspect of the workflow.

File: Manage your projects, save and load scenes, and access application preferences.
Robot: Connect to your robot, manage multiple robots, and access robot-specific tools like the conveyor belt and camera panels.
Modeling: Create and manipulate 3D objects in the scene.
Trajectory: Create complex robot paths, including 3D printing toolpaths and paths from SVG files.
View: Control the 3D viewer, camera, and visibility of different elements.

The 3D Viewer

The 3D Viewer is the central part of the interface, where you can see a real-time simulation of your robot and its environment. You can navigate the 3D scene using your mouse:

Orbit: Click and drag the left mouse button to orbit the camera around the robot.
Pan: Click and drag the right mouse button to pan the camera.
Zoom: Use the mouse wheel to zoom in and out.

The Program Tree

The Program Tree, typically located on the right side of the window, is where you will create and manage your robot programs. It displays a hierarchical view of your program, including:

Sequences: Ordered lists of targets that make up a program.
Targets: Recorded robot positions.
Models: Imported 3D models (STL, SVG).
Other Objects: Any other objects you’ve created in the scene.

Robot Connection and Basic Control

This section covers how to connect to your Arctos robot(s) and the basic methods for controlling their movement.

Connecting to a Robot

Navigate to the Robot tab in the Ribbon Menu.
In the “Connection” group, you’ll find the connection controls.
Choose Robot Version: Select “Open Loop” or “Closed Loop” from the dropdown, depending on your robot hardware.
Select Port: Choose the correct communication port for your robot.
Click Connect: The status of the connection will be displayed in the “Messages” panel at the bottom of the window.

Multi-Robot Environments
Arctos Studio Pro allows you to work with multiple robots in the same scene.

Adding a Robot: In the Robot tab, click “Duplicate Robot”. A new robot will be added to the scene.
Switching Between Robots: To control a different robot, simply select it in the 3D viewer. The active robot will be highlighted, and all the control panels will now correspond to the selected robot.

Basic Robot Control Methods

Arctos Studio Pro offers several ways to control your robot:

1. Joint & IK Control Panel

The Joint Control Panel gives you direct control over each joint of the robot. Inverse Kinematics panel can control translation and rotation of the end effector.

Sliders: Drag the sliders to move each joint.
Angle Input: For precise control, enter a specific angle in the input box next to each slider.
The 3D model will update in real-time to reflect the joint changes.

2. End Effector Control (IK)

For more intuitive control, you can directly manipulate the robot’s end effector (the “hand” or “tool”).

Activate Gizmo: Click on the end effector in the 3D view to show the manipulation gizmo.
Translate: Click and drag the arrows of the gizmo to move the end effector in the X, Y, or Z direction.
Rotate: Press the “G” key to toggle the gizmo to rotation mode. Click and drag the rings to rotate the end effector.
Arctos Studio Pro will automatically calculate the required joint angles using Inverse Kinematics (IK).

Joystick Control
For fluid, real-time control, you can use a standard joystick.

Connect a joystick to your computer.
In the Robot tab, click the Joystick button to open the Joystick Configuration panel.
Enable Joystick: Check the “Enable Joystick Control” box.
Map Axes: Assign joystick axes and buttons to robot movements (e.g., X, Y, Z, gripper).
Once configured, you can move the robot by using the joystick.

Program Creation and Execution

Arctos Studio Pro allows you to create complex automation programs by recording a sequence of robot positions, called “targets.”

Recording Targets

Position the Robot: Use any of the control methods (Joint Control, IK, or Joystick) to move the robot to the desired position.
Record Target: In the “Program” panel, click the “Record Target” button.
A new target will appear in the Program Tree. Each target stores the joint positions, gripper state, and movement parameters.

Editing the Program

The Program Tree provides an easy way to edit and organize your program.

Reorder Targets: Click and drag targets in the tree to change the order of execution.
Update Target: To modify a target, first select it in the tree. Then, move the robot to the new desired position and click “Update Target”. The selected target will be updated with the new position.
Delete Target: Right-click on a target and select “Delete” to remove it.

Program Parameters

You can fine-tune your program’s execution with the following parameters, found in the “Program” panel:

Speed (1-100%): Controls the overall speed of the robot’s movements.
Delay (seconds): Sets a pause duration after the robot reaches a target.
Transition Time (seconds): Adjusts how long the robot takes to move between targets. A longer transition time will result in smoother, more fluid movements.

Direct Control vs. Simulation

A critical safety feature in Arctos Studio is the Direct Control checkbox.

Direct Control ON: When checked, all movements you make in the interface are immediately sent to the physical robot. Use this with caution!
Direct Control OFF: When unchecked, all movements happen only in the simulation. This is the safe mode for developing and testing programs without risking damage to the physical robot or its environment.

Running and Stopping a Program

Run Program: Once your program is ready, click the “Run Program” button or press the “R” key. The robot (either in simulation or physical, depending on Direct Control) will execute the sequence of targets.
Stop Program: To stop the program at any time, click the “Stop” button or press the “S” key. The robot will immediately halt its movement.

Saving and Loading Programs

Save Program: In the “Program” panel, enter a name for your program and click “Save Program”. This will save the sequence as a .arctos file.
Load Program: Click “Load Program” to open a previously saved .arctos file. The program will be loaded into the Program Tree.

Scene and Object Manipulation

A key feature of Arctos Studio Pro is the ability to build a complete virtual environment around your robot. You can import your own 3D models, create primitive shapes, and set up a realistic simulation of your workspace.

Importing 3D Models (STL)

You can import 3D models in the STL format to represent things like parts, fixtures, or other machinery in your scene.

Go to the Modeling tab in the Ribbon Menu.
Click “Import STL”.
Select the STL file you want to import.
The model will appear in the 3D viewer and in the Program Tree under “Models”.

Creating Primitive Shapes and Lines

You can also create basic geometric shapes and lines directly within the application. In the Modeling tab:

Shapes: Click the “Box”, “Cylinder”, or “Polygon” buttons to add the respective shape.
Lines: Click the “Line” button to activate line drawing mode. Then, click two points on the ground plane in the 3D viewer to define the start and end of the line.

Modifying Objects (The “Modify” Tools)

Once an object is in the scene, you can modify it using interactive controls or for more precision, the tools in the Modeling tab:

Select the Object: Click on the object in the 3D Viewer or in the Program Tree.
Interactive Gizmo: Use the gizmo to move (drag arrows) or rotate (press ‘G’ and drag rings) the object.
Precise Control:
- Move: Click “Move Model” to open a dialog to enter exact coordinates.
- Rotate: Click “Rotate Model” to open a dialog for precise rotation.
- Scale: Click “Scale Model” to open a dialog to resize the object.

Physics Simulation

Arctos Studio Pro includes a physics engine for realistic simulations.

Enable Physics: In the View tab, you can toggle physics simulation.
When physics is enabled, objects will have properties like mass and friction. The robot can interact with them realistically (e.g., push them, pick them up).
This is invaluable for testing grasping operations and ensuring your robot’s path is free of collisions that would cause issues in the real world.

Conveyor Belts and PLC

For users creating factory automation or assembly line simulations, Arctos Studio Pro includes a powerful conveyor belt and Programmable Logic Controller (PLC) system.

Working with Conveyor Belts

Add a Conveyor: Go to the Robot tab and click the “Conveyor” button. This will open the Conveyor Belt panel and add a conveyor to the scene.
Control the Conveyor: In the Conveyor Belt panel, you can:
- Start/Stop: Control the movement of the belt.
- Change Speed: Adjust the speed of the belt.
- Change Direction: Reverse the direction of the belt.
Objects on the Belt: When physics is enabled, any object placed on the conveyor belt will move with it. You can also have “spawners” that generate objects at the start of the conveyor.

The PLC Editor

The PLC allows you to create complex logic for your simulation without writing any code. It’s a visual, block-based editor where you can create rules and behaviors for the objects in your scene.

Open the PLC Panel: Go to the Robot tab and click the “PLC” button. This will open the PLC panel.
Create Logic: You can drag and drop blocks to create logic. For example, you can create a rule that says: “IF a box on the conveyor reaches a certain sensor, THEN stop the conveyor and signal the robot to pick up the box.”
PLC Blocks: The PLC editor includes a variety of blocks:
- Input Blocks: Read data from sensors (e.g., proximity sensors, color sensors).
- Logic Blocks: Perform logical operations (AND, OR, NOT).
- Output Blocks: Control actuators (e.g., stop/start the conveyor, send a signal to the robot).
- Timers and Counters: Create time-based events and count objects.

Advanced Trajectory and Path Following

Arctos Studio Pro gives you advanced tools to create complex robot trajectories for tasks like 3D printing, dispensing, or welding.

3D Printing (Slicing)

You can slice an STL model to generate a 3D printing toolpath for the robot to follow.

Import an STL Model: Import the model you want to 3D print.
Open the Slicer: Go to the Trajectory tab and click “Slice Model”. This will open the 3D printing dialog.
Configure Slicer Settings: Set parameters like layer height, print speed, and nozzle size.
Generate Toolpath: Click “Slice” to generate the toolpath. The layers of the toolpath will be visualized in the 3D viewer.
Run the Print: You can then have the robot execute this path, simulating a 3D print.

Slicing Parameters Explained

When you open the slicing dialog, you’ll find several important parameters:

Layer Height (0.1-0.3mm): Controls the thickness of each printed layer. Smaller values create finer detail but increase print time.
Print Speed (10-100 mm/s): Determines how fast the robot moves while extruding material.
Nozzle Temperature: Set the temperature for material extrusion (typically 200-250°C for PLA).
Bed Temperature: Set the heated bed temperature (typically 60°C for PLA).
Infill Percentage (0-100%): Controls how solid the interior of the print will be.
Support Generation: Automatically generates support structures for overhanging features.

Advanced Slicing Options (Experimental)

Retraction Settings: Configure how the extruder pulls back filament during travel moves to prevent stringing.
Travel Speed: Set the speed for non-printing movements.
First Layer Settings: Special parameters for the critical first layer of adhesion.
Cooling Settings: Configure part cooling fan behavior.

Welding

The Welding (Edge Path) feature in ArctosStudio Pro enables you to create robot welding paths directly along the edges of imported 3D models. It automates tool positioning with precise orientation and tool compensation, ideal for welding tasks that require accuracy and consistency.

To get started, import your STL model, define the welding tool length, and activate edge selection mode. Selected edges turn blue and can be used to generate a continuous welding path. The system automatically adds safe approach and departure points to ensure reliable operation.

Once edges are selected, use the Edge Orientation Dialog to set tool angles (pitch, yaw, roll) for each segment. You can preview and adjust these in real-time, ensuring optimal torch alignment. Common configurations like flat, vertical, and overhead welding are easily achievable with preset values.

After orientations are set, the program generates all necessary motion targets, including intermediate points for smooth paths and automatic validation to ensure robot reachability. The result is a clean, optimized program ready to run or simulate.

Tool compensation is handled automatically based on your specified tool length. The system calculates TCP positions and applies orientation offsets to follow the path exactly. Advanced options include path smoothing, duplicate point removal, and surface normal detection for edge accuracy.

If you encounter issues like failed IK or inaccurate edge following, the most common fixes include adjusting the tool angle, checking your tool length setting, or ensuring the model edges are clean and well-defined.

Welding paths created with this feature integrate smoothly with other robotic operations like pick-and-place, multi-robot coordination, and custom logic. A 3D simulation is available for real-time previews before executing.

For best results, use clean STL files, measure your tool precisely, test orientations frequently, and simulate paths before live welding. The feature is designed to be both powerful and accessible—ideal for both industrial and prototyping environments.

Reinforcement Learning

One of the most advanced features in Arctos Studio Pro is the ability to train your robot using reinforcement learning (RL). This allows the robot to learn complex tasks through trial and error.

Setting Up RL Training

Open the RL Panel: Go to the Robot tab and click “Reinforcement Learning”.
Define the Task: Set up the training environment with objects and obstacles.
Configure Rewards: Define what constitutes success (positive rewards) and failure (negative rewards).

Training Process

The RL system uses deep learning to train neural networks that can control the robot:

Observation Space: Define what sensors and information the robot can use (joint positions, camera feeds, object locations).
Action Space: Define what actions the robot can take (joint movements, gripper control).
Reward Function: Create a mathematical function that scores the robot’s performance.
Pick and Place: Train the robot to pick up objects and place them in specific locations.
Obstacle Avoidance: Teach the robot to navigate around obstacles to reach a target.
Assembly Tasks: Learn to fit parts together with precise alignment.
Dynamic Catching: Train the robot to catch moving objects.

Python Scripting – with Examples

Arctos Studio Pro – Python Commands Reference

Welcome to the comprehensive Python commands reference for Arctos Studio Pro! This guide will help you understand and use all available Python functions to automate your robot operations, manipulate 3D models, control simulations, and much more.

Robot Movement Commands
Inverse Kinematics (IK) Commands
Program Control Commands
Connection Control Commands
Model Creation & Import Commands
Model Manipulation Commands
SVG Manipulation Commands
Pick and Place Commands
Simulation & View Commands
Physics & Simulation Commands
Conveyor Control Commands
Camera & Computer Vision Commands
Panel Control Commands
Scene & Object Querying Commands
Spatial Utility Commands
Multi-Robot Commands
Advanced Commands
Emergency Commands

Robot Movement Commands

`move_joints(joint_values, feed_rate=1000)`

Description: Moves the robot’s 6 controllable joints to specified absolute angles in degrees with smooth transition.

Parameters:

joint_values: List of 6 float values representing joint angles in degrees [J1, J2, J3, J4, J5, J6]
feed_rate: Movement speed (default: 1000)

Examples:

# Move all joints to specific angles
move_joints([90, 0, -45, 0, 90, 0])

# Alternative syntax with individual arguments
move_joints(90, 0, -45, 0, 90, 0)

# Move with custom feed rate
move_joints([45, 30, -30, 0, 60, 0], 2000)

`set_gripper(position)`

Description: Sets the gripper position.

Parameters:

position: Integer value (0 = fully open, 100 = fully closed)

Examples:

set_gripper(0)    # Open gripper completely
set_gripper(50)   # Half-closed gripper
set_gripper(100)  # Close gripper completely

`go_to_zero()`

Description: Moves all controllable joints to 0 degrees with smooth transition.

Examples:

go_to_zero()  # Reset robot to home position

`reset_axes()`

Description: Resets the robot’s coordinate system (GRBL internal state).

Examples:

reset_axes()  # Reset coordinate system

`get_joint_values()`

Description: Returns the current angles of the 6 controllable joints in degrees.

Returns: List of 6 float values [J1, J2, J3, J4, J5, J6]

Examples:

current_joints = get_joint_values()
print(f"Current joint angles: {current_joints}")

# Use current values for calculations
if current_joints[0] > 45:
    print("First joint is beyond 45 degrees")

Inverse Kinematics (IK) Commands

`translate_ik(x, y, z)`

Description: Moves the end-effector to target position (x, y, z) in meters with smooth transition, keeping current orientation.

Parameters:

x, y, z: Target position coordinates in meters

Examples:

translate_ik(0.3, 0.1, 0.2)  # Move to specific world position
translate_ik(0.25, 0, 0.15)  # Move above center

`rotate_ik(rx, ry, rz)`

Description: Rotates the end-effector by Euler angles in degrees with smooth transition, keeping current position.

Parameters:

rx, ry, rz: Rotation angles in degrees (XYZ Euler angles)

Examples:

rotate_ik(0, 0, 45)   # Rotate 45 degrees around Z-axis
rotate_ik(90, 0, 0)   # Rotate 90 degrees around X-axis

`move_ee_to_world_pose(target_position, target_orientation_matrix)`

Description: Moves end-effector to specific position AND orientation in world coordinates.

Parameters:

target_position: List [x, y, z] in meters
target_orientation_matrix: 3×3 list of lists representing target orientation

Examples:

# Move to position with specific orientation
target_pos = [0.2, 0.0, 0.1]
target_orient = [[0.0, 0.0, 1.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]
move_ee_to_world_pose(target_pos, target_orient)

Relative Movement Patterns

Description: For relative movements like “move left” or “move down”.

Examples:

# Move left by 0.1 meters
current_pos = get_translation()
new_pos = [current_pos[0] - 0.1, current_pos[1], current_pos[2]]
translate_ik(new_pos[0], new_pos[1], new_pos[2])

# Move down by 0.05 meters
current_pos = get_translation()
new_pos = [current_pos[0], current_pos[1], current_pos[2] - 0.05]
translate_ik(new_pos[0], new_pos[1], new_pos[2])

Program Control Commands

`record_target()`

Description: Records the current robot pose (joints + gripper) as a new target in the sequence.

Examples:

# Move to desired position first, then record
move_joints([45, 0, -30, 0, 75, 0])
set_gripper(0)
record_target()  # Save this position as a target

`run_program()`

Description: Executes the loaded program sequence with transitions.

Examples:

run_program()  # Execute all recorded targets in sequence

`stop_program()`

Description: Stops the currently running program.

Examples:

stop_program()  # Emergency stop for running program

`save_program()` / `load_program()`

Description: Save or load program using file dialog.

Examples:

save_program()  # Opens file dialog to save current program
load_program()  # Opens file dialog to load a program

`save_program_as(filepath)` / `load_program_as(filepath)`

Description: Save or load program to/from specific file path.

Parameters:

filepath: String path to the program file

Examples:

save_program_as('my_pick_place.rp')
load_program_as('assembly_sequence.rp')

`clear_all_targets()`

Description: Removes all targets from the program sequence.

Examples:

clear_all_targets()  # Start fresh program sequence

`get_program_data()` / `set_program_data(program_dict)`

Description: Get or set the entire program sequence data.

Examples:

# Backup current program
program_backup = get_program_data()

# Restore program from backup
set_program_data(program_backup)

Connection Control Commands

`connect_robot()` / `disconnect_robot()`

Description: Connect to or disconnect from the robot.

Examples:

connect_robot()     # Establish connection
disconnect_robot()  # Close connection

`refresh_ports()`

Description: Refreshes the list of available serial ports.

Examples:

refresh_ports()  # Update available port list

`set_feed_rate(rate)`

Description: Sets the feed rate (speed) for robot movements.

Parameters:

rate: Integer speed value

Examples:

set_feed_rate(2000)  # Set high speed
set_feed_rate(500)   # Set slow speed for precision

Model Creation & Import Commands

`create_box(x, y, z, width, height, depth)`

Description: Creates a box mesh and immediately positions it at specified coordinates.

Parameters:

x, y, z: Center position in meters
width, height, depth: Box dimensions in meters

Examples:

create_box(0.1, 0, 0, 0.05, 0.05, 0.05)  # Small cube
create_box(0.2, 0.1, 0.025, 0.1, 0.05, 0.05)  # Rectangular box

`create_cylinder(x, y, z, radius, height)`

Description: Creates a cylinder mesh and positions it at specified coordinates.

Parameters:

x, y, z: Center position in meters
radius: Cylinder radius in meters
height: Cylinder height in meters

Examples:

create_cylinder(0, 0.1, 0, 0.03, 0.1)  # Thin cylinder
create_cylinder(0.15, 0, 0.05, 0.025, 0.1)  # Positioned cylinder

`create_line(x1, y1, z1, x2, y2, z2)`

Description: Creates a line mesh between two points.

Parameters:

x1, y1, z1: Start point coordinates in meters
x2, y2, z2: End point coordinates in meters

Examples:

create_line(0, 0, 0, 0.2, 0.2, 0.2)  # Diagonal line
create_line(0.1, 0, 0, 0.1, 0, 0.1)  # Vertical line

`import_stl(filepath)`

Description: Imports an STL model into the scene.

Parameters:

filepath: String path to the STL file

Examples:

import_stl('models/part.stl')
import_stl('library/Models/Box.stl')

`import_svg(filepath)`

Description: Loads an SVG file for path following operations.

Parameters:

filepath: String path to the SVG file

Examples:

import_svg('drawings/logo.svg')
import_svg('library/Drawings/arctos.svg')

Model Manipulation Commands

`list_models()`

Description: Lists all loaded STL models with their index and name.

Returns: List of dictionaries with ‘index’ and ‘name’ keys

Examples:

models = list_models()
print(f"Available models: {models}")

# Find a specific model
for model in models:
    if 'box' in model['name'].lower():
        print(f"Found box at index {model['index']}")

`select_model(index_or_name)`

Description: Selects an STL model by index or name for subsequent operations.

Parameters:

index_or_name: Integer index or string name

Examples:

select_model(0)          # Select first model
select_model('my_box')   # Select by name

`translate_model(x, y, z, index_or_name=None)`

Description: Translates the specified or selected STL model by the given vector.

Parameters:

x, y, z: Translation vector in meters
index_or_name: Optional model identifier

Examples:

# Translate selected model
select_model(0)
translate_model(0.01, 0, 0)  # Move 1cm in X direction

# Translate specific model directly
translate_model(0.05, 0.02, 0, 'my_part')

`rotate_model(rx, ry, rz, index_or_name=None)`

Description: Rotates the specified or selected STL model by Euler angles.

Parameters:

rx, ry, rz: Rotation angles in degrees
index_or_name: Optional model identifier

Examples:

# Rotate selected model
select_model('cylinder')
rotate_model(0, 0, 90)  # Rotate 90 degrees around Z

# Rotate specific model directly
rotate_model(45, 0, 0, 0)  # Rotate first model 45 degrees around X

`scale_model(sx, sy, sz, index_or_name=None)`

Description: Scales the specified or selected STL model by given factors.

Parameters:

sx, sy, sz: Scale factors for each axis
index_or_name: Optional model identifier

Examples:

# Scale selected model
select_model('my_box')
scale_model(1.5, 1.5, 1.0)  # Make 50% larger in X and Y

# Uniform scaling
scale_model(2, 2, 2, 'small_part')  # Double the size

`color_model(color_name, index_or_name=None)`

Description: Changes the color of the specified or selected STL model.

Parameters:

color_name: String color name (e.g., ‘red’, ‘blue’, ‘green’)
index_or_name: Optional model identifier

Examples:

# Color selected model
select_model(0)
color_model('red')

# Color specific model
color_model('blue', 'my_cylinder')

`delete_model(index_or_name)`

Description: Deletes an STL model by index or name.

Examples:

delete_model('old_part')
delete_model(2)

`clear_models()`

Description: Deletes all loaded STL models.

Examples:

clear_models()  # Remove all models from scene

SVG Manipulation Commands

`list_svgs()`

Description: Lists all loaded SVGs with index and name.

Examples:

svgs = list_svgs()
print(f"Available SVGs: {svgs}")

`select_svg(index_or_name)`

Description: Selects an SVG by index or name for operations.

Examples:

select_svg(0)
select_svg('my_drawing')

`translate_svg(x, y, z)`

Description: Sets the absolute position of the selected SVG.

Examples:

select_svg('logo')
translate_svg(0.1, 0.1, 0)  # Position SVG in scene

`rotate_svg(rx, ry, rz)`

Description: Sets the absolute rotation of the selected SVG.

Examples:

select_svg(0)
rotate_svg(0, 0, 90)  # Rotate 90 degrees

`scale_svg(sx, sy, sz)`

Description: Sets the absolute scale of the selected SVG.

Examples:

select_svg('drawing')
scale_svg(2, 2, 1)  # Double size in X and Y

Pick and Place Commands

`pick_object()`

Description: Attaches the selected STL model to the robot’s gripper.

Examples:

# Complete pick operation
select_model('cup')
translate_ik(0.2, 0.1, 0.05)  # Move above object
translate_ik(0.2, 0.1, 0.02)  # Move down to object
set_gripper(80)  # Close gripper
pick_object()    # Attach object to gripper
translate_ik(0.2, 0.1, 0.1)   # Lift object

`place_object()`

Description: Detaches the object currently held by the gripper.

Examples:

# Complete place operation
translate_ik(0.3, 0.0, 0.05)  # Move to place location
place_object()  # Detach object
set_gripper(0)  # Open gripper
translate_ik(0.3, 0.0, 0.1)   # Move away

Simulation & View Commands

`get_end_effector_pose()`

Description: Returns the 4×4 transformation matrix of the end effector.

Returns: 4×4 numpy array or None

Examples:

pose = get_end_effector_pose()
if pose is not None:
    position = pose[:3, 3]  # Extract position
    print(f"End effector position: {position}")

`get_translation()`

Description: Returns current end-effector position as [x, y, z] in meters.

Examples:

pos = get_translation()
print(f"Current position: X={pos[0]:.3f}, Y={pos[1]:.3f}, Z={pos[2]:.3f}")

`get_rotation()`

Description: Returns current end-effector rotation as [rx, ry, rz] in degrees.

Examples:

rot = get_rotation()
print(f"Current rotation: RX={rot[0]:.1f}, RY={rot[1]:.1f}, RZ={rot[2]:.1f}")

`add_target_marker(x, y, z, name="Script Target")`

Description: Adds a visual marker at specified coordinates.

Examples:

add_target_marker(0.3, 0, 0.2, 'Goal Point')
add_target_marker(0.1, 0.1, 0.05, 'Pick Location')

`clear_target_markers()`

Description: Removes all visual markers.

Examples:

clear_target_markers()  # Clean up all markers

`set_view(view_name)`

Description: Changes the camera view.

Parameters:

view_name: String (‘top’, ‘front’, ‘side’, ‘iso’)

Examples:

set_view('top')    # Top-down view
set_view('iso')    # Isometric view
set_view('front')  # Front view

`toggle_collision_checking()`

Description: Toggles real-time collision checking.

Examples:

toggle_collision_checking()  # Enable/disable collision detection

`toggle_targets_visibility()`

Description: Shows/hides program target markers.

Examples:

toggle_targets_visibility()  # Show/hide target visualization

Physics & Simulation Commands

`toggle_physics(enabled)`

Description: Enables or disables physics simulation.

Parameters:

enabled: Boolean value

Examples:

toggle_physics(True)   # Enable physics
toggle_physics(False)  # Disable physics

`reset_simulation()`

Description: Resets physics simulation state.

Examples:

reset_simulation()  # Reset all physics objects

`apply_force(index_or_name, force, position=None)`

Description: Applies force vector to an object.

Parameters:

index_or_name: Object identifier
force: List [fx, fy, fz] force vector
position: Optional application point [x, y, z]

Examples:

# Apply upward force to object
apply_force('my_box', [0, 0, 10])

# Apply force at specific point
apply_force(0, [5, 0, 0], [0, 0, 0.05])

`get_physics_state(index_or_name)`

Description: Gets physics state of an object.

Examples:

state = get_physics_state('my_box')
if state:
    print(f"Object velocity: {state.get('velocity', 'N/A')}")

Conveyor Control Commands

`set_conveyor_power(enabled)`

Description: Turns conveyor belt motor on or off.

Parameters:

enabled: Boolean value

Examples:

set_conveyor_power(True)   # Start conveyor
set_conveyor_power(False)  # Stop conveyor

`set_conveyor_speed(speed)`

Description: Sets conveyor belt speed.

Parameters:

speed: Float speed value

Examples:

set_conveyor_speed(0.1)   # Slow speed
set_conveyor_speed(0.5)   # Medium speed

`add_conveyor_belt()`

Description: Adds a default conveyor belt to the scene.

Examples:

add_conveyor_belt()  # Add conveyor if none exists

`toggle_conveyor_bounds(visible=None)`

Description: Shows/hides conveyor bounding box.

Examples:

toggle_conveyor_bounds(True)   # Show bounds
toggle_conveyor_bounds(False)  # Hide bounds
toggle_conveyor_bounds()       # Toggle current state

Camera & Computer Vision Commands

`list_available_cameras()`

Description: Returns list of available camera names/IDs.

Examples:

cameras = list_available_cameras()
print(f"Available cameras: {cameras}")

`select_camera(cam_idx)`

Description: Selects a camera by index.

Examples:

select_camera(0)  # Select first camera
select_camera(1)  # Select second camera

`start_real_camera()` / `stop_real_camera()`

Description: Start or stop real camera feed.

Examples:

start_real_camera()  # Begin camera feed
stop_real_camera()   # End camera feed

`show_sim_camera()`

Description: Switch to simulated camera feed.

Examples:

show_sim_camera()  # Use simulation camera

`toggle_cv(enable)`

Description: Enable/disable computer vision processing.

Parameters:

enable: Boolean value

Examples:

toggle_cv(True)   # Enable CV processing
toggle_cv(False)  # Disable CV processing

`set_cv_color(color_name)`

Description: Sets target color for CV detection.

Parameters:

color_name: String color name

Examples:

set_cv_color('red')    # Detect red objects
set_cv_color('blue')   # Detect blue objects
set_cv_color('green')  # Detect green objects

`set_cv_shape(shape_name)`

Description: Sets target shape for CV detection.

Parameters:

shape_name: String shape name

Examples:

set_cv_shape('Box')      # Detect boxes
set_cv_shape('Circle')   # Detect circles
set_cv_shape('Any Shape') # Detect any shape

`get_detected_object()`

Description: Returns description of last detected object.

Returns: String description or empty string

Examples:

obj = get_detected_object()
if obj:
    print(f"Detected: {obj}")
    if obj.startswith("Red Box"):
        print("Found a red box!")
else:
    print("No object detected")

Panel Control Commands

`toggle_conveyor_panel()`

Description: Toggle conveyor control panel visibility.

`toggle_camera_panel()`

Description: Toggle camera control panel visibility.

`toggle_library_panel()`

Description: Toggle model library panel visibility.

`toggle_python_panel()`

Description: Toggle Python scripting panel visibility.

Examples:

toggle_camera_panel()    # Show/hide camera controls
toggle_library_panel()   # Show/hide model library
toggle_python_panel()    # Show/hide Python console

Scene & Object Querying Commands

`list_all_scene_objects()`

Description: Returns list of all objects in the scene with detailed information.

Returns: List of dictionaries with object details

Examples:

all_objects = list_all_scene_objects()
print(f"Scene contains {len(all_objects)} objects")

# Find objects by type
boxes = [obj for obj in all_objects if 'box' in obj['name'].lower()]
print(f"Found {len(boxes)} boxes in scene")

`get_stl_model_details(name_or_index)`

Description: Returns detailed information for an STL model.

Examples:

details = get_stl_model_details('my_box')
if details:
    pos = details['position']
    print(f"Box position: {pos}")
    bounds = details['bounds_world_min']
    print(f"Box bounds min: {bounds}")

`find_object_by_keyword(keyword)`

Description: Searches scene objects by keyword in name.

Examples:

box = find_object_by_keyword('box')
if box:
    print(f"Found box: {box['name']} at {box['position']}")

Spatial Utility Commands

`get_object_dimensions(obj_details)`

Description: Calculates object dimensions from details.

Returns: Dictionary with ‘width’, ‘depth’, ‘height’

Examples:

obj = find_object_by_keyword('box')
if obj:
    dims = get_object_dimensions(obj)
    print(f"Box size: {dims['width']} x {dims['depth']} x {dims['height']}")

`calculate_front_placement_target(robot_details, obj_details, distance)`

Description: Calculates position to place object in front of robot.

Examples:

robot = get_robot_base_transform()
obj = find_object_by_keyword('part')
target = calculate_front_placement_target(robot, obj, 0.2)
if target:
    translate_ik(target['x'], target['y'], target['z'])

`calculate_stacking_target(obj_on_top, obj_below)`

Description: Calculates position to stack one object on another.

Examples:

bottom_box = find_object_by_keyword('base')
top_box = find_object_by_keyword('small')
stack_pos = calculate_stacking_target(top_box, bottom_box)
if stack_pos:
    # Move top box to stacking position
    select_model(top_box['name'])
    translate_model(stack_pos['x'], stack_pos['y'], stack_pos['z'])

Multi-Robot Commands

`add_robot(x, y, z, r)`

Description: Adds a visual duplicate robot at specified position and rotation.

Parameters:

x, y: 2D offset for robot base
z: Z offset (currently not used in graphics)
r: Rotation in degrees around Z-axis

Examples:

add_robot(0.5, 0, 0, 0)    # Add robot 0.5m to the right
add_robot(0, 0.5, 0, 90)   # Add robot 0.5m forward, rotated 90°

`select_robot(index)`

Description: Selects which robot to control.

Parameters:

index: 0 for main robot, 1+ for duplicates

Examples:

select_robot(0)  # Control main robot
select_robot(1)  # Control first duplicate
select_robot(2)  # Control second duplicate

`clear_duplicate_robots()`

Description: Removes all duplicate robots.

Examples:

clear_duplicate_robots()  # Remove all duplicates, keep main robot

Advanced Commands

`follow_svg_path()`

Description: Makes robot follow the selected SVG path.

Examples:

# Complete SVG following sequence
import_svg('drawings/circle.svg')
select_svg(0)
translate_svg(0.2, 0, 0)  # Position SVG in workspace
follow_svg_path()         # Execute path following

`open_3d_printing_dialog()`

Description: Opens 3D printing dialog for selected model.

Examples:

select_model('printable_part')
open_3d_printing_dialog()

`with_transition(movement_func, *args, total_steps=20, step_time=0.005)`

Description: Adds smooth transitions to any movement command.

Parameters:

movement_func: Function to execute with transition
total_steps: Number of interpolation steps
step_time: Time per step in seconds

Examples:

# Smooth movement with custom parameters
with_transition(translate_ik, 0.3, 0.1, 0.2, total_steps=50, step_time=0.01)

# Smooth joint movement
with_transition(move_joints, [45, 0, -30, 0, 90, 0], total_steps=30)

Emergency Commands

`stop()`

Description: Comprehensive emergency stop – halts ALL operations including robot programs, AI operations, physics simulations, hardware movements, and Python threads.

Examples:

stop()  # EMERGENCY STOP - halt everything immediately

What it stops:

Robot programs and movements
AI controller operations
Physics simulations
Hardware operations
Conveyor belts
PLC operations
All running timers
Background Python threads

Advanced Object Finding Commands

`find_object_robust(description)`

Description: AI-powered robust object finding using natural language descriptions.

Examples:

obj = find_object_robust("red box")
obj = find_object_robust("the cylinder on the left")
obj = find_object_robust("biggest object")

`get_object_by_color_and_type(color, object_type='box')`

Description: Find objects by specific color and type combination.

Examples:

red_box = get_object_by_color_and_type('red', 'box')
blue_cylinder = get_object_by_color_and_type('blue', 'cylinder')

`ensure_object_exists(color='red', object_type='box', position_x=0.25, position_y=0.0, position_z=0.025)`

Description: Finds existing object or creates new one if none exists.

Examples:

# Ensure there's a red box in the scene
red_box = ensure_object_exists('red', 'box', 0.2, 0.1, 0.025)

# Ensure there's a blue cylinder
blue_cyl = ensure_object_exists('blue', 'cylinder', 0.3, 0, 0.05)

Practical Examples

Complete Pick and Place Sequence

# Setup
connect_robot()
go_to_zero()

# Create objects
create_box(0.2, 0.1, 0.025, 0.05, 0.05, 0.05)  # Source box
color_model('red', 0)  # Make it red

# Pick sequence
translate_ik(0.2, 0.1, 0.1)    # Move above object
translate_ik(0.2, 0.1, 0.025)  # Move down to object
set_gripper(80)                # Close gripper
pick_object()                  # Attach object
translate_ik(0.2, 0.1, 0.1)    # Lift object

# Place sequence  
translate_ik(0.3, 0, 0.1)      # Move to place location
translate_ik(0.3, 0, 0.025)    # Move down
place_object()                 # Detach object
set_gripper(0)                 # Open gripper
translate_ik(0.3, 0, 0.1)      # Move away

# Cleanup
go_to_zero()
disconnect_robot()

Multi-Robot Coordination

# Add multiple robots
add_robot(0.5, 0, 0, 0)    # Robot 1 to the right
add_robot(-0.5, 0, 0, 0)   # Robot 2 to the left

# Control Robot 1
select_robot(1)
move_joints([45, 0, 0, 0, 0, 0])

# Control Robot 2  
select_robot(2)
move_joints([-45, 0, 0, 0, 0, 0])

# Return to main robot
select_robot(0)
go_to_zero()

Computer Vision Integration

# Setup camera and CV
toggle_camera_panel()
start_real_camera()
toggle_cv(True)
set_cv_color('red')
set_cv_shape('Box')

# Wait for detection and pick up
import time
while True:
    obj = get_detected_object()
    if 'Red Box' in obj:
        print("Red box detected!")
        # Add pick and place logic here
        break
    time.sleep(0.1)

Tips and Best Practices

Always check return values – Many functions return None or False on failure
Use smooth transitions – The with_transition() wrapper makes movements smoother
Position objects safely – Keep objects within robot’s reach (typically 0.1-0.4m from base)
Check connections – Use connect_robot() before sending movement commands
Handle errors gracefully – Wrap critical operations in try-except blocks
Use emergency stop – The stop() command halts all operations immediately
Coordinate multi-robot operations – Always select_robot() before sending commands
Test in simulation first – Use physics simulation to verify sequences before real robot operation

This comprehensive reference covers all available Python commands in Arctos Studio Pro. Each command is designed to work seamlessly with the robot control system, 3D simulation environment, and various hardware components. Use these commands to create powerful automation sequences, interactive demonstrations, and complex robotic applications.

For more advanced usage and integration examples, refer to the AI controller documentation and the API reference guide.

Common Issues and Solutions

Robot Not Responding:

Check communication port settings
Verify robot power and connections
Ensure correct robot version is selected
Check for emergency stop activation

Simulation Performance Issues:

Reduce scene complexity
Lower physics simulation quality
Close unnecessary panels
Check system resource usage

Vision System Problems:

Verify camera connection
Check lighting conditions
Calibrate camera if needed
Update vision model if objects aren’t detected

Python Script Errors:

Check syntax highlighting for errors
Verify all required modules are imported
Use try-catch blocks for error handling
Check the console for detailed error messages

Known issues / Future updates

Things that are not fully working, or need better implementations:

Rotate: resets the object rotation when clicked
3D print layer preview: hides all layers when previwed (should highlight only the selected layer)
Follow lines: needs a target density adjuster to fine tune the number of targets
Follow SVG: creating targets smaller than the image
Gripper: needs full urdf for each gripper added to be able to open/close gripper. Needs more grippers in a library
Gripper settings: needs a fix for gcode commands
GRBL settings: loading grbl settings needs a fix
Sensors: needs full implementation with the working logic and hardware
Duplicate robot: needs hardware implementation
Depth camera: needs other brands implemented other than Kinect v1
PLC: needs hardware implementation with Arduino PLC
Gym: Plot last results needs a visualization
Joystick: throws an error to enable even if fully working
Help: button needs to point to this page

Community and Learning Resources

Online Communities

Discord Server: Real-time chat with the community and development team.
YouTube Channel: Video tutorials and project showcases.
GitHub Repository: Access example code and contribute to open-source projects.

Conclusion

Arctos Studio Pro is built to support your journey in robotics, from simple automation tasks to advanced AI-powered systems. Whether you are fine-tuning motion paths or experimenting with intelligent control, the software gives you the tools and flexibility to learn, iterate, and grow.

This is not just about building robots. It is about learning by doing. Start small, explore the features, and do not be afraid to try bold ideas. The simulation environment allows you to test safely without risking real hardware.

We are constantly improving Arctos Studio Pro, fixing bugs, and adding new features based on your feedback. Like any software, it is not perfect. There may be occasional bugs or glitches, and we are always working to make it better.

Important note: Arctos Studio Pro is not a certified or professional-grade software. It is intended for educational and experimental use only, not for industrial use. We are not responsible for any damage, loss, or malfunction resulting from the use of this software in physical systems. Use it at your own risk and always test thoroughly before applying it to real-world hardware.

We look forward to seeing what you create. Share your projects, help others in the community, and be part of shaping the future of accessible robotics.

Thank you for using Arctos Studio Pro. Now go build something amazing.

For the latest updates, tutorials, and community discussions, visit our website and join our growing community of robotics innovators.

Arctos Studio Pro User Guide

Table of Contents

Introduction

What’s New in Arctos Studio Pro?

Getting Started

System Requirements

Installation

First Run and Logging In

Interface Overview

The Ribbon Menu

The 3D Viewer

The Program Tree

Robot Connection and Basic Control

Connecting to a Robot

Basic Robot Control Methods

1. Joint & IK Control Panel

2. End Effector Control (IK)

Program Creation and Execution

Recording Targets

Editing the Program

Program Parameters

Direct Control vs. Simulation

Running and Stopping a Program

Saving and Loading Programs

Scene and Object Manipulation

Importing 3D Models (STL)

Creating Primitive Shapes and Lines

Modifying Objects (The “Modify” Tools)

Physics Simulation

Conveyor Belts and PLC

Working with Conveyor Belts

The PLC Editor

Advanced Trajectory and Path Following

3D Printing (Slicing)

Slicing Parameters Explained

Advanced Slicing Options (Experimental)

Welding

Reinforcement Learning

Setting Up RL Training

Training Process

Python Scripting – with Examples

Arctos Studio Pro – Python Commands Reference

Table of Contents

Robot Movement Commands

move_joints(joint_values, feed_rate=1000)

set_gripper(position)

go_to_zero()

reset_axes()

get_joint_values()

Inverse Kinematics (IK) Commands

translate_ik(x, y, z)

rotate_ik(rx, ry, rz)

move_ee_to_world_pose(target_position, target_orientation_matrix)

Relative Movement Patterns

Program Control Commands

record_target()

run_program()

stop_program()

save_program() / load_program()

save_program_as(filepath) / load_program_as(filepath)

clear_all_targets()

get_program_data() / set_program_data(program_dict)

Connection Control Commands

connect_robot() / disconnect_robot()

refresh_ports()

set_feed_rate(rate)

Model Creation & Import Commands

create_box(x, y, z, width, height, depth)

create_cylinder(x, y, z, radius, height)

create_line(x1, y1, z1, x2, y2, z2)

import_stl(filepath)

import_svg(filepath)

Model Manipulation Commands

list_models()

select_model(index_or_name)

translate_model(x, y, z, index_or_name=None)

rotate_model(rx, ry, rz, index_or_name=None)

scale_model(sx, sy, sz, index_or_name=None)

color_model(color_name, index_or_name=None)

delete_model(index_or_name)

`move_joints(joint_values, feed_rate=1000)`

`set_gripper(position)`

`go_to_zero()`

`reset_axes()`

`get_joint_values()`

`translate_ik(x, y, z)`

`rotate_ik(rx, ry, rz)`

`move_ee_to_world_pose(target_position, target_orientation_matrix)`

`record_target()`

`run_program()`

`stop_program()`

`save_program()` / `load_program()`

`save_program_as(filepath)` / `load_program_as(filepath)`

`clear_all_targets()`

`get_program_data()` / `set_program_data(program_dict)`

`connect_robot()` / `disconnect_robot()`

`refresh_ports()`

`set_feed_rate(rate)`

`create_box(x, y, z, width, height, depth)`

`create_cylinder(x, y, z, radius, height)`

`create_line(x1, y1, z1, x2, y2, z2)`

`import_stl(filepath)`

`import_svg(filepath)`

`list_models()`

`select_model(index_or_name)`

`translate_model(x, y, z, index_or_name=None)`

`rotate_model(rx, ry, rz, index_or_name=None)`

`scale_model(sx, sy, sz, index_or_name=None)`

`color_model(color_name, index_or_name=None)`

`delete_model(index_or_name)`

`clear_models()`

`list_svgs()`

`select_svg(index_or_name)`

`translate_svg(x, y, z)`

`rotate_svg(rx, ry, rz)`

`scale_svg(sx, sy, sz)`

`pick_object()`

`place_object()`

`get_end_effector_pose()`

`get_translation()`

`get_rotation()`

`add_target_marker(x, y, z, name="Script Target")`

`clear_target_markers()`

`set_view(view_name)`

`toggle_collision_checking()`

`toggle_targets_visibility()`

`toggle_physics(enabled)`

`reset_simulation()`

`apply_force(index_or_name, force, position=None)`

`get_physics_state(index_or_name)`

`set_conveyor_power(enabled)`

`set_conveyor_speed(speed)`

`add_conveyor_belt()`

`toggle_conveyor_bounds(visible=None)`

`list_available_cameras()`

`select_camera(cam_idx)`

`start_real_camera()` / `stop_real_camera()`

`show_sim_camera()`

`toggle_cv(enable)`

`set_cv_color(color_name)`

`set_cv_shape(shape_name)`

`get_detected_object()`

`toggle_conveyor_panel()`

`toggle_camera_panel()`

`toggle_library_panel()`

`toggle_python_panel()`

`list_all_scene_objects()`

`get_stl_model_details(name_or_index)`

`find_object_by_keyword(keyword)`

`get_object_dimensions(obj_details)`

`calculate_front_placement_target(robot_details, obj_details, distance)`

`calculate_stacking_target(obj_on_top, obj_below)`

`add_robot(x, y, z, r)`

`select_robot(index)`

`clear_duplicate_robots()`

`follow_svg_path()`

`open_3d_printing_dialog()`

`with_transition(movement_func, *args, total_steps=20, step_time=0.005)`

`stop()`

`find_object_robust(description)`