Welcome to the Complementary Community Guide for the Arctos robot arm! This document is an additional resource to the existing assembly manual, specifically designed to compile and organize valuable information currently scattered across our dedicated Discord channel. It represents our best efforts to capture essential insights, additional instructions, and tips not fully covered in the official manual.

While this guide aims to be comprehensive, it may not encompass all possible details and nuances of the project. It is a living document reflective of our community members’ collective knowledge and ongoing discoveries. As such, we openly encourage contributions from all participants. Whether it’s a new workaround, a better explanation of a complex concept, or a freshly encountered issue, your insights are invaluable in enriching this guide and aiding your fellow builders.

Please use this guide as a supplement to the official assembly manual. It is crafted to clarify, enhance, and expand upon the provided information, ensuring you have a well-rounded understanding of every aspect of the project. Your active participation and contributions will help improve this guide and support the community in building more effective and efficient robot arms.

Community Guidelines

To ensure our community remains a welcoming and productive environment for all members, we ask that you adhere to the following guidelines:

  • Respect and Inclusivity: Treat all community members equally, regardless of their skill level or background. Encourage and support your fellow members, and celebrate our diverse perspectives and contributions.
  • Collaboration Over Competition: While building the robot arm may present challenges, we encourage collaboration and collective problem-solving. Share your experiences, tips, and resources generously.
  • Safety First: Always prioritize safety when engaging in assembly and testing. Follow all recommended safety procedures detailed in this guide, and do not hesitate to ask for advice if you are unsure.
  • Constructive Feedback: When providing feedback, whether on design choices or documentation, please be constructive. Aim to provide solutions or improvements rather than just criticisms.
  • Integrity and Honesty: Be honest about your progress and challenges. Sharing both your successes and difficulties helps improve everyone’s learning process.

Let’s build a robot arm and a vibrant community of passionate learners and makers.

How to contribute

Our community thrives on the active participation and contributions of its members. As we have yet to designate official community leaders or moderators, the review and integration of contributions into this guide will be managed on a best-effort basis by the community itself. Here’s how you can contribute:

Using Comments:

  1. Select the text or section you want to comment on.
  2. Right-click and choose Comment from the context menu, or use the comment icon in the toolbar.
  3. Type your comment in the box on the document’s right side. Be as specific as possible, explaining your suggestion or the correction needed.
  4. Post the comment by clicking the comment button. Your comment will now be visible to all viewers and editors of the document, who can discuss and consider the proposed changes.

Using Suggestion Mode:

  1. Turn on Suggestion mode by clicking on the pencil icon in the upper right corner of the Google Docs interface and selecting Suggesting from the drop-down menu.
  2. Make edits directly in the text of the document. Your changes will appear as suggestions that do not alter the original text but are visible to all collaborators.
  3. Each suggestion can be accepted, rejected, or further discussed by anyone with editing access to the document. This method is especially useful for proposing rewrites or additional content.

Review Process:

Until we have official community leaders or moderators, active community members will collectively review all contributions made through comments and suggestions. We encourage everyone to participate in reviewing suggestions to ensure that the document remains accurate and helpful.

Stay Informed:

We recommend regularly checking the document to see new contributions and ongoing discussions. Your engagement is crucial for maintaining the quality and relevance of this guide.

We value your knowledge and experiences and invite you to help us enhance this guide. Contributing ensures that our guide remains a dynamic, community-driven resource.

Project Overview

This project has two versions: the Open Loop and the recent Closed Loop versions. Both versions aim to provide a rich learning and building experience but differ in complexity and functionality.

Open Loop Version: This is the original version of the project, which operates without feedback to control the position and movement of the robot arm. It is simpler and may suit beginners or those interested in basic robotics concepts.

Closed Loop Version: Introduced as an advancement of the Open Loop model, the Closed Loop version includes feedback mechanisms that allow for more precise control and positioning of the robot arm. This version utilizes sensors and advanced control systems to adjust the real-time movements, making it more complex and capable.

Due to its advanced features and recent development, this guide will focus primarily on the closed-loop version of the robot arm. It will provide detailed information and resources related to assembly, calibration, and operation. While both versions are supported by our community, the Closed Loop version represents the latest in our collaborative efforts to enhance the project’s capabilities.

Please note that as the Closed Loop version is the focus of recent updates and improvements, it will receive more attention in this guide. However, we welcome contributions and discussions related to both versions on our Discord channel, ensuring that all members can benefit from shared knowledge and experience.



  • Number of degrees of freedom: 6
  • Max reach: 600 mm
  • Payload capacity: 500 g (v1) 1.3 kg max (v2)
  • Electronics: Integrated Arduino-based system located in the base
  • Software compatibility: RoboDK, GrblGru, Robot Overlord, Matlab, ROS, Unity (in progress)
  • Applications: Suitable for education, pick-and-place tasks, and automation purposes

Work envelope

Axes nomenclature
Name – joint name – link name – CAN ID
  • X – joint1- Link_1_1 – 01
  • Y – joint2- Link_2_1 – 02
  • Z – joint3 – Link_3_1- 03
  • A – joint4- Link_4_1 – 04
  • B – joint5- Link_5_1 – 07
  • C – joint6- Link_6_1 – 06

Denavit-Hartenberg parameters

Gear ratios













If you don’t have better, use these:

Print settings

Before printing it’s good to have test_print.stl and check if the hardware parts are fitting well with printed parts. IF not change print settings, or parameteres for bearings inside Fusion 360 file. There the clearance can be adjusted.
Many holes are meant to have tight fit with the bolts.




215 °

Layer height


Extrusion width


Infill percentage

Lorem ipsum dolor sit amet, consec tetur adipiscing elit.

Wall count


Covers wall count


Top/Bottom layers


Allen key sizes

2.5, 3, 4, 6

Hand tools

Pliers, tweezers

Electric tools

Soltering iron, drill,


Philipps, flat

Additional items

superglue, deburring tool, hammer,

You better have:

PC, 3D printer and 4 kg of PLA

Hardware tools

Robot can be assembled with only hand tools. But since there are a lot of bolts, power tools might come handy.

Printing order

Parts nomenclature

  • Print from ground up. Axes are called X, Y, Z, A, B, C. So inside stl folder search for axis X and it will contain all parts for X axis. Follow the user manual and start the build.
  • For two tone refer to Fusion 360 file or sort stl files by: “cover” , “panel” , “pulley” and print them in accent color. Or search for “core” and print parts in second color.
  • Or get inspired in #showcase Discord channel.
  • There are 168 parts in total, some of them are copies (gears).
  • Part naming example:
  • Z R lower core (1)_1-Z R lower core-stl.stl
  • Z axis, Right (there is left), lower (there is uper), (1) means nothing, parts showing duplicate names because export plugin catches Component and Body names.
  • Safest way: Print gearboxes first, cover panels last

Parts orientation and supports

Always double check in slicer software if the part needs support. In many cases it does. Some of files are 6,7 hour long and realising that there are supports missing is not great experience. Remove supports with small flat screwdriver, pliers and utility knife. Orca slicer does a pretty good job with that border layer between walls and supports, so supports remove easily.

Bill of Materials (BOM)

Can be found here and contains 4 tabs: 0.2.6, 0.16.7, upgrade, printed parts. First tab is the latest v2, and second tab latest v1 hardware version. Hardware version 0.2.6 is compatible with CAD version. Upgrade tab contains upgrades from v1 to v2, and from v2.0 to latest. Printed parts contains earlier version part names and print order. BOM contains all parts (except tools, and printed parts) to assemble this robot. If not using kits double check the product version and quantity. You can use Aliexpress or Amazon to source kits.
NOTE: In v2 hardware kit there is no controller board for the gripper.

You can also source parts yourself. Mostly from old 3D printer, from hardware store. For example, use 1m m4 threaded rod and cut it yourself. Drywall ancher is exactly 4mm in diameter, and one 0.5$ piece which can be found anywhere locally can become 5-6 rods for cycloidal gearbox. Have bigger/smaller motors, different bearings – adapt cad file to your needs. Make a mod and post it, some folks have already done it.

Kit versions:

Open loop

Does not have feedback control.
More affordable
Less complicated to program
More wires, harder to connect

Closed loop

Have feedback control.
More expensive
More complicated to program
Less wires, easier to connect

Assembly Instructions

Version 0.1

PDF style assembly manual for initial versuion 0.1

Version 0.2

3D web viewer step-by-step based manual.

v – latest

3D web viewer step-by-step based manual.

NOTE: Steps not mentioned in manuals:

– Glue magnets on each stepper motors shaft
– Prepare wires of the MKS drivers, configure and calibrate before bolting them to robot.
– Install on/off switch and LED diode.
More info in the Wiring section.

More links:

For video tutorials refer to these links. Most of them are incomplete. But at least there are some good pointers. Also if you stuck use Discord for more help.

Wiring and Electronics

V1 Open loop:

Arduino + 2x CNC shields + 6x TMC2209

Here we are using grbl to run robot with G code. We can get g code by RoboDK postprocessor for Arctos 0.16.7 which outputs this format:

G90 X 0.00 Y 0.00 Z 0.00 A 0.00 B 0.00 C 0.00 

F800 – Feedrate (adapt by your needs)

G90 – Absolute coordinates – Unlike G91 (relative coordinates) it will for each toolpath generate coordinates based on zero position. That code have to be streamed to Arduino by Universal Gcode Sender or similar programs. Sending directly from console also works.
Diagram below shows how to connect everything together.


Keep in mind to use these small jumpers underneath each driver to jump M0, M1 and M2 wires.

Newer versions do not use IEC connector, but 12V DC female connector, because now the power supply is external and we don’t need to worry about AC . DiP1 switch is KCD1-101 which breaks (+) positive wire from the DC connector. Later along the way to cnc shields connect the 12V LED diode indicator and place it in Electronics panel.

Closed loop

CANable adapter v2 + 4x MKS Servo 42D + 2x MKS Servo 57D + 3x WSH231Dual hall effect + 6x KY 003 Limit switches

All components are daisy-chained from CANable adapter to C servo. So those two requires 120 Ohm resistor jumper wired. As shown bellow.

NOTE: Before bolting down the stepper motors make sure that all of the requiring wires are already connected to the MKS Servo drivers. If they are bolted there is no space to add them later on A, B and C axes.

Here we also use (not shown in diagram) 12V DC Female connector from Electronics panel + On/Off switch + LED diode. Same as in open loop version.

Configuring MKS drivers

Configure each MKS Servo driver to these settings. CAN ID – Axis: 01 – X, 02 – Y, 03 – Z, 04 – A, 05 – B, 06 – C.
Use this tool made by DavidD to mount magnet in the center shaft.

Additional encoders

We are trying to implement double closed loop system with MT6701 which works on SPI and I2C. Still no off the shelf hall effect sensor that works on CAN bus.


Wiring the gripper to Arduino

In order to control the gripper you have to connect the servo DS3225 to the Arduino. It should have 3 wires (red +, black – and white which is signal wire). Since Arduinos output voltage pins are already in use, you can use the voltage pins from CNC shield. They are located in top right corner marked as 5V and GND in yellow and blue colors (pic down there). Signal pin (white wire) should be connected to the pin 6 on Arduino Mega. If you connected the servo this way, you can control it by sending this command for example: M97 B40 T2 This will close the gripper from fully open to fully closed Some value explanation:

  • B value has range from 0-499, so to control the angle of the servo from 0 to 360 you should take the proportion into the account. So for each 1* angle B value should be 499/360 = 1.38

T is the time needed to complete the operation in seconds.

Gripper control over CAN bus is till not officially implemented and not included in kit. But there is our user Borris who made it by ESP32 Servo Gripper working via wireless command from PC browser controller.

Software setup

Arctos grbl

Flashing GRBL firmware to an Arduino is a process that involves uploading new software to the microcontroller on the board. In order to do this, you’ll need a few things:

  1. An Arduino MEGA 2560
  2. A USB cable to connect the board to your computer
  3. The GRBL firmware (which can be downloaded from this link). It has to be unzipped and zipped the grbl folder only.
  4. The Arduino IDE software (which can be downloaded from the official Arduino website)

Once you have these things, you can follow the steps below to flash the GRBL firmware to your Arduino:

Step 1: Install the Arduino IDE Software Download the Arduino IDE software and install it on your computer. Once the installation is complete, open the Arduino IDE.

Step 2: Connect the Arduino Board Connect your Arduino board to your computer using the USB cable.

Step 3: Select the Arduino Board Type In the Arduino IDE, go to the “Tools” menu and select “Board.” Choose the type of Arduino board you are using (such as “Arduino Uno” or “Arduino Nano”).

Step 4: Select the Serial Port In the same “Tools” menu, select “Port” and choose the serial port that your Arduino board is connected to. If you’re not sure which port to select, you can check the “Device Manager” on your computer to see which port the Arduino board is using.

Step 5: Open Arduino IDE. Select Sketch > Include Library > Add .zip library. When the window opens, go to the extracted folder, there’ll be another “grbl” folder inside. Select it. Click the File menu. Then go over to Examples > grbl > grbl upload. A new window of Arduino IDE will pop up.

Step 6: Upload the GRBL Firmware

You can upload it to your Arduino board. Click the “Upload” button in the Arduino IDE (it looks like an arrow pointing to the right) to upload the firmware to the board.

Step 8: Verify the Upload After the firmware has been uploaded, you can verify that it was successful by opening the Serial Monitor in the Arduino IDE. Make sure the baud rate is set to 115200, and you should see the GRBL welcome message appear in the monitor window.

Here are the default robot settings you can rewrite in ugs, or pronterface. You can also download it here and import it in Machine>Firmware>Import

$0 = 10 (Step pulse time, microseconds)
$1 = 255 (Step idle delay, milliseconds)
$2 = 0 (Step pulse invert, mask)
$3 = 0 (Step direction invert, mask)
$4 = 0 (Invert step enable pin, boolean)
$5 = 0 (Invert limit pins, boolean)
$6 = 0 (Invert probe pin, boolean)
$10 = 0 (Status report options, mask)
$11 = 0.010 (Junction deviation, millimeters)
$12 = 0.002 (Arc tolerance, millimeters)
$13 = 0 (Report in inches, boolean)
$20 = 0 (Soft limits enable, boolean)
$21 = 0 (Hard limits enable, boolean)
$22 = 0 (Homing cycle enable, boolean)
$23 = 0 (Homing direction invert, mask)
$24 = 200.000 (Homing locate feed rate, mm/min)
$25 = 200.000 (Homing search seek rate, mm/min)
$26 = 250 (Homing switch debounce delay, milliseconds)
$27 = 0.000 (Homing switch pull-off distance, millimeters)
$30 = 0 (Maximum spindle speed, RPM)
$31 = 5 (Minimum spindle speed, RPM)
$32 = 0 (Laser-mode enable, boolean)
$100 = 60.000 (X-axis travel resolution, step/mm)
$101 = 576.000 (Y-axis travel resolution, step/mm)
$102 = 450.000 (Z-axis travel resolution, step/mm)
$103 = 20.000
$104 = 40.000
$105 = 40.000
$110 = 7000.000 (X-axis maximum rate, mm/min)
$111 = 900.000 (Y-axis maximum rate, mm/min)
$112 = 9000.000 (Z-axis maximum rate, mm/min)
$113 = 9000.000
$114 = 9000.000
$115 = 9000.000
$120 = 150.000 (X-axis acceleration, mm/sec^2)
$121 = 150.000 (Y-axis acceleration, mm/sec^2)
$122 = 150.000 (Z-axis acceleration, mm/sec^2)
$123 = 150.000
$124 = 150.000
$125 = 150.000
$130 = 150.000 (X-axis maximum travel, millimeters)
$131 = 200.000 (Y-axis maximum travel, millimeters)
$132 = 150.000 (Z-axis maximum travel, millimeters)
$133 = 800.000
$134 = 800.000
$135 = 800.000

That’s it! You have successfully flashed the GRBL firmware to your Arduino board. You can now use the board to control


  1. Make sure you have ROS properly installed with a working workspace. This repository assumes ROS Melodic on Ubuntu 18.04, so make any necessary adjustments if you are using a different configuration. Place the ‘arctos_ros’ package in the ‘src’ directory of your catkin workspace.
  2. To plan and execute trajectories for the Arctos arm in simulation (using RVIZ with Moveit plugin), run the following terminal
  3. command
roslaunch arctos_config demo.launch
  1. Once the window loads, enable “Allow Approximate IK Solutions” in the bottom-left corner. Navigate to the “Planning” tab in the Motion Planning panel of RVIZ. You can set a new goal state by either dragging the interactive marker (the light blue ball at the end effector) or selecting one under “Select Goal State.” After updating the goal state, clicking “Plan and Execute” will generate and execute the trajectory from the start state to the updated goal state.

Controlling the Real Robot, Synchronized with the Simulated Arm’s Trajectories

  1. Make sure to download the AccelStepper library (AccelStepper Library Download) and the ros_lib library (rosserial-arduino tutorial) in your Arduino development environment.
    • If you already have the ros_lib library in your Arduino libraries directory (/libraries), follow the last troubleshooting tip to avoid errors related to “ArmJointState.h”. ROS requires you to remove ros_lib and regenerate it every time you introduce a new custom message.
  2. Update the pin layout to match your robot and the CNC shield boards in the ‘arctos_moveit_arduino.ino’ file and upload it to your Arduino (assuming you are using a MEGA 2560). Ensure that both the real robot and the simulation start in the same position. To set the simulation upright initially, select “home” from the “Select Goal States” in RVIZ.
  3. In ‘arctos_moveit_convert.cpp’, replace the stepsPerRevolution array with the steps per revolution (or microsteps per revolution) of each of your motors. If you don’t know these values, you can experimentally determine how many microsteps per revolution your motors have using the MultiStepperTest.ino and recording/observing the results.
  4. With the simulation already running, execute the following commands in separate terminal windows:
    • rosrun rosserial_python /dev/ttyUSB0 (establishes a rosserial node to communicate with the Arduino).
    • rosrun moveo_moveit moveit_convert (converts joint_state rotations from the simulation to steps and publishes them on the /joint_steps topic, which the Arduino script subscribes to).
    • rostopic pub gripper_angle std_msgs/UInt16 <angle 0-180> (publishes the gripper angle).

Now, any trajectories planned and executed in the simulation will be echoed on the real Arctos robot.

Directory Structure


This directory contains the URDF (Unified Robot Description File) for the Arctos robotic arm. It’s essential for simulating the Arctos arm in RVIZ and configuring it with Moveit.


Here, you’ll find the configuration files for Moveit, a motion planning framework with a plugin for RVIZ. This configuration is designed for use with the Arctos arm.


  • arctos_moveit_convert.cpp: This node converts joint_state rotations from the simulation (via the ‘move_group/fake_controller_joint_states’ topic) into steps. It then publishes these steps on the /joint_steps topic. The joint_steps topic is an array of 6 Int16 values (though in the case of the Arctos arm, there are only 5 joints). This array represents the accumulated steps executed by each joint since the arctos_moveit_convert node started running.
  • arctos_move_group_interface_coor_1.cpp: This node allows you to hardcode a pose/position for the end effector in the script and plan/execute a trajectory to reach that position. It can also read and output the current pose/position of the end effector.


  • After following step 7, you should see three new topics created:
    • /joint_steps: This topic contains the steps necessary to move each motor to the desired position.
    • /joint_steps_feedback: Similar to /joint_steps, but information is published back by the Arduino to verify that it is receiving data correctly.
    • /gripper_angle: This topic provides the current angle of the gripper.
  • To move the Arctos arm from the command line, use the following command:
    • rostopic pub joint_steps arctos_moveit/ArmJointState <Joint1 Joint2 Joint3 Joint4 Joint5 0>
    • Replace “Joint1, Joint2, etc.” with the number of steps you want each joint to move.
  • Use “`rostopic

list“` and search for these topics to check if they are currently running.


RoboDK postprocessor for Arctos 0.16.7

This repository contains RoboDK packages for the Arctos robotic arm, enabling motion planning, execution, and simulation in both virtual and real environments.

How to Use:


  1. RoboDK
  2. UGS

Import Arctos.rdk in RoboDK

  1. File > Open > Arctos.rdk
  2. Double click on Prog1 to see the test move
  3. Import post processor to installation folder. For example “C:\RoboDK\Posts”
  4. Right click on Prog1 > Select Post Processor > there should be “Arctos” in the list.

Generate robot program

  1. Right click on Prog1 > Generate robot program > select Arctos > OK

If you want to make your custom program follow the RoboDK tutorials

In short:

  • double click on Arctos in design tree below the My Mechanism Base opens the panel
  • In panel it is possible to jog and move the robot to desired position More fun way is to click anywhere in space and hit ALT key, it allows to move the robot by pivoting tools on each target.
  • Add target to desired position
  • Create New program
  • Select target
  • Add movement to a program (joint, linear, circular)
  • Double click on Prog2 to see the movement
  • Step 1.

Open robot program in UGS

  1. Connect the robot with USB cable
  2. Refresh the Port and select COM port, Select Baud 115200
  3. Connect the robot
  4. Make sure it is in the same position as target “Home” in RoboDK
  5. File > Open > Prog1.gcode
  6. Toolbox > Reset Zero
  7. Play the program on robot

Arctos GUI

Open terminal in desktop:

git clone

Copy scripts and to:


make sure they are executable with:

sudo chmod +x 
sudo chmod +x 
cd ~/your-path/arctos_ros 
catkin build 

Now you can go to

cd ~/your-path/arctosgui

Install requirements:

pip3 install -r requirements.txt

Then run


4 tabs will open you can manually open them by:

roslaunch arctos_config demo launch 
rosrun moveo_moveit 
rosrun moveo_moveit 

Wait for the gui and rviz to show

In moveit rviz go File>Open config or Ctrl+O and open arctosgui_config.rviz

Connect the robot

If you have other port than /dev/ttyACM0 edit files and to adress your specific port

Plan new toolpath by moving joints or tool Run ROS button will send CAN messages from new pose

Run RoboDK will send gcode.tap file to robot Make sure that you copy the gcode from RoboDK post processor to gcode.tap or adapt it to export code to arctos gui location under the name gcode.tap and replace it.

Set gear ratios in and gear_ratios = [1, 1, 1, 1, 1, 1] # Replace with your actual gearbox ratios

Raw gear ratios. X 13.5 Y 150 Z 150 A 48 B 67.82 C 67.82

In theory raw gear ratios should be multiplied to 0.5, so gear_ratios would be [6.75, 75, 75, 24, 33.91, 33.91] They are not tested!

If your folder is not in desktop and your machine is not named “aa” you should edit those lines in script according to your path:

BACKGROUND_IMAGE_PATH = "/home/aa/Desktop/arctosgui/img/strelice.png"
BUTTON_IMAGE_PATH = "/home/aa/Desktop/arctosgui/img/bg.png"
ico ='/home/aa/Desktop/arctosgui/img/icon.png')



Please be avare that this robot can electrocute you. Make sure all wires are secured before turning on. Before building please read the entire manual.
Be aware that runing the stepper motors on high current can get you burned and destroy the robot. Thin undersized wires and bad contacts can induce heat as well. Inverting polarity can damage the boards. Removing the supports with sharp object can get you hurt real bad. 3D printer and soldering iron can burn you like crazy. Robot joints and gearboxes can hurt you. You can get emotional damage.

Additional Resources