Spark - An AI Emotional Companion Robot

Spark: An AI Emotional Companion Robot

A small robot that sees, hears, understands, and answers with emotion, touch, voice, and expressive movement. Built on the Arduino UNO Q for about ₹10,000.

What is Spark?

Most of us talk to AI through a screen or a speaker. Spark gives that AI a body.

Spark combines voice, vision, touch, animated OLED eyes, servo-driven ears, and motion sensing into one small robot. Pet it and it reacts. Pick it up and it knows. Say "Hey Spark" and it wakes, listens, thinks, answers out loud, and shows how it feels.

Instead of the usual voice > AI > voice loop, Spark works like this:

human > sensors > AI > decision > physical reaction

One idea runs through the whole design: the robot should belong to its owner, not to an AI company. You choose the model, the speech system, and the tools Spark uses.

What Spark can do

👁️ See: A camera feed goes to an object-detection model, and Spark's eyes follow what it finds

👂 Hear: A custom "Hey Spark" wake word, then speech-to-text

🧠 Think: An LLM decides what to say and which tools to use

🗣️ Speak: Text-to-speech through the on-board speaker

👀 Express: Animated OLED eyes and mouth show emotions

✋ Feel touch: Six capacitive sensors detect petting and taps

📐 Feel motion: An IMU detects being picked up, tilted, bumped, or shaken

👂 Move: Two servo-driven ears add body language

🏠 Use tools: The AI can control external systems such as Home Assistant

How Spark works: a brain and a body

The most important design decision was to separate thinking from moving.

The Arduino UNO Q has two computers on one board: a Linux processor (MPU) and an STM32U585 microcontroller (MCU). Spark uses each for what it does best.

The brain (Linux side)

The Linux side runs everything that needs an operating system and more computing power:

• Wake-word detection
• Speech-to-text
• LLM communication and reasoning
• Text-to-speech
• Computer vision
• High-level behaviour, tool calling, and integrations

An AI gateway routes requests to different services. Spark can use a local LLM (LM Studio or Ollama) when privacy and independence matter, or a cloud model through OpenRouter when it needs more capability. Speech recognition and text-to-speech can be swapped the same way.

The body (STM32 side)

The MCU handles everything that needs fast, predictable timing:

• OLED eyes and mouth
• Touch sensors
• Ear servos
• IMU

The brain decides what Spark wants to do. The body makes sure it happens reliably.

One emotional state

Spark keeps a single central emotion state. An AI reply, a touch, or a physical event can each request an emotion, and that one state is turned into eye animations and ear movements. Every part of the robot reacts in the same way.

The loop is: Sense > Understand > Decide > Express.

Vision and wake word

Arduino App Lab provides the camera feed and AI perception, and an object-detection model uses that feed to move Spark's eyes. I trained a custom keyword-spotting model in Edge Impulse for "Hey Spark", so Spark only starts its voice pipeline when it hears its name and does not process every conversation.

Meet the parts of Spark

The head is built from a few printed parts, four PCBs, two servos, and a translucent front.

• Top head PCB (touch sensors)
• SG92R servos (ears)
• Servo holder
• Spark's ears
• Head PCB (eyes and mouth)
• Head back panel
• Translucent acrylic front

Build guide

The build has five stages. Test the electronics on the bench before closing everything inside the enclosure.

• Make the four PCBs
• Set up the software and bench-test
• Assemble the head
• Assemble the body
• First power-on

Step 1: Make the four PCBs

Spark uses four PCBs:

• Head PCB: Eye and mouth OLEDs, LDR
• Top head PCB: The six touch sensors
• Amp + IMU PCB: Audio amplifier and motion sensor
• Power PCB: Power distribution

Pick whichever way suits you:

• Order them. Upload the Gerber files from the repo to any PCB manufacturer.
• Etch them yourself. Print and etch. This is how I made my prototype.
• Use perfboard. The circuit is simple, so custom PCBs are not required.

The schematic PDF has every connection is attached bellow.

Note: Spark is an actively developed prototype. Treat the repository version used for this guide as the reference version.

Step 2: Set up the software and bench-test

Do this with the boards still outside the enclosure, so you can fix problems easily.

1. Clone the repo

git clone https://gitlab.com/mayur-454/project-spark.git

2. Import the App Lab app

Open Arduino App Lab and import the app projectspark. Then edit the .env file and set:

• the IP address of the camera phone running the CCTV Cam app
• the keyword-spotting model

My custom "Hey Spark" model is not public yet. Use the default "Hey Arduino!" model, which is already included.

3. Set up the LLM gateway

Go to scripts/llm-gateway and edit the .env credentials. You can use a cloud LLM through OpenRouter, or a local one through LM Studio or Ollama.

4. Flash the STM32

Open mcu/robot.ino in the Arduino IDE (or use Arduino CLI) and upload it to the UNO Q.

✅ Checkpoint: once flashed, the eye and mouth OLEDs should come alive on their own, without App Lab or any Python running. That is expected, and it means the body works.

5. Start the App Lab app

6. Run the main script

Run it manually:

python3 main.py

That is fine for a first test. For everyday use, set up main.py as a service so it starts on every boot. If main.py is not running in the background, nothing happens: the eyes and mouth light up, but Spark never listens or thinks. The repo shows how to set up the service: project-spark on GitLab.

✅ Checkpoint: the electronics and software are now working. Next, put them into the enclosure.

Step 3: Assemble the head

The head holds the eyes, mouth, touch sensors, and ear servos. These renders show the 3D-printable head design, and all the printable parts are attached to this article and in the repo. My own prototype uses a PVC enclosure, so some mounting details differ (I note them where they matter). All screws are M3 × 8 mm.

3.1 Install the top head PCB (panel 1)

Mount the top head PCB, the one with the six touch sensors, first, because it sits at the top of the head. The render shows it seated in the shell's guide slots. I fixed mine with hot glue, because I had no printed parts to test a proper mounting mechanism on.

3.2 Install the ear servos (panels 2 to 4)

• Place each SG92R servo in its cradle on the inner side wall, with the output shaft pointing out through the round opening in the shell.
• Lower a servo holder over the servo so it clamps the servo against the shell wall and lines up with the screw holes.
• Fasten each holder with two M3 × 8 mm screws.

The servos do not plug into any PCB in the head. Their cables run out through the back panel to the body and are wired there.

3.3 Attach the ears (panel 5)

Press each ear onto the servo's spline shaft from the outside. [TIP: if you centre the servos before pressing the ears on, both ears start level. Keep or delete.]

3.4 Install the head PCB (panel 6)

Insert the head PCB through the open front of the shell. This is the board with the two 1.3" eye OLEDs and the 0.91" mouth OLED, with the mouth below the eyes.

3.5 Close the back panel (panels 7 and 8)

Align the back panel with its screw holes and secure it with M3 × 8 mm screws. The rectangular slot is the cable exit: the servo cables and the head wiring leave the head through it.

3.6 Press in the smoked acrylic front (panel 9)

Press the smoked acrylic into the front opening. It is a friction fit, so it needs no glue or screws. It hides the display edges and lets the eyes and mouth glow through.

✅ Checkpoint: the ears sit level, the back panel is closed, and the acrylic is snug. You will test the displays and ears once the head is wired to the body in Step 4.

Step 4: Assemble the body

🖼️ [BODY ASSEMBLY GRID IMAGE: coming soon

• 4.1 [Mount the UNO Q in the body]
• 4.2 [Install the amp + IMU PCB]
• 4.3 [Install the power PCB and connect power]
• 4.4 [Mount the speaker, microphone, and sound card]
• 4.5 [Connect the head to the body: cable routing]
• 4.6 [Mount the camera phone or camera module]
• 4.7 [Close the body]

The enclosure: the body is up to you. My prototype uses a reshaped PVC pipe (see the budget section below), and the 3D-printable parts are attached to this article. An old Android phone or a camera module both work as the camera.

The enclosure: the body is up to you. My prototype uses a reshaped PVC pipe (see the budget section below), and the 3D-printable parts are attached to this article. An old Android phone or a camera module both work as the camera.

Step 5: First power-on

Try these in order:

• Say "Hey Spark" (or "Hey Arduino!" with the default model). The eyes should react and Spark should listen.
• Ask a question. Spark should answer out loud and show an emotion.
• Touch the top of its head. It should react to being petted.
• Pick it up or tilt it. The IMU should trigger a reaction.
• Show it something. The eyes should follow it.
• Ask it to control something through Home Assistant.

Troubleshooting

These are the problems I actually hit. The exact fixes and commands are in the project-spark repo on GitLab.

The UNO Q has only one USB-C port. A USB sound card needs a USB-A port, and a normal USB-C hub works on the bench but is too bulky for a small robot.

The JMISC audio input did not work. I planned to use the UNO Q's JMISC connector for audio in and out. Audio in never worked, even after a lot of testing and reformatting the board. I never tested audio out, because audio in is the part Spark needs most. So USB audio was the only option.

The OTG adapter gave no 5 V. I bought a small, cheap USB-C OTG adapter. The UNO Q's USB-C port would not supply 5 V through it, so the sound card had no power. The fix was to wire the board's 5 V output to the VCC line of the OTG cable. After that, recording and playback both worked. Check polarity and voltage before you connect it.

The sound card was not detected after a reboot. After a few reboots the UNO Q did not initialise the USB sound card correctly, and I had to unplug and replug it. A command fixed this, and it is in the repo.

Spark does nothing after boot. The eyes and mouth run on the MCU, so they work on their own. If main.py is not running as a service, Spark never listens or answers. Check that the service is running.

Designing Spark on a budget

My target was about ₹10,000, so I could not buy a polished robotics platform or outsource every part.

A professionally fabricated 3D-printed body was quoted well above what I could justify, so I reused what I had and built my prototype's body from a reshaped old PVC pipe. It is not the prettiest solution, but it let me spend the money on parts that mattered for the demonstration: the UNO Q, sensors, displays, audio hardware, and actuators. I also designed the body as 3D-printable parts, and all the files are attached to this article. I have not printed them myself, so the PVC prototype and the printable design differ in how things mount. For example, I fixed the top head PCB with hot glue.

Spark is closer to a maker prototype than a commercial product, and that is part of the point. A physical AI robot does not need a large budget.

What went wrong, and what I learned

Hardware integration. Every part worked on its own. Together they did not: USB audio, the microphone, the speaker, and the Linux software pipeline all had to cooperate, and that took the most debugging.

Two computers on one board. The MPU and MCU are powerful together, but the link between them is a place where things break. I kept high-level AI behaviour on one side and deterministic hardware behaviour on the other. Lesson: modularity helps, but every interface between modules is another possible point of failure.

Budget. I could not fix problems by buying better parts, so enclosure, sensors, and audio had to be balanced against each other. Several ideas were simplified or postponed.

Scope. The biggest lesson was learning when not to build something. I focused on one loop, See / Hear > Understand > Respond > Express, instead of adding features that could fail during the final demo.

Power. The boost converter I tried could not reliably power the UNO Q from a 3.6 V LiPo, so the prototype runs on external power.

What the prototype proves

Spark is a complete physical-AI architecture, not a single AI feature:

• Arduino UNO Q: a Linux AI system (speech, vision, LLM, tools, TTS) plus robot control (eyes, ears, touch, motion, audio)
• Swappable parts: a new AI model does not need a rebuilt robot, a new tool does not need a rewritten personality, and a new sensor can be added to the physical layer

Because the AI uses tools, new abilities do not have to be hard-coded. Spark already works with Home Assistant. The same design could later let it control smart-home devices, run personal automations, access local information, control other robots or IoT devices, and use locally hosted AI services.

What I would improve next

• A cleaner, more durable enclosure
• Better cable management and internal construction
• Smoother eye and ear animations
• More reliable touch and motion reactions
• A bigger tool ecosystem
• Better local AI and less dependence on external services
• A web UI for conversation history and analytics

All of this can be done step by step, because the architecture is modular.

Final thoughts

Spark began with one question: what would an AI assistant feel like if it had a physical body, and its owner actually controlled it?

The result is a budget-friendly, modular prototype showing that AI does not have to be tied to a single cloud ecosystem. It is not a finished product, but it shows that AI can sense the world, react to people, express itself physically, and stay open enough to keep evolving.