JBR-001 Open-Source 3D-Printable Desktop Robot Overview

TL;DR

JBR-001 is a fully open‑source, 3D‑printable desktop robot built around the Arduino UNO Q, featuring three servos, a camera, distance sensor, buzzer, and an 8×13 bitmap display, enabling hobbyists to experiment with edge AI, computer vision, and physical interaction.

---

What Is JBR-001?

JBR-001 is a compact, 3D‑printable robot platform designed for rapid prototyping of robotics, perception, and edge AI. All mechanical parts, firmware, and CAD files are released under an open‑source license, and the bill of materials consists of inexpensive off‑the‑shelf components:

• Arduino UNO Q (central controller)
• USB‑C hub for camera connectivity
• One camera module (forward‑facing)
• Modulino distance sensor (rear‑facing)
• Modulino buzzer (audio feedback)
• Three hobby servos (head and two arms)
• External 5 V/2 A power supply for the servos
• Complete STL files hosted on GitHub

The robot can greet users, display a pulsing heart animation, detect objects with a distance sensor, and run computer‑vision models on‑board.

---

Core Architecture and Wiring

The Arduino UNO Q drives all peripherals and runs inference for computer‑vision models. Key wiring rules are:

1. Head servo → pin 9
2. Left‑arm servo → pin 10
3. Right‑arm servo → pin 11
4. All servos → external 5 V supply (never power directly from the UNO Q)
5. External supply ground ↔ UNO Q ground (common reference)
6. Modulino distance & buzzer → UNO Q pins (as shown in the wiring diagram)
7. Camera → USB‑C hub → UNO Q

Important: Connecting servo power directly to the UNO Q will cause brown‑outs and unreliable motion; always use a dedicated supply and share grounds.

---

Mechanical Assembly

The robot’s body consists of 3D‑printed parts that house the electronics and servos. Assembly steps:

1. Print all STL files.
2. Install the head servo (horizontal rotation) and arm servos (vertical movement) ensuring shaft alignment.
3. Mount the camera in the head and the distance sensor on the rear.
4. Route cables through the printed channels before closing the shell.
5. Secure the Arduino UNO Q and connect the external power supply.

A full video walkthrough is available on the project page.

---

Display Animation (Heartbeat)

The 8×13 LED matrix shows a pulsing heart when idle. Two bitmap arrays (heartSmall and heartLarge) are rendered in a timed state machine that updates without blocking sensor reads:

unsigned long heartbeatTimer = 0;
int heartbeatStep = 0;
void heartbeat() {
  unsigned long now = millis();
  switch (heartbeatStep) {
    case 0: matrix.renderBitmap(heartLarge,8,13); heartbeatTimer=now; heartbeatStep=1; break;
    case 1: if (now-heartbeatTimer>=120) { matrix.renderBitmap(heartSmall,8,13); heartbeatTimer=now; heartbeatStep=2; }
    case 2: if (now-heartbeatTimer>=100) { matrix.renderBitmap(heartLarge,8,13); heartbeatTimer=now; heartbeatStep=3; }
    case 3: if (now-heartbeatTimer>=160) { matrix.renderBitmap(heartSmall,8,13); heartbeatTimer=now; heartbeatStep=4; }
    case 4: if (now-heartbeatTimer>=700) { heartbeatStep=0; }
  }
}

The non‑blocking design lets the robot monitor the distance sensor and camera simultaneously.

---

Audio Feedback with the Buzzer

A simple four‑tone melody provides a friendly greeting when the distance sensor detects a nearby object:

void playHello() {
  buzzer.tone(523,120); delay(150);
  buzzer.tone(659,120); delay(150);
  buzzer.tone(784,180); delay(210);
  buzzer.tone(1047,250); delay(270);
}

Developers can replace the melody with custom tone sequences to signal different robot states.

---

Proximity Sensing

The rear distance sensor continuously reports range. A typical interaction pattern is:

if (distanceSensor.available()) {
  float d = distanceSensor.get();
  if (d < DETECTION_DISTANCE && !objectDetected) {
    objectDetected = true;
    playHello();
  }
  if (d > RESET_DISTANCE) objectDetected = false;
}

Adjust DETECTION_DISTANCE and RESET_DISTANCE to tune responsiveness.

---

Servo Control Guidelines

Servos are driven via standard Servo.write(angle) calls. Recommended practices:

• Limit motion to the mechanical range of the printed joints (avoid full 0‑180° sweeps).
• Use small, expressive movements (e.g., 10‑30° head turn) for natural behavior.
• Always power servos from the external supply and keep grounds common.

---

Edge AI: Running Computer Vision on the UNO Q

The camera feeds 96×96 (or similar) frames to the Arduino UNO Q, where an Edge Impulse‑generated model performs inference. The workflow is:

1. Dataset acquisition – Use VisionDatasets.com to download a synthetic dataset (e.g., Arduino Modulino images).
2. Edge Impulse import – Upload the dataset directly via the provided API key.
3. Model training – Configure an image‑classification impulse; Edge Impulse handles training and validation.
4. Deployment – Export the model as a C++ library and integrate it into the JBR‑001 firmware.
5. Inference loop – Capture a frame, run run_classifier(), and act on the predicted class.

The robot can therefore recognize specific objects (e.g., different Modulinos) and trigger coordinated actions such as moving the head, raising arms, playing a sound, or changing the display.

---

Example Application: Modulino Recognition

The authors trained a model to distinguish several Arduino Modulino boards. When a Modulino appears in front of the robot, the following sequence occurs:

1. Camera captures image.
2. Edge Impulse model predicts the Modulino class.
3. Firmware maps the class to a behavior (e.g., head turn + arm raise + beep).

Because the dataset includes varied lighting, poses, and backgrounds, the model generalizes to real‑world captures.

---

Extending JBR‑001

The platform is deliberately modular:

• Swap the camera for higher resolution or infrared.
• Add sensors (e.g., temperature, IMU) by connecting to spare UNO Q pins.
• Replace the display with a larger matrix or OLED for richer UI.
• Train new models on any object set using VisionDatasets.com or custom images.
• Program custom behaviors in the Arduino IDE or PlatformIO, leveraging the same non‑blocking loop structure.

---

Community Reception

The Hacker News thread highlighted several user perspectives:

• Positive enthusiasm for the open‑source nature and family‑friendly build experience (comment by salamachinas).
• Concerns about the UNO Q’s cost and limited clone availability (mrheosuper).
• Comparisons to earlier open‑source kits like Otto DIY, noting a trend toward commercialisation (phil42).
• Light‑hearted remarks about the robot’s aesthetic and utility (shevy-java, krisoft).

These comments underscore both the educational value of the project and the importance of keeping the hardware affordable and truly open.

---

Conclusion

JBR‑001 demonstrates that a fully functional, AI‑capable desktop robot can be built from inexpensive, 3D‑printed parts and a single Arduino UNO Q board. Its open‑source design, complete firmware examples, and seamless Edge Impulse integration make it an ideal sandbox for learning robotics, computer vision, and edge AI.