Connecting to sources…

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

Documents