Meet and Connect the Robot Arm
For engineers and R&D staff · Every output was measured on the actual setup · Companion web console: in the release bundle so101-webapp-*
1. What you will be able to do#
- State clearly where this arm's capabilities end, and where it sits in the overall control chain
- Install from the release bundle, choose simulation or real hardware, and understand why real hardware requires lerobot (about 1.5–5 GB)
- Find and confirm the arm's serial port (via
/dev/serial/by-id/, notttyACM0) - Open the web console, connect the arm and get it moving
- Read the 3D pose view and know what every marker means
- Use the IK pre-check to decide, before you move anything, whether a pose is reachable
2. First, the chain diagram#
Every line of code you write eventually runs through this chain:
Your script
└─ starm.Arm move_joints / move_pose / gripper
├─ MotionPlanner joint interpolation, linear interpolation, speed → duration
├─ Kinematics URDF FK / LM IK
├─ SafetyLayer limit, speed, acceleration, workspace, tracking error, e-stop
└─ ControlLoop (30 Hz) every cycle: read state → safety layer → write targets
└─ LeRobotBackend lerobot → STS3215 servo bus
Keep two things in mind and everything else follows from them:
- The safety layer is the only path that writes to the servos. No
Armmethod can bypass it, so an out-of-range target never "flies off" — it just raises an error. - Motion is "submit + advance".
move_*blocks until the target is reached by default; withwait=Falseit only submits the trajectory and the 30 Hz loop advances it.
Leader/follower teleoperation is the exception to this rule: your hand is the reference, so limits / speed / acceleration / workspace do not participate during teleoperation (they can be switched back on in the UI), while tracking error, over-temperature and e-stop still apply. See Chapter 6, §5.
3. Environment and dependencies#
This section follows the release bundle so101-webapp-0.3.0-20261112.zip:
extract → install → self-check → start → connect → use the web features. Simulation-only
takes about ten minutes to get on screen; real hardware additionally needs lerobot and
serial-port permissions.
This page uses
0.3.0-20261112as the example. For a newer bundle, replace the directory and zip names; the commands stay the same.
3.1 What is in the bundle#
so101-webapp-0.3.0-20261112/
├── start.sh start the web console
├── requirements.txt simulation / web dependencies
├── README.md three-minute quick start
├── INSTALL.md install, run and troubleshooting
├── docs/webapp-guide.md screen-by-screen console guide
├── webapp/ Flask backend + static frontend
├── so101_studio_sdk/ robot SDK (loaded by the server; no pip install)
└── scripts/check_env.py self-check: simulation / web / hardware
A few points:
- Use the whole directory; do not pull out
index.htmlorwebapp/alone. Frontend, backend and SDK belong together. - Runtime data defaults to the bundle directory: recordings in
recordings/, datasets indatasets/, training output inoutputs/. Pose library,config.tomland simulation calibration live in~/.starm/(override withSTARM_HOME); real-hardware calibration lives under~/.cache/huggingface/lerobot/calibration/inrobots/so_follower/andteleoperators/so_leader/. - The bundle targets Linux (Ubuntu 22.04+) and is tested on Python 3.12.13. The code
itself requires Python ≥ 3.11 (the SDK uses
tomllibfrom the standard library); simulation connect and the control loop have also been exercised on 3.11 and 3.13. On Windows use WSL2 Ubuntu and pass the USB serial device through; native Windows cannot run./start.shdirectly. macOS is not verified.
3.2 Install: three profiles#
| Profile | Install | Can do |
|---|---|---|
| A. Simulation / UI only | requirements.txt |
open the web console, simulation, learn the UI |
| B. Add real hardware | A + CPU torch + lerobot[feetech] |
real arm, teleoperation, camera calibration, collection, QC |
| C. Add training / inference | B + lerobot[training] (includes dataset) |
ACT training, dataset inference, real-robot inference |
A. Simulation / UI only (no arm, no lerobot):
unzip so101-webapp-0.3.0-20261112.zip
cd so101-webapp-0.3.0-20261112
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
B. Add real hardware: for the real arm without training, CPU torch is fine and saves about 3.4 GB:
pip install "torch==2.11.0+cpu" --index-url https://download.pytorch.org/whl/cpu
pip install -r requirements.txt
pip install "lerobot[feetech]==0.6.1"
C. Add training / inference: training and inference also need lerobot[training], which pulls in the
dataset extra (datasets / av / torchcodec). Do not train with CPU torch — it is far too slow:
# NVIDIA: install a CUDA torch matching your driver first, not +cpu
pip install "torch==2.11.0"
python -c "import torch; print(torch.cuda.is_available())" # expect True
pip install "lerobot[feetech,training]==0.6.1"
# dataset inference only, no training: lerobot[feetech,dataset] also works
If the machine has no NVIDIA GPU, the +cpu build from B can still train/infer, but it is only
practical for smoke tests; use CUDA for real training or accept the slowdown explicitly.
Already installed
+cpuvia B and now want training?torch==2.11.0also matches the local2.11.0+cpu, so pip may not replace it. The safest path is a clean.venvwith profile C; otherwise install the CUDA wheel with--force-reinstalland confirm withtorch.cuda.is_available().
Real hardware (B/C) also requires:
- your user in the
dialoutgroup (sudo usermod -aG dialout $USER, then log in again); - completed joint calibration; if missing, use the Joint Calibration card at the bottom of the Leader–Follower Teleoperation tab to calibrate the leader and follower;
- the serial port not held by another script (one process, one connection).
You do not need
pip install starm:webapp/server.pyadds the bundledso101_studio_sdk/to the import path. Always start from the bundle root; do not launch a second interpreter insidewebapp/.With profile A only, training/dataset inference will report missing
lerobot / datasets; install profile C for offline training and inference, even without the arm.
3.3 Self-check: read the four verdicts#
python3 scripts/check_env.py
It checks numpy / flask / lerobot / scservo_sdk / torch, serial ports, the dialout group,
the calibration file and the training dependencies, then prints four verdicts:
✓ Simulation (Arm.sim) runnable
✓ Web console runnable
✓ Real hardware (Arm.connect) connectable
✓ Model training (ACT) trainable
- For simulation only, the last three may report missing lerobot/calibration/training deps; the UI can still run;
- For real hardware, the simulation / web / hardware lines must pass; for training and inference, the last line must pass too;
- Exit code
0= at least simulation works,1= not even simulation runs; install the dependencies before continuing.
3.4 Start the web console#
./start.sh
# open http://127.0.0.1:8010
Common options:
./start.sh --port 8080 # use another port if 8010 is taken
./start.sh --host 0.0.0.0 # reachable from other devices on the LAN
On startup it prints which interpreter is used and either lerobot available → real hardware
or no lerobot → simulation only. Those two lines tell you how far the install got.
--host 0.0.0.0is for a trusted LAN only: the console has no login or authentication, so never expose it to the public internet. Stop it withCtrl+C; do not unplug the USB serial device while the server is running.
3.5 Connect the arm#
Simulation first, real hardware second. Simulation needs no hardware; the control loop and safety layer are the same code as on the real arm, so it is the best way to confirm that the bundle runs and the UI responds.
Simulation
- Open
http://127.0.0.1:8010; - choose Simulation in the connection card;
- click Connect; the top bar turns green and says "Connected · Simulation";
- drag a joint slider and check that the 3D pose and telemetry follow;
- click Disconnect to confirm a clean stop.
Real hardware
- Plug in the follower USB and check the port:
ls /dev/serial/by-id/(details in §4); - choose Real hardware, click Rescan, and select the follower port; if it does not
appear, type
/dev/serial/by-id/...directly — do not hard-codettyACM0long-term; - for leader–follower teleoperation, fill in the leader arm port in the same Connection card before connecting; leave it empty to connect the follower alone. If you change it after connecting, disconnect and reconnect first;
- tick the safety confirmation and click Connect;
- once the top bar says "Connected · Real hardware", make a small joint move; keep the mouse/finger on the top-right e-stop button and have a switchable power strip or physical switch as a backup.
If connection fails, check the page log and the scripts/check_env.py verdicts:
| Symptom | Cause | Fix |
|---|---|---|
lerobot is not installed |
the interpreter has no lerobot | start from the bundle root with .venv/bin/python or ./start.sh |
Serial port cannot open / Permission denied |
not in dialout, or the port is busy |
add the group and log in again; disconnect other scripts/pages |
| No serial port found | no udev rule, different adapter, or WSL without USB passthrough | type /dev/serial/by-id/...; use usbipd in WSL |
| Connection says not calibrated | joint calibration missing | use the Joint Calibration card at the bottom of the Leader–Follower Teleoperation tab |
| Port 8010 does not open | server not running / port taken | check the terminal; use ./start.sh --port 8081 |
3.6 Web feature map#
After connecting, use the console in this order. Do not skip steps on the first pass — each one depends on the previous one being correct.
| Area | What it does | First use |
|---|---|---|
| Connection | simulation / real hardware, port scan, connect/disconnect | simulation first, then real hardware; tick safety confirmation |
| Joints | six joint sliders, numeric input, live angles | drag shoulder_pan a little; release to send |
| End-effector pose | x/y/z/pitch/roll, IK precheck, joint/line path | always IK precheck before Move |
| Arrival check | target pose/tolerance and a numeric arrival verdict | take the current pose, set a tolerance; do not judge by eye (Chapter 5) |
| Gripper and actions | open/close, force, home, stop, release | dry-run the gripper; hold the arm before release |
| Pose library | save and jump to frequently used poses | save a safe folded pose first, then try others |
| Leader–follower teleoperation | leader drives follower, absolute/relative mapping | fill the leader port in the Connection card first; calibrate both arms and keep the e-stop close (Chapter 6) |
| Camera calibration | top/wrist camera, nine-point/ArUco, homography | start with the top camera and a nine-point board (Chapter 7) |
| Data collection | multi-camera recording, episodes, start/stop | check the camera views, then record a short episode (Chapter 8) |
| Data QC | dropped/duplicate frames, timestamps, action alignment | run QC after recording, before training (Chapter 9) |
| Model training | dataset build, ACT parameters, loss curve, checkpoints | run a small quick job to validate the pipeline (Chapter 10) |
| Dataset inference | offline prediction vs ground truth, chunk, error table | use a test set; set chunk step equal to the model chunk first |
| Real-robot inference | camera + policy closed loop, speed/interval, safety layer | first run at 1–2°, e-stop in hand, base and camera fixed (Chapter 10) |
| Telemetry / log / e-stop | end-effector pose, loop rate, voltage/temperature, errors, e-stop | check the log first when something fails; e-stop works on every page |
3.7 Full workflow map: install to first inference#
- Extract, install, and get three passing lines from
check_env.py(the hardware line may wait if you only want simulation); ./start.sh, then open port 8010;- simulation: connect → move a joint → open/close the gripper → home;
- end-effector pose: take current, change z/pitch, IK precheck, move;
- real hardware: serial port, safety confirmation, small move, disconnect;
- teleoperation: leader + follower, confirm the following direction;
- camera calibration → record one episode → data QC;
- train a short run → dataset inference → only then consider real-robot inference.
After these eight steps you have touched every web feature; the remaining chapters go deeper into one step each.
3.8 Data, stopping and troubleshooting#
Data locations
<bundle>/recordings/ raw recordings
<bundle>/datasets/ built datasets
<bundle>/outputs/ training output and checkpoints
~/.starm/ pose library, config.toml, simulation calibration
~/.cache/huggingface/lerobot/calibration/
real hardware: robots/so_follower/*.json
teleoperators/so_leader/*.json
When moving machines or upgrading the bundle, take recordings/, datasets/ and outputs/
with you; the pose library is in ~/.starm/, while real-hardware calibration is in the HF cache;
back up both locations, not just the bundle directory.
Stopping
Ctrl+Cin the terminal stops the web server;- disconnect the arm first, then stop the server or unplug USB;
- one process, one connection: all pages share the same arm, and the serial port is exclusive; do not let a script and the page fight over it.
Frequent problems
| Symptom | Fix |
|---|---|
missing required dependencies |
activate .venv in the bundle root, then pip install -r requirements.txt |
lerobot is not installed |
real-hardware path has no lerobot, or the system python is used; use .venv/bin/python / ./start.sh |
ModuleNotFoundError: scservo_sdk |
install lerobot[feetech]==0.6.1, not plain lerobot |
| Serial permission | sudo usermod -aG dialout $USER, then log in again |
| Port already in use | ./start.sh --port 8081 |
| Browser shows an old page | Ctrl+F5; the static server sends no-store by default |
| WSL cannot see USB | usbipd list → usbipd attach --wsl --busid ... |
For more detail, read INSTALL.md in the bundle and docs/webapp-guide.md for the
screen-by-screen UI; Chapters 6–10 cover teleoperation, camera calibration, collection, QC,
training and inference.
4. Finding the serial port#
Bottom line first: with the web console you can skip this step. Open the page and switch to Real hardware; the serial-port field lists every device it scans as a dropdown, and when there is only one it is filled in for you — you never have to copy anything by hand.
To look from the command line, use this:
ls -1 /dev/serial/by-id/
Measured output (42 characters — it does not wrap at a normal terminal width):
usb-1a86_USB_Single_Serial_5B79081041-if00
Prefix that with /dev/serial/by-id/ and you have the full path:
/dev/serial/by-id/usb-1a86_USB_Single_Serial_5B79081041-if00
The
ls -l /dev/serial/by-id/you see everywhere online also prints permissions, owner, date and-> ../../ttyACM0: 96 characters per line, which in an 80-column terminal is guaranteed to wrap onto two lines and makes it look as if the filename were split.ls -1prints only the name, so it does not. The wrapping is purely a display artefact and a copy still contains the whole string — but why make life harder.
The bundle does not put a starm command on PATH, so a bare starm ports fails with
command not found. Run it as a module from the bundle root instead; it prints the full path, the
matching ttyACM0 and the serial number:
PYTHONPATH=so101_studio_sdk .venv/bin/python -m starm ports
# /dev/serial/by-id/usb-1a86_USB_Single_Serial_5B79081041-if00 -> /dev/ttyACM0 serial=5B79081041
starm portsis only on PATH if you previously ranpip install -e so101_studio_sdkin a development environment. Do not assume it exists when using the release bundle.
Prefer the path under /dev/serial/by-id/, not /dev/ttyACM0. The reason is practical: the ACM number changes
when you unplug and replug, so a script with ttyACM0 hard-coded works today and connects to the wrong device
tomorrow.
ls -1 prints nothing → a cable, power or CH340/CP2102 driver problem. Fix that first; do not go on.
5. Console overview#
Once the serial port is confirmed, the fastest way to validate everything is to open the web console — it puts the SDK state, the safety layer and the kinematics on screen, and hands you the original error text when something fails.
The console has eleven tabs: Connect (this figure), Joint Control, End-Effector Pose, Arrival Check, Teleop, Camera Calibration, Data Collection, Data QC, Model Training, Dataset Inference and Real-Robot Inference. The right-hand column (pose view / telemetry / log) is shared by 8 tabs: Connect, Joint Control, End-Effector Pose, Arrival Check, Teleop, Camera Calibration, Data Collection and Data QC. Model Training, Dataset Inference and Real-Robot Inference use a full-width layout without that column.
| Area | Purpose | When |
|---|---|---|
| Connect | Choose simulation / real hardware, connect and disconnect; on real hardware you can also fill in the leader arm port (for teleoperation) | Must be done first |
| IK solver | Hot-swap lm / riemann without reconnecting |
When a solve fails |
| Gripper and actions | Open/close, force, home, stop, torque release, teach | Any time |
| Pose library | Save / jump to frequently used poses | Once you are comfortable |
| Pose view | Real URDF model, rotate / zoom / reset | Keep an eye on it |
| Telemetry | End-effector pose, loop rate, voltage and temperature, safety flags | When troubleshooting |
| Log | Every command and every error | First place to look when something breaks |
| E-stop | Effective in any state | Your first reaction when things go wrong |
Look at the red E-stop in the top-right corner first. It is always in the same place and easy to find; it is a web button, not a physical e-stop — keep a switchable power strip or physical switch as a backup.
The six joint sliders are on the Joint Control tab (see Chapter 2); pose input and the IK pre-check are on the End-Effector Pose tab; anchors, motion recording and replay are on the Arrival Check tab; leader-follower teleoperation is on the Leader-Follower Teleoperation tab For real hardware, fill in the leader arm port in the Connection card before connecting.
6. Connecting: two modes#
Simulation mode (recommended for a first run)#
- Select Simulation
- Click Connect
No hardware needed. The control loop, safety layer and kinematics are the same code as on real hardware; the only difference is that the actuator at the very bottom becomes a virtual joint. So a motion that works in simulation needs nothing but calibration to run on the real arm.
Real-hardware mode#
- Select Real hardware
- Confirm the serial port — the page scans and fills it in automatically (when there is only one candidate); the line under the input tells you how many devices were found. After plugging or unplugging a device, click Rescan, or simply type a different path
- Tick the safety confirmation
- Click Connect
The checkbox is not ceremonial: the server re-validates the confirm field, and a request without it gets a
straight 400.
Why can you just type a path in? There is not necessarily an entry under
/dev/serial/by-id/— no udev rules, a different adapter board, or macOS (where the path is/dev/cu.usbserial-…) can all leave the scan empty. In that case, type the path directly and it connects. The price is that numbers likettyACM0change when you replug, so never hard-code them in scripts.The leader arm port lives in the Connection card, not on the teleoperation page. For leader–follower teleoperation, fill in the leader by-id path before clicking Connect; if the arm is already connected, disconnect and reconnect after changing it.
Got
lerobot is not installedafter clicking Connect? You are running an interpreter without lerobot. First check which interpreter is running:./.venv/bin/python -c "import lerobot; print(lerobot.__version__)". If it is missing, install it into.venv; switching to./webapp/run.shdoes not fix it.
7. Reading the pose view#
What is rendered is the real meshes from the URDF, not a stick-figure skeleton. Thirteen STL parts are assembled along the joint tree, and each frame's pose comes from the SDK's forward kinematics.
The view can be adjusted:
| Action | Effect |
|---|---|
| Drag | Orbit around the arm (azimuth + elevation) |
| Scroll wheel | Zoom |
| Double-click / Reset View | Return to the default view and re-center on the model |
| Marker | Meaning |
|---|---|
| gray model | Current pose |
| Orange gripper | The moving finger is coloured separately. It turns with wrist_roll, so end-effector rotation is visible at a glance |
| Green ring | The current TCP |
| Translucent orange model | Target pose, shown only while the arm is moving |
| Orange ring | Target TCP |
| White dot | Base origin (z = 0) |
| Floor grid | The tabletop plane (z ≈ 30.1 mm) |
Coordinate frame#
The X / Y / Z on screen are in the base frame (the URDF base link):
- Origin at the center of the base
- X points left, Y points back, Z points up, in mm
- The table is not at
z = 0but atz ≈ 30.1 mm(the base origin sits 30.1 mm below the table surface)
Note that these are the coordinates of the TCP (the fixed fingertip contact point on the gripper link, not the midpoint between the fingers), not the rotation center
of the gripper — the two are about 104 mm apart.
pitch and roll do not depend on how the frame is oriented: pitch is the angle between the approach direction and
the horizontal plane, and roll is simply wrist_roll.
For how to read a pose, the TCP offset and the meaning of each component, see Chapter 3: End-Effector Pose.
Where the model and the poses come from#
| Part | Source |
|---|---|
| Meshes, assembly | webapp/static/models/so101/ (URDF + STL) |
| Per-frame link transforms | links from /api/state, computed server-side with starm.kinematics.fk() |
The front end does not recompute kinematics; it only applies the 4×4 matrices from the server to the corresponding meshes. So the pose in the 3D view and the pose the SDK believes in are always the same thing — which is exactly why you can use the view to investigate "I don't think it should be there".
When parsing the URDF, only
<visual>is taken, never<collision>. The two come in pairs in the URDF; taking both duplicates the geometry, which makes the view flicker and the materials go black.
Why the gripper is coloured separately#
The arm body is gray-white; the orange part at the end is the moving finger. It rotates with wrist_roll, so
to check "how far did it actually turn", watching it is enough — a gray link spinning about its own axis shows
nothing.
8. IK pre-check: compute first, then move#
The IK pre-check only solves — it does not move. It answers two questions:
- Reachable → you get a set of joint angles to look at before deciding whether to move
- Unreachable → it states the reason plainly, e.g.
wrist_flex is at its upper limit (95.0 deg)
The error on the right contains the single most useful sentence:
Pointing straight down costs reach height: at pitch 90 the arm only reaches about 80 mm above the table
On a 5-DoF arm, the more vertically you point, the closer you hug the table. To work up high, lower pitch to
60–75.
Make it a habit: pre-check every new pose before moving. The pre-check carries zero risk; the move does not.
9. First hands-on run in simulation: 8 steps#
| Step | Tab | Action | What you should see |
|---|---|---|---|
| 1 | Connect | Select Simulation → Connect | The top bar shows a green dot, "Connected · Simulation" |
| 2 | Joint Control | Drag shoulder_pan to 20° and release |
The model rotates and the angle in telemetry follows |
| 3 | End-Effector Pose | Click Get Current and watch the pose fields fill in | X/Y/Z/pitch/roll show the current values |
| 4 | End-Effector Pose | Enter X 0, Y -300, Z 150, pitch 65, click IK Pre-Check, then Move if it passes | A list of joint angles; the end effector then moves and the status bar shows the target waypoint |
| 5 | Connect | Click Open, then Close | The gripper opens and closes; the Gripper opening value changes |
| 6 | End-Effector Pose | Keep Y=-300, set Z to 230 and pitch to 90, click IK Pre-Check | A red error: out of reach (about 1.4 mm / 43.5° short), with the reason given |
| 7 | Connect | Click Home | Back to the all-zero pose |
| 8 | Connect | Click Disconnect | The top bar turns gray and the controls dim |
After these eight steps you have walked the whole chain: connect → read state → move joints → move the end effector → control the gripper → handle an error → wrap up.
10. Teaching: posing the arm by hand#
Once real hardware is connected, there is a Teach button under Gripper and actions. What it does is release the torque, leaving the arm in a state you can push around — far more direct than dragging sliders, especially when you just need a roughly right pose.
Procedure:
- Support the arm with your hand or a stand first — confirming Teach releases torque and the arm will drop under gravity;
- Click Teach and confirm in the dialog (torque is released only now);
- Pose it by hand. The six joint sliders on the left follow you in real time;
- When it is where you want it, click Finish Teaching (the button on the right of the banner) — torque comes back and the arm holds where it is; it does not snap back to the previous pose;
- To keep it, click Save Current to store it in the pose library, then return to it with one click later.
A few points:
- All motion controls are disabled while teaching. Not to prevent mis-clicks: with the torque off the backend skips writing targets, so motion commands issued then would only raise an error.
- In teaching mode the arm has no torque, so the e-stop cannot replace supporting it. The e-stop button can still be pressed, but with no torque it cannot stop the arm falling under gravity; that is why step 1 must support the arm first.
- Finish Teaching does not move the arm. It freezes the target at the current measured position, hence "holds where it is".
- Disconnecting while teaching makes the server restore torque before shutting down, so the arm is never left limp.
- The button is greyed out in simulation mode. You cannot back-drive virtual joints, so teaching is meaningless there.
Teaching versus the Release Torque button: release torque is a toggle with no extra state attached; teaching is a mode, with a banner, an explicit start and end, and the motion controls locked while it is active. Use torque release to nudge the arm out of the way for a moment; use teaching to set a pose properly.
11. Common states and what to do#
| Symptom | Cause | Fix |
|---|---|---|
| All controls are greyed out | Not connected | Connect first |
| Connect is gray but Disconnect is active | Already connected (check which mode the top bar shows) | Click Disconnect first, then switch modes or reconnect |
| Teach is gray | Currently in simulation mode | Teaching is only available on real hardware |
| Clicking Connect does nothing | Safety confirmation not ticked in real-hardware mode | Tick it |
lerobot is not installed |
The interpreter has no lerobot, or the console was not started from .venv |
Check with ./.venv/bin/python -c "import lerobot"; install it into .venv rather than switching launch scripts |
SafetyError: … outside soft limits |
Target out of range | Back off; the command itself is invalid and retrying will not help |
Unreachable: … |
IK found no solution | Change pitch or z; this is not a bug |
| The top bar reports an e-stop | E-stop not cleared | Once you are sure it is safe, click Clear E-Stop |
| The safety flags in telemetry are non-empty | This cycle was clipped by the safety layer | Check whether it was a limit, a speed limit or the workspace |
12. A few conventions you must know#
- One connection per process. Every open page shares the same arm connection; this is a single-user console, not a multi-user system.
- Motion is "submit + advance". Clicking Move returns immediately and the motion runs in the 30 Hz loop. The UI shows progress from the difference between position and target.
- The serial port is exclusive. While a page is connected, your script cannot open the same port. Click Disconnect before running a script.
- Release torque drops the arm. Support the arm before clicking Release Torque — it has no brake.
- The e-stop does not recover automatically. Clearing it does not resume the motion that was interrupted; you have to send the command again.
13. Want to change the UI?#
The front end has no build step — just four files:
webapp/static/index.html page structure
webapp/static/app.js state polling, command dispatch
webapp/static/view3d.js three.js scene: URDF meshes + orbit camera
webapp/static/style.css dark theme
The figures in this document are generated by scripts/make_figures.py. After a UI
change, retake the screenshots and adjust a few coordinates to regenerate them — no manual Photoshop work.
References#
scripts/check_env.py— environment self-check (dependencies / serial port / permissions / calibration)webapp/README.md— web console architecture and APIso101_studio_sdk/README.md— the full API referenceso101_studio_sdk/examples/— four runnable examples (01–04)so101-course-outline.md— the companion course outline (this chapter maps to sections A2 / A3)