Drive DOBOT robot arms directly from Core.
Core talks to DOBOT robotics natively: 22 blocks drive the arm, the gripper and the camera straight over TCP, with no control layer in between. For anyone looking at pick-and-place or a full robot cell, from one arm at a packing table to an autonomous line.
The arm does what the flow says
The instruction comes from your flow
What the robot does follows from your process: an order, a task or a signal in Core decides the movement. You build that logic in the same editor as the rest of your application.
Arm, gripper and camera over TCP
The blocks talk straight over TCP to the arm, the gripper and the camera. No layer from an outside vendor in between.
Vision reports back into the flow
The camera sees what is in front of the arm and where it sits, and that picture arrives live in your flow. Your process decides the next movement from there.
From pick-and-place to an autonomous cell
Start with one arm doing repetitive picking and placing, around the clock if that is what the line needs. Grow into a cell that uses vision to pick its own next step. Same blocks, same control.
How the integration works
Every DOBOT block is a building block in Core: drag it into your flow and connect it to your orders, your stock or your camera. The blocks address the robot directly over TCP, so no extra control sits between your process and the arm.
Before any hardware moves, the cell runs in our simulator. Grip points, cycle times and exceptions are tested digitally, so the physical installation holds no surprises.
Blocks
22 native DOBOT blocks in the Core 14 block library.
Protocol
Straight over TCP, with no vendor layer in between.
Driven
Robot arm, gripper and camera.
Direction
Instructions out, camera feed and status in.
Scale
From one pick-and-place arm to a fully autonomous cell.
First
The cell runs in simulation before it reaches your floor.
The questions we get most about the DOBOT integration
Three questions we hear in nearly every first conversation.
Is there no extra controller between Core and the robot?
No. The DOBOT blocks in Core talk straight over TCP to arm, gripper and camera, with no layer from an outside vendor in between. The same control layer already runs entire distribution lines at our customers.
How do I know the cell works before it stands on my floor?
We rebuild the cell in our simulator first. Grip points, cycle times and exceptions are tested digitally, so you see how the cell performs before you commit to anything.
What if a command I need has no block yet?
File a request and the block is in there within a week, built and maintained by us. And if a connection truly goes off the beaten path, you can write your own block in ReactJS.
Wondering what a robot cell would do in your process?
Name your process and we will show you in the demo how the control runs, from flow to gripper.