How to build JBR-001 (open-source desktop companion robot): the whole process
77 steps to build JBR-001 (open-source desktop companion robot), from buying parts, printing and assembly to software, calibration and training, with the bill of materia…
Not sold and no official kit; no BOM total is given. The Arduino Project Hub parts list names one each of the UNO Q 2GB, Modulino Distance, Modulino Motors, Modulino Buzzer and the USB‑C hub, and leaves out the camera, servos, external supply, cables and screws, with no prices
Buy parts
- Obtain the listed electronic components
Use an Arduino® UNO™ Q 2GB, Modulino™ Distance, Modulino™ Motors, Modulino™ Buzzer, and Arduino USB-C Hub (8 in 1).
Assemble
- Assemble servo head frame
Assemble Frame_Head_Servo_Top, Frame_Head_Servo_Middle, and Frame_Head_Servo_Bottom into the head frame.
- Continue the head frame assembly
Continue the HEAD FRAME assembly as shown in the illustration.
- Continue connecting the head frame
Continue connecting and assembling the HEAD FRAME as shown.
- Complete head frame connections
Complete the remaining HEAD FRAME connections as shown.
- Install the 18-tooth gear
Install Frame_Gear_18_teeth in the head frame.
- Assemble the head back frame
Assemble Frame_Head_Back_Bottom_Left, Frame_Head_Back_Bottom_Right, Frame_Head_Back_Top_Left, and Frame_Head_Back_Top_Right.
- Assemble the head front frame
Assemble Frame_Head_Front_Bottom_Left, Frame_Head_Front_Bottom_Right, Frame_Head_Front_Top_Left, and Frame_Head_Front_Top_Right.
- Continue assembling the front and back frames
Continue assembling the front and back head frames as shown.
- Install the camera holder
Install Frame_Head_Camera_Holder on the head frame.
- Assemble the body frame
Assemble Frame_Cage_Body_Bottom and Frame_Cage_Body_Top into the body frame.
- Continue the body frame assembly
Continue the BODY FRAME assembly as shown in the illustration.
- Continue connecting the body frame
Continue connecting and assembling the BODY FRAME as shown.
- Assemble body pole parts and gear
Assemble Frame_Pole_Barrel_Back, Frame_Pole_Barrel_Front, Frame_Pole_White, and Frame_Gear_36_teeth.
- Install the head back shell
Install Head_Back_White, Head_Back_Left_White, and Head_Back_Right_White.
- Install the left and right ears
Install Head_Ear_Right_Blue and Head_Ear_Left_Blue.
- Install antennas and ear buttons
Install Head_Antenna_Cap_Left_Blue, Head_Antenna_Cap_Right_Blue, Head_Antenna_Left_White, Head_Antenna_Right_White, Head_Ear_Button_Left_White, and Head_Ear_Button_Right_White.
- Install the blue back ring
Install Head_Back_Ring_Blue on the head.
- Install the inner ear pieces
Install Head_Ear_Inside_Right_Blue and Head_Ear_Inside_Left_Blue.
- Install the camera lens
Install Head_Camera_Lens_Black and Head_Camera_Lens_Ring_Blue in the camera frame.
- Install the white head front
Install Head_Front_White on the head.
- Install the front and back holders
Install Frame_Holder_Back_Blue, Frame_Holder_Back_Cap_Left_Blue, Frame_Holder_Back_Cap_Right_Blue, and Frame_Holder_Front_Blue.
- Connect the head and body
Connect the HEAD AND BODY as shown in the illustration.
- Continue joining the head and body
Continue completing the HEAD AND BODY connection as shown.
- Install the body front frame
Install Body_Frame_Front_White, Body_Logo_Left_Blue, and Body_Logo_Right_Blue.
- Install the body back frame
Install Body_Frame_Back_White on the body.
- Assemble the two legs
Assemble the robot's two legs following the LEGS x2 illustration.
Software
- Create the required accounts
Create an Edge Impulse account with a project, and sign up for a free Vision Datasets account.
- Open the Vision Datasets dashboard
Log in to the Vision Datasets dashboard.
- Find the project API key
Find the API key in the Edge Impulse project under Dashboard → Keys → API Keys.
- Open the Edge Impulse project
Go to Edge Impulse Studio and open the project containing the uploaded dataset.
- Use an Edge Impulse API Key
Open Dashboard → Keys → API Keys in your Edge Impulse project and use an API key from there.
- Remove Extra Characters
Remove any extra spaces or characters from the value being entered.
- Generate a New API Key
Generate a new API key if the current one cannot be used.
- Open the Edge Impulse Dashboard
Go to the Dashboard in Edge Impulse Studio.
- Load the robot control libraries
Include the Servo, Modulino, and Arduino_LED_Matrix libraries used by the JBR-001 source code.
- Configure the head and arm servos
Create servo objects for the head, left arm, and right arm. Assign pins 9, 10, and 11 respectively, with a resting position of 90 for each servo.
- Set all servo center positions
Set the head, left arm, and right arm resting positions to 90 and assign the right arm to pin 11.
- Initialize the robot modules and display
Create the Modulino buzzer and distance sensor objects and initialize the Arduino LED matrix.
- Configure distance detection thresholds
Set object detection to 200.0 and the reset distance to 250.0, with the object-detected state initially false.
- Define the display heart graphics
Define small and large 8-by-13 heart bitmaps whose orientation matches the display.
- Implement the heartbeat animation
Render the large and small heart bitmaps on the LED matrix with the document's 120, 100, 160, and 700 millisecond timing sequence.
- Capture Images with the Camera
Use the camera to capture images of the environment in front of the robot, then pass the images into the computer vision workflow.
- Run the Model on the UNO Q
Process the camera images on the Arduino® UNO™ Q using the trained computer vision model.
- Deploy the Model to the Robot
Once satisfied with the model, deploy it to the robot.
- Run the Model on Arduino UNO Q
Deploy the trained Edge Impulse model on the Arduino® UNO™ Q. Use JBR-001's head camera for image input so the UNO Q can run inference and return predictions to the application.
- Connect Vision to Robot Reactions
Map model predictions to robot behaviours in the Arduino® application, such as turning the head, raising the arms, playing a short sound, and changing the display animation. Different Modulinos can trigger different reactions, and the process can run continuously.
Calibrate and test
- Verify the Modulino Detection Result
Place different Modulinos in front of the camera and check whether the model identifies the module it sees.
- Evaluate with Unseen Images
After training is complete, use Edge Impulse's model testing tools to evaluate the model's performance on images that weren't used during training.
- Test Recognition with a Real Modulino
Put a real Modulino™ in front of JBR-001 and check whether the model recognizes it.
Data and training
- Find a relevant vision dataset
Browse or search Vision Datasets for a relevant dataset.
- Inspect the dataset details
Review the description, preview images, image count, file size, classes, version, and license.
- Choose upload to Edge Impulse
Click Upload to Edge Impulse on the selected dataset.
- Configure the image upload
In the popup, set the image volume, image resolution such as 96×96, 320×320, or 512×512, and select one or more classes to include.
- Start the dataset transfer
Click Upload to start transferring the selected dataset to Edge Impulse.
- Confirm the completed upload
Check for the success confirmation displayed after the upload.
- Open Data Acquisition
Navigate to Data Acquisition in the Edge Impulse project.
- Verify the uploaded images
Review the uploaded images for correct labels per selected class, the selected resolution, and the training/testing split.
- Explore classes and subsets
Use filters or search to explore specific classes or subsets, and click any image to preview it.
- Check Spam and Junk Folders
Check the spam or junk folders for the email or code.
- Verify the Email Address
Ensure that the email address used for the dataset upload is correct.
- Resend the Code
Resend the code, or use a different email address if needed.
- Set the Bounding Box Labeling Method
On the Project info card, set Labeling method to Bounding boxes (object detection) so labels are displayed correctly.
- Use the Public Modulino Dataset
Obtain the Arduino® Modulino™ dataset from VisionDatasets.com. It contains synthetic images with varied positions, orientations, backgrounds, lighting conditions, and other visual variations.
- Train the Modulino Object Detection Model
Train the JBR-001 computer vision model with the Modulino dataset so it can recognize different modules from the Arduino® Modulino™ family.
- Open and Upload the Dataset
Open the Arduino® Modulino™ dataset on VisionDatasets.com, then select Upload to Edge Impulse.
- Configure Upload Settings
Provide your Edge Impulse project's API key and select the number of images, image resolution, and Modulino™ classes to include.
- Confirm Imported Images
After the upload is complete, the images appear under Data Acquisition in Edge Impulse, already labeled and ready to use.
- Review Imported Data
Open Data Acquisition and review the imported images, verifying that the Modulino™ classes are represented correctly and that the training and testing data look as expected.
- Create and Configure the Pipeline
Create an impulse and configure the image processing and learning blocks for the model.
- Train the Vision Model
Train with the imported images so the model learns the visual characteristics that distinguish the different Modulinos.
- Check Training Data Variation
Check that the data includes different object positions, rotations, backgrounds, lighting conditions, and other variations to expose the model to a wider range of appearances.
- Train Your Own Vision Model
Choose the tools, electronic components, everyday objects, or project-specific objects to recognize. Import ready-to-use datasets from VisionDatasets.com directly into Edge Impulse, or create and use your own training data, then train a different model.
Use it
- Connect Detection to Robot Outputs
Connect the detection result to any of JBR-001's physical outputs. The computer vision model determines what can be recognized, while the application determines the robot's reaction.
- Set Robot Actions for Detection Results
Use the detection result to move the robot's head or arms, play a sound, change its display, or combine several actions into a single reaction.
- Train the Model for Different Objects
Change the dataset and train a new model to teach JBR-001 to recognize completely different objects.
- Combine Detections and Behaviours
After training a different model, the physical JBR-001 platform does not need to change; simply decide what it recognizes and what it does when a detection occurs. Combine multiple detections so they trigger different movements, sounds, and display animations.
Parts
- Arduino UNO Q 2GB (the controller: it drives the display, sensors, buzzer and servos and runs computer vision)
- 3 servos: head on D9, left arm on D10, right arm on D11 (model not named), powered by an external servo supply that shares ground with the UNO Q
- A camera (in the head, model not named) and the Arduino 8-in-1 USB‑C hub
- Modulino Distance and Modulino Buzzer (daisy-chained on Modulino cables); the Project Hub parts list adds one Modulino Motors
- 80 STL print files: body, inner frame (with 18- and 36-tooth gears), head, both arms and both legs; plus cables, screws and mounting hardware
Tools
- A desktop 3D printer (Project Hub parts list)
- An external power supply that can feed the 3 servos
Skills
- Assembling the head frame, body, legs and hands from the 35-page assembly PDF or the assembly video, aligning the servo shafts with the moving parts
- Wiring from the diagram: servos on an external supply sharing ground with the UNO Q, the camera through the USB‑C hub
- Arduino programming (Servo, Modulino and LED matrix libraries), with optional object-detection training in Edge Impulse and deployment through Arduino App Lab
Software
- Arduino sketches: heartbeat animation (head-display), hello tune (buzzer), distance-triggered greeting (distance-and-buzzer), servo motion (servo-motors), a dance (dance) and the full program (full-code)
- Arduino App Lab: deploys and runs the Edge Impulse object detection model on the UNO Q
- The synthetic Arduino Modulino dataset on VisionDatasets.com, which imports straight into Edge Impulse