Nuvi is a small, expressive desktop companion, less than 30 cm tall. It wakes up when someone comes close, answers when it is called by name and holds a conversation with the user. It also searches the web, controls smart home devices by voice or with a hand gesture, and reads the room’s temperature and humidity. It was designed by Luca Di Lorenzo, and the board that brings it to life is the Arduino UNO Q.

What stands out is not the conversation itself, but where it runs. The Linux side of the UNO Q runs the artificial intelligence pipeline, the voice engine and the application logic, all on the board itself rather than on a connected PC. So Nuvi is self-contained: you switch it on and it is there.

Two souls on one board: microcontroller and Linux

Arduino UNO Q splits the work in two. The real-time microcontroller side handles the physical control: four servos for the arms and ears, two serial servos for the neck, the display, the sensors and the touch inputs. The Linux side, on the other hand, takes care of the heavy part, that is the artificial intelligence and the voice.

This separation makes practical sense. Movements have to respond immediately, without waiting, and that is why they live on the microcontroller. The conversation can take a few moments longer, so it lives on the processor running Linux. As a result, the arms, ears and head move smoothly while the brain works out the sentence.

• Four servos for the arms and ears
• Two serial servos for neck rotation and tilt
• Display for the animated eyes
• Temperature and humidity sensors
• Touch inputs on the head and belly

Gemini to understand, Piper to speak without the cloud

The conversation is based on Gemini, which handles both speech understanding and response generation in a single pass. There is therefore no separate speech-to-text stage: the model does everything at once, and the pipeline stays leaner.

For the outgoing voice, on the other hand, Nuvi uses Piper, a voice engine that runs entirely on the board. So the synthesis does not go through the cloud: the sentence is spoken locally. In particular, it is this choice that makes the robot usable even when the network is poor, at least for the sound side of things.

The animated eyes express different moods. The ears and arms move, the head rotates and tilts, and touching the head and belly triggers a reaction. Finally, purely for fun, there is also a little dance.

What you need to rebuild it: 3D files, electronics and code

Anyone who wants to build a Nuvi starts from the Arduino UNO Q, the heart of the project. The complete kit with accessories includes the board and what you need to start working with it. To drive traditional three-pin RC servos, with power, ground and PWM signal, you then need a dedicated driver stage.

On the sensor side, Nuvi reads the room’s temperature and humidity. Nuvi uses a Modulino Thermo module for the room’s temperature and humidity, while two Modulino Distance modules take care of noticing who is approaching.

The rest is assembly: 3D printing for the body, wiring the servos, connecting the display and the touch inputs. Luca Di Lorenzo’s video shows the project in action, and from it you can see how much work lies behind every single gesture Nuvi makes.

The most interesting part remains the amount of personality you can put into a project based on the UNO Q. 3D files, electronics, code and a step-by-step tutorial are available for anyone who wants to build one. And the result, under 30 cm tall, sits comfortably on a desk.

Source: https://projecthub.arduino.cc/lucadilo/nuvi-ai-desk-companion-bdd30c

The post Nuvi: an Arduino UNO Q Desktop Companion appeared first on Open Electronics.

JBR-001 is an open source desktop robot that sees and recognizes the objects in front of it, then reacts with movements, sounds and animations. It was created by syntheticAIdata and built around the Arduino UNO Q 2GB. Inside there are three servos, a camera, a distance sensor, a buzzer and an animated display. So it is not yet another blinking ornament: it is a platform for experimenting with robotics, computer vision and edge AI on a workbench.

Assembly starts from a body of 3D-printable parts that house the board and the rest of the electronics. The head contains the camera, mounted so that it looks straight ahead of the robot. On the back of the same head sits a Modulino Distance, which continuously measures the distance to nearby objects. The arms and the rotation of the head, on the other hand, come from three servos. The mechanics are therefore easy to replicate for anyone who already has a 3D printer at home.

Servo pins and distance thresholds in the code

The three servos split the tasks: one rotates the head, the other two control the arms. In the code the pins are HEAD_SERVO_PIN = 9, LEFT_ARM_SERVO_PIN = 10 and RIGHT_ARM_SERVO_PIN = 11. The rest positions are all at 90 degrees, so HEAD_CENTER = 90, LEFT_ARM_CENTER = 90 and RIGHT_ARM_CENTER = 90. The servos also use a separate external power supply instead of drawing power from the UNO Q: a forced choice when three motors start at the same time.

The distance sensor decides when the robot should notice someone. In the code the detection threshold is DETECTION_DISTANCE = 200.0, while the reset one is RESET_DISTANCE = 250.0. The units are not specified in the project material, so they should be checked on the bench before trusting them. The margin between the two thresholds prevents the robot from switching on and off continuously when someone stays right on the boundary.

Heartbeat on the display, a greeting in notes and the vision model

The robot’s responses go through three different channels. The LED matrix display is driven with bitmaps of 8 rows by 13 columns, the two used for the small and large heart. In the heartbeat animation the delays are 120, 100, 160 and 700 milliseconds, and the last long gap gives the sense of the pause between one beat and the next. The sound greeting playHello instead uses the notes 523 Hz (C5), 659 Hz (E5), 784 Hz (G5) and 1047 Hz (C6), that is a C major arpeggio rising by one octave.

The most interesting part comes from the camera mounted in the head. It connects through a USB-C hub and gives the robot a front view of its surroundings. The captured images can be processed on the UNO Q with a trained computer vision model: this way JBR-001 does not just understand that something is nearby, but identifies the object and uses the result to decide how to react. Consequently the same hardware can turn its head, move its arms, change the image on the display or play a short sequence.

• Arduino UNO Q 2GB as the robot’s brain
• Modulino Distance for continuous distance measurement
• Modulino Motors for motion control
• Modulino Buzzer for sound sequences
• Arduino USB-C Hub (8 in 1) to connect the camera
• Three servos for head and arms
• Camera mounted in the head
• 3D printer for the body parts

On the software side you need Arduino App Lab and the JBR-001 source code, plus a trained computer vision model for object recognition. The project has 1805 views and 2 respects. Anyone who wants to rebuild it starts here: the maker syntheticAIdata’s site, where the code and the instructions to replicate the build are. For the servos, an RC servo control module simplifies the wiring when the channels to drive grow. The project’s distance sensor is a Modulino, and as an alternative you can consider a ToF laser sensor for close-range measurement. The board everything runs on is the 2GB version, while the catalogue also lists the Arduino UNO Q 4GB in a complete kit: same family, more memory for vision models.

Source: https://projecthub.arduino.cc/syntheticaidata/jbr-001-a-desktop-companion-robot-powered-by-arduino-uno-q-b11c96

Related products

• Arduino shield for RC servo control
• ToF Laser Distance Sensor with VL53L3CX
• Arduino UNO Q 4GB – Complete kit with accessories

The post JBR-001: the open source desktop robot that recognizes objects appeared first on Open Electronics.

I am working on a biped robot that I am running using Processing and servo firmata on an arduino uno.  This works fine and I have a decent walking gait.  I would like to include an accelerometer into the robot to give the robot more stability.  So I decided to switch over to standard firmata on the arduino so I can use the i/o.  The problem is that with the standard firmata none of the servos work eventhough the servo library is still included in the standard firmata.  

read more