The ConsolesRobot ConsoleFind and connect
Find and connect to a robot
Use the Robot Console to see the hardware on your PC and the robots in your account, and open a session with one of them.
The Robot Console is a web page that runs on your own PC. It lists two kinds of hardware: arms and units wired to this computer, and the robots in your MAKIINA account wherever they are. Pick one and the console opens a session with it. This page shows how to find your hardware and get to the cockpit; Drive from the cockpit covers what you do there.
Start the console
.\RobotConsole.bat # Windows, in PowerShell in the kit folder
./robot_console.sh # Linux
makiina-console # any shell with the SDK's environment activeOn Windows you can also double-click RobotConsole.bat. Your browser opens http://127.0.0.1:8726. The console only listens on your own machine; nobody else on the network can open it. To run a second console, give it another port with --port 8728.

The landing page has two cards. On this PC sums up what answered on your USB CAN adapters. Fleet tells you whether you are signed in and how many of your robots are online. Along the bottom you see your Python version, the free disk space and a link to the Actuator Console for single actuators (start ActuatorConsole.bat first). The core field there reads n/a in a kit.
Connect to an arm on your PC
Open On this PC. The console looks at every USB CAN adapter and asks each board what it is. Every arm or unit it finds gets a row:

- The adapter's serial number and the bus speed, 1 Mbit/s.
- The unit (right arm, left arm, head) and Ready when every board answered and says it is calibrated.
- The chain of boards from J1 to the gripper, each with its CAN id, in the order they sit on the bus.
- The firmware version the boards run.
Click Control to open a session. The console starts a robot server on your PC on every adapter in the list, so with two arms plugged in, Control on either row opens one session with both (Run two arms). It waits for the first joint state; that takes a few seconds, and the cockpit opens when the arm is live. If another program holds one of the adapters, the session does not start: close that program first.
Click Rescan after plugging in another adapter or powering an arm on.
Click Control on the arm's row.
from makiina.robot import Robot
robot = Robot.connect_local()A row that says boards without a unit holds boards that do not know which arm they belong to yet, and no boards answered means the adapter is there but the bus is silent: the arm is off or its cable is loose. Troubleshooting goes through both.
Sign in to your fleet
Open Fleet and sign in with the email and password of your MAKIINA account. If you signed in once with the command line tool, Saved login signs you in with that sign in instead. Only tokens stay on your PC, never your password. The Code tab signs you in with an 8 letter code that you approve on your phone, and New account creates a MAKIINA account. We mail a new account a link to confirm its address. Open it and press CONFIRM MY EMAIL ADDRESS on the page it opens before you add a robot: opening the link alone does not confirm the address, and an account whose address is not confirmed cannot add a robot. A new account has no organization yet: it gets one when you add your first robot.

The fleet list shows every robot in your account with its state. A new account says No robots in this account yet: Add robot at the top of the list adds one with the claim code from its card (Add it from the Robot Console). The usual way is the account console at cloud.makiina.com/account, as in Add the robot to your account.

| State | What it means |
|---|---|
| Idle | Online and free. Control starts a session. When the row's status reads ROBOT INCOMPLETE, a part of the robot did not answer, and the line under it says which (Troubleshooting). |
| In session | Someone is connected. You see who and for how long. End session ends a session that was left behind, for example when an operator's PC went away without disconnecting. |
| Maintenance | Calibrate, Cameras or Firmware is running on the robot, or a software update. Sessions wait until it is done. |
| Offline | The robot's agent has not reported in; the row says when it was last seen. |
The list refreshes every four seconds. Each row also shows the commit of the software the robot runs (Core, a short code such as 5e1c0a2; the release version is on its Software page) and its drive firmware, and marks old firmware in amber.
Click Control on a robot's row.
from makiina.robot import Robot
robot = Robot.connect("acme-robot-02")The same list is available from Python without opening a session:
from makiina.cloud import Fleet
fleet = Fleet.login() # same credentials as the console
for r in fleet.robots():
print(r["name"], r["online"], r["status"])Watch the session start
Between the click and the cockpit the console shows each step of the session start, with how long it took:

For a robot in your fleet the steps are: finding the addresses this PC can be reached on, offering the session through the cloud, punching a direct path to the robot, the robot booting its drives (with a count of the boards that are up), and the camera streams arriving. The robot's own boot log scrolls on the right. The cloud only introduces the two sides; video and control then flow directly between your PC and the robot, over your local network when both are on it, and through MAKIINA's relay only when no direct route exists.
For an arm on your PC the steps are shorter: the robot server starts on your adapters, takes the bus and reports the first joint state.
Cancel (or Esc) stops the attempt.
Check the session and disconnect
Click the connection readout in the middle of the cockpit's top bar (the path, the ping and the state rate) to open the session card. It shows the robot, how the session was set up, the network path, the ping, the state rate and the video streams, with the latest console messages underneath.

Disconnect ends the session and leaves you on the page. Exit in the top left ends it and takes you back to the list.
robot.disconnect()Disconnecting does not change what the motors do: an arm that was holding its pose keeps holding it. Turn the torque off first if it should go limp.
With a robot in your fleet the card also has Reboot robot, which restarts the robot's own computer once you confirm. The robot is back in about a minute. Before you press it, support the arms and click Torque off. The question says the motors de-energise and the arms settle, but the robot sends no such command: each drive keeps its last target while the computer restarts, so only Torque off lets the arms rest.
Move between pages
An arm or unit on your PC has five pages, listed in the menu next to its name in the top bar: Control, Tuning, Calibrate, Firmware and Software. A robot in your fleet has eight: Control, Tuning, Calibrate, Cameras, Firmware, Software, SSH access and Cloud. Control and Tuning share one session, so you can switch between them while connected. Leaving for any other page ends the session.
[ and ] step through the console's whole list of pages in one order, not through the menu of the robot you have open: the landing, Sign in, Fleet, This PC, Control, Tuning, Calibrate, Firmware, Software, SSH and Cloud. The list leaves out Cameras, and it includes SSH and Cloud for an arm on your PC, which has neither. A step from Tuning to Calibrate, or from Control back to This PC, ends the session, so use the menu next to the robot's name to move between its pages.
For a robot in your fleet, every page except Control, Tuning and Cloud runs on the robot's own console and reaches it over your local network, and so does the device code on Cloud. These pages need your PC on the robot's network, and owners and admins of the robot's organization open them with their account. Driving works from anywhere. Add your SSH keys and Update the robot software walk through SSH access and Software.
Calibrate, Cameras and Firmware are maintenance tools; the arms and robots ship calibrated and with their firmware loaded, so they do not need them. Cameras calibrates the head's two cameras again, for example after a camera was replaced. They are described in Calibration and firmware.