This project builds a basic electronic door lock with the Arduino UNO R4 WiFi. A touch sensor detects contact, a relay controls a solenoid lock, and an OLED display shows the system status. The principle is simple: touch the sensor, the door unlocks for 5 seconds, then locks itself again. It is a starting point for customizable smart locking systems.
The central board is the Arduino UNO R4 WiFi, which manages the whole flow. The touch sensor sends a signal to the board, which activates the relay to power the lock. The 128×64 pixel OLED display shows the startup, locked, and unlocked screens. The system uses a relay module to separate the control circuit from the power circuit, so the solenoid lock operates safely.
The circuit and components of the lock
Assembly requires few components: the Arduino board, the touch sensor, the OLED display, the relay module, and a solenoid lock. Everything connects on a breadboard with jumper wires. The relay is essential because the lock runs at 12 VDC, while the Arduino operates at 5 V. Without the relay, the lock’s current would damage the board.
The OLED display connects via I2C, using the SSD1306 and Adafruit_GFX libraries. The 128×64 pixel resolution is enough to show the system status with clear characters. The touch sensor connects to a digital pin: when it detects a touch, it sends a high signal to the Arduino. The response is immediate, and the relay trips right away.
The firmware and unlock time
The code is written in the Arduino IDE and uses the SSD1306, Adafruit_GFX, and Adafruit_SSD1306 libraries. The sketch reads the touch sensor state and, when it detects a touch, activates the relay. The display shows the unlock screen for 5 seconds, then the system locks the door again. The unlock time is fixed at 5 seconds, but it can be changed in the code.
The operation is cyclic: startup, waiting, unlock, relock. The OLED display updates the status in real time, so you always know whether the door is locked or unlocked. The project demonstrates the principle of a basic electronic lock, and the maker’s website collects the details for replicating it. It is a simple but complete system.
For assembly you also need a universal acrylic support to keep the Arduino and breadboard tidy. 15 cm male-to-female jumper wires help connect the modules without soldering. The project can be expanded with a numeric keypad, an RFID reader, or a Wi-Fi module for remote control.
In short, this project is an excellent base for anyone who wants to understand how an electronic lock works. The components are few, the code is essential, and the result is functional. With the Arduino UNO R4 WiFi you also have the option to add connectivity in the future, turning the prototype into a real smart lock.
An inexpensive robot kit with Arduino UNO Rev3, obstacle-avoidance sensors, and line-following capability becomes a face-tracking robot. The trick is in the control board: just replace the UNO Rev3 with an Arduino UNO Q, which has the same headers and mounts an STM32U585 microcontroller alongside a Linux microprocessor. Iulia Feroli’s project shows how local artificial intelligence can be added to a low-cost robot without touching the mechanics.
The robot starts from the Elegoo kit, with its motor shield and sensors for obstacle avoidance and line following. The UNO Q slots in place of the original board, and the shield moves over without any modification. Thanks to the STM32 microcontroller and the Linux microprocessor, the new board runs machine learning models locally, with no cloud connection. A standard USB webcam is connected to the UNO Q to provide vision.
Video stream and face tracking
The webcam video stream is processed with the face tracking Brick from Arduino App Lab. The code converts the face position in the frame into movement commands for the robot. The robot rotates to center the face and moves toward it, always staying in front of the person. The result is a responsive face tracker that requires no external servers or Wi-Fi connections.
Iulia Feroli’s project is documented in a video showing the robot in action, with an explanation of the assembly and the code. Swapping the board is the core of the intervention: the UNO Q maintains electrical and mechanical compatibility with the UNO Rev3 but adds the computing power needed for AI. In addition, the face tracking Brick in Arduino App Lab simplifies managing the machine learning model, making the code accessible even to those without neural network experience.
What you need to rebuild the project
To replicate the robot you need only a few components, all easily available. The list includes the Elegoo kit, a USB webcam, and the control board. Here are the main steps:
Remove the Arduino UNO Rev3 from the Elegoo kit and keep the motor shield.
Mount the Arduino UNO Q in its place, checking that the headers align.
Connect the USB webcam to the UNO Q port.
Upload the sketch with the face tracking Brick from Arduino App Lab.
Power the robot and test it in front of a face.
The UNO Q is the heart of the system: it combines the simplicity of the STM32U585 microcontroller with the power of the Linux processor. This combination allows local machine learning models, such as face tracking, to run without additional hardware. The board is also available in a 4GB version with a full accessory kit, which includes everything needed to get started.
The original Elegoo kit, with its Arduino UNO Rev3 board, remains an excellent base for other projects. However, for this face tracker, the UNO Q is the right choice: it offers the necessary computing power and maintains compatibility with the shield. The overall cost stays low, and the result is a smart robot that impresses with its responsiveness.
Let’s find out how to use the MAX7219 to drive an LED matrix. Wiring, Arduino libraries and sketches will guide us through building custom graphic and numeric displays.
An LED matrix display is one of the most fascinating components for anyone starting to experiment with Arduino: with a small square module we can bring to life numbers, letters, symbols and animations that immediately catch the eye. The problem? An 8×8 matrix means no fewer than 64 LEDs to control individually: an almost impossible task without dedicated support. That is where the MAX7219 chip comes in, an IC designed specifically to simplify the management of matrix and 7-segment displays, reducing the connection to the Arduino board to just a few pins. In this article we will see how to connect the MAX7219 to an 8×8 matrix, how to use the ready-made modules available on the market and how to program everything with the LedControl library.
The MAX7219
Fig. 1 Pinout of the chip and of the display.
The MAX7219 chip has 24 pins. The 8×8 display (Fig. 1) is connected so that the rows are linked to the DIG pins and the columns to the SEG pins of the MAX7219.
Brightness is varied in software after setting the maximum current with an external resistor connected to the Iset pin. Three pins are dedicated to communication with the control board: DIN (to transfer data from the board to the chip), CS (for device selection) and CLK (for the data clock). A further pin, DOUT, is used to connect the DIN of the next chip, in case you want to chain several LED matrices together (for example to build scrolling text).
The complete schematic of the connection between the chip and the display is shown in Fig. 2, with particular emphasis on the links to the Arduino board and to a second chip. Using the MAX7219 is made even simpler by the availability on the market of modules (such as those in Fig. 3) that integrate both the chip and the LED matrix, along with the relevant wiring.
Fig. 2 Schematic of the connection between the chip and the display.
Fig. 3 Schematic of the connection between modules and the Arduino board.
Using a module reduces the wiring to just the connections between the module and the Arduino board, and between modules possibly arranged in a chain. Each module has 5 input pins (VCC, GND, DIN, CS/LOAD and CLK, to be connected to a board such as the Arduino UNO R3) and 5 output pins (VCC, GND, DOUT, CS and CLK, for any subsequent modules in the chain). The Arduino UNO R3 board can be replaced by the more recent Arduino UNO R4 versions, available in the Minima and WIFI models, both fully compatible electrically and in software with the previous R3. Both versions keep the same pin layout and are compatible with most shields and libraries already developed for the R3.
Programming with Arduino
Several libraries make programming the MAX7219 easier; among them, in particular, the LedControl library, which is very widespread and simple to use.
An object of the LedControl class is created, to which an identifying name is assigned (for example, LC). The DIN, CLK and CS parameters will be replaced with the numbers of the Arduino pins (for example: 2, 4, 3) to which the respective signals are connected.
LC.SHUT (module_number, 0/1)
Enables or disables the chip. The value 0 makes it operational, while 1 puts it in standby. On power-up, the chip is in standby mode by default. The module_number parameter identifies the module in a serial chain, numbered starting from 0.
lc.setIntensity (module_number, intensity)
Adjusts the brightness of the LEDs, with a value between 0 (minimum) and 15 (maximum). The value 0 does not turn the LEDs completely off; to do that, you need to use LC.Shutdown(module_number, 1).
lc.clearDisplay (module_number)
Turns off all the LEDs of the specified module, clearing the displayed content.
Turns a single LED on or off. row_number and column_number indicate the position of the LED (numbered from 0 to 7). state = true (or 1) turns the LED on, false (or 0) turns it off. Rows are numbered from 0 (top) to 7 (bottom), columns from 0 (left) to 7 (right).
For example, the top-left LED occupies position (0, 0), the bottom-right one (7, 7).
lc.setRow (module_number, row_number, byte)
Lets you turn all the LEDs of a row on or off, specifying their state with a binary byte. For example, to turn on the first four LEDs of a row you use: B11110000.
lc.setColumn (module_number, column_number, byte)
Works in a similar way to setRow, but acts on a column. The byte defines which LEDs to turn on or off in the specified column.
Let’s now look at some practical examples of use.
Example 1
The first sketch, shown in Listing 1, is meant to display the 8 rows in sequence, one at a time, starting from the top; then the 8 columns, one at a time, starting from the left; then the 8 rows starting from the bottom; then the 8 columns starting from the right. Finally, all the LEDs are turned on gradually in pairs of rows, starting from the two middle rows and following the order: 4-5, 3-6, 2-7, 1-8. In this last phase, the lighting happens at low intensity, with brightness varying progressively from 10 to 2.
The first sketch lights up rows and columns of the matrix in sequence.
Example 2
The purpose of this sketch (Listing 2) is to gradually light up the LEDs of the matrix rows starting from the bottom, as a consequence of a voltage varying between 0 V and 5 V set by a potentiometer connected to pin A5; the comments inside the sketch describe how the gradual lighting works.
The second sketch lights the rows gradually as the potentiometer voltage changes.
Using arrays
The goals of the two previous examples can be achieved in a similar way using arrays. One approach is to define the row structure inside an array of bytes (for example in binary): with 8 elements of 8 bits you describe the LED states of the whole display. The first cell of the array corresponds to the state of the eight LEDs of row 0 (from left to right), the second to that of row 1, and so on up to row 7.
If, for example, you want to turn off all the LEDs of the first four rows and turn on those of the last four, you can use the following array:
The purpose of this sketch (Listing 3) is to display in sequence all the numbers between 0 and 9 using 10 arrays that define the numbers and 10 for loops that call them up.
The third sketch displays the digits 0 to 9 in sequence.
Example 4
The fourth sketch shows temperature and humidity thresholds on the matrix.
Fig. 4 Display of the temperature and humidity thresholds.
The purpose of this sketch (Listing 4) is to show when certain temperature and humidity thresholds (set in the program) are exceeded, as shown in Fig. 4.
In the left half of the display (columns 0-1-2) the temperature data is shown, while in the right half (columns 5-6-7) the humidity data is shown.
In the upper part of the display (rows 0-1-2) the letters T and U appear; in the lower part (rows 4-5-6-7) the lighting of the LEDs indicates that a given temperature or humidity threshold has been reached.
Four thresholds are defined in the code: as the value increases, the corresponding rows light up progressively, starting from row 7. Temperature and humidity are measured with the HTS221 sensor, integrated into the STMicroelectronics IKS01A3 expansion board (Fig. 5), mounted on the Arduino UNO board. Those who do not have this board can use other sensors, such as the DHT11 or DHT22, adapting the data acquisition part of the software accordingly.
Fig. 5 The IKS01A3 expansion board.
Conclusion
The MAX7219 makes LED matrix management accessible to everyone, turning a complex task into a fun, stimulating and creative experience. Once you understand the basic commands, the possibilities become practically endless: custom scrolling text, small animations, graphic indicators, simple light games and real-time data visualisations. All that is left is to experiment, adapt the sketches provided and let yourself be inspired: with a simple LED matrix your Arduino project can finally “speak with light” in a clear, dynamic and original way.
Physical AI needs a board that can think and act at the same time. This project pairs a Qualcomm Dragonwing IQ8 processor with an STM32H5 in a dual-brain architecture. The first runs AI models with 40 TOPS, while the second controls motors and peripherals in real time. The result is a complete platform for robotics and automation.
The board carries 16 GB of LPDDR5 RAM and 64 GB of eMMC storage. Connectivity includes tri-band Wi-Fi 6, Bluetooth 5.3, 2.5 Gb Ethernet, and CAN-FD. The board with integrated display from the Arduino UNO Q family offers a similar starting point for anyone approaching this world. The project board is open source and free of proprietary lock-ins.
How the dual-brain architecture works
The Qualcomm Dragonwing IQ8 processor handles the artificial intelligence. The STM32H5, on the other hand, guarantees deterministic control over motors, CAN bus, and other peripherals. The two processors communicate efficiently, so the AI can make decisions and the hardware executes without unpredictable latencies.
The preinstalled operating system is Ubuntu with an Ubuntu Pro license. The Arduino core runs on Zephyr RTOS, which offers guaranteed response times. In addition, the environment supports VS Code, PyCharm, Jupyter, and Docker for development.
AI models optimized for the NPU run through Arduino App Lab. The platform supports importing GGUF models from Hugging Face and training with Edge Impulse Studio. There are over 100 ready-to-use examples.
40 TOPS of AI power
16 GB LPDDR5 RAM
64 GB eMMC
Tri-band Wi-Fi 6 (2.4/5/6 GHz)
Bluetooth 5.3
2.5 Gb Ethernet
CAN-FD
Why a board for Physical AI is needed
Modern robotics requires perception, decision, and action in a single device. This board unifies everything in an open format. Makers can prototype with Arduino UNO shields and Raspberry Pi HATs. Moreover, ROS 2 support and the CAN-FD, I2C/I3C, SPI, PWM, and UART interfaces make it suitable for professional projects.
Compatibility with existing shields lets you reuse sensors and actuators you already own. For example, those with the more powerful processor board from the Raspberry Pi family can compare performance. In addition, the Works with Arduino program allows scaling prototypes to production level with certified SOMs from SECO and Toradex.
An open ecosystem for physical AI
The board uses Ubuntu Pro as its main operating system. Zephyr RTOS handles real-time hardware control. This mix ensures flexibility for development and robustness for execution.
Arduino App Lab is the access point for AI models. It supports importing from Hugging Face and training with Edge Impulse. There are also over 100 ready-made examples to get started right away.
The board is powered by a 65W USB-C power supply. It is designed for those who want to move from prototyping to production without changing platforms. Finally, support for Arduino shields and Raspberry Pi HATs makes it versatile.
For those starting out with embedded AI, the board with the STM32 microcontroller offers a simpler alternative. However, this board represents the next step for advanced robotics projects. Physical AI thus becomes accessible to makers, educators, and professionals.
You step into a fitting room carrying two jackets and a pair of trousers. You like each piece, but you are not sure they work together – and which jacket is better. Normally, you would take a photo, message a friend, or walk back outside to ask a store assistant. But imagine if you could simply look into the mirror and tap “Scan your look” instead.
A few seconds later, the mirror recognizes what you are wearing, identifies colors, and suggests how you might complete the outfit. Perhaps with a shirt or an accessory – available in the store – that will tie everything together.
This is the experience behind the Smart Mirror example running on VENTUNO Q. It begins as a personalized style advisor, but it also points towards a new kind of retail experience: one in which physical spaces can understand what customers are doing and offer relevant guidance in real-time.
We recently published a full tutorial on Arduino Docs that you can follow to build your own Smart Mirror with the board. While straightforward to replicate, we think this use case is very interesting both from a technological and an experiential standpoint. Let’s dive in.
A mirror that understands what it sees
The Smart Mirror application uses a USB camera to provide a live video feed. When you tap “Scan your look”, the latest camera frame is analyzed locally on VENTUNO Q by the Qwen3-VL Model, accessed through the Arduino VLM Brick.
The model is built to analyze the image, identify the most prominent garment and its color, and return two short sentences: a description of the outfit and a related styling suggestion. The result is then displayed directly over the live camera view.
The experience is designed to be intentionally simple: just look in the mirror, start the scan, and receive an immediate recommendation.
Behind that simple interaction, however, several components are working together:
Continuous camera acquisition
Local visual AI inference
Prompt-controlled text generation
A browser-based user interface
Real-time communication between the frontend and the application
This combination is what makes the example useful as more than a technical demonstration. It shows how visual AI can become part of a complete user experience.
From demo to retail use case
With a Smart Mirror powered by VENTUNO Q, customers don’t need to go through racks or search through the store’s catalog. Once they find one piece they like, the mirror recognizes the garment and provides an immediate suggestion: “You’re wearing a navy jacket. Try pairing it with light-colored trousers for more contrast.” And that is only the beginning.
Connected to the retailer’s catalog and inventory system, the same application could recommend matching products that are currently available in the store. It could show alternative colors, suggest accessories, display available sizes, or generate a QR code that allows the customer to save the outfit on their phone.
In this scenario, the Smart Mirror is no longer just giving generic fashion advice. It becomes part of the retail experienceand connects visual understanding with real business information – providing a concise and relevant response.
Why local AI matters: all privacy, no latency
One of the most important characteristics of the example is that the Vision Language Model is designed to run locally on the board. The camera image does not need to be sent to an external cloud service for inference: the image is processed on VENTUNO Q, and the generated answer is returned directly to the local browser interface.
This matters, especially in camera-based applications. By processing images locally, developers can design experiences in which visual data remains closer to where it is generated, potentially reducing the need to transmit image data to external services and helping protect user privacy.
It also reduces dependency on network latency and external AI services. The application can remain responsive even when the internet connection is slow, unreliable, or unavailable.
Turning AI output into a product experience
In the Smart Mirror example, the prompt is designed to produce a very specific result. The model is asked to identify the main clothing item, detect its color, and provide a short styling suggestion. The application also randomizes the opening phrase and the start of the recommendation to provide variation across repeated scans. For this example, the prompt behavior can be customized through a single prompt.py configuration file.
This is a small detail, but it illustrates an important point. The model in this example is configured with a relatively low temperature and a short token limit, helping it produce concise and predictable responses. In a commercial retail application, the prompt could be expanded with product rules, brand guidelines, seasonal collections, availability data, or customer preferences.
How the application works
The technical architecture is designed to be streamlned. The camera continuously captures frames, and the latest frame is stored in a shared buffer. The browser displays the live feed through an MJPEG stream exposed by the backend.
The generated result is then sent back to the browser and displayed in the mirror overlay.
In the code, the application uses two App Lab Bricks: the Vision Language Model Brick and the Web Interface Brick.
The camera could be replaced with another image source. The prompt could be adapted to a completely different domain. The web interface could be redesigned for a kiosk, a touchscreen, or an embedded display.
Beyond fashion
The most valuable lesson from the Smart Mirror example is that the architecture is not limited to clothing: the same model can be applied in several domains.
Assisted dressing: The system could help users identify colors, distinguish garments, or check whether items match. For people with visual impairments, it could describe the clothing they are currently wearing. For the elderly or users who need cognitive support, it could provide simple guidance when choosing an outfit.
Beauty and personal care: A similar mirror could support makeup tutorials, eyewear selection, hair styling, or skincare routines. The camera would analyze the visible situation, while the prompt and application logic would determine what type of recommendation is appropriate.
Hospitality: A hotel-room mirror could provide recommendations based on guests’ clothing, the weather, the planned activity, or the dress code of a venue. For example, it could suggest bringing a jacket before an evening event or recommend more comfortable footwear for a walking tour.
Industrial operator assistance: The same architecture can also move from consumer applications to professional environments. Instead of recognizing a shirt or jacket, the model could identify tools, machine components, labels, or personal protective equipment. An operator could stand in front of a workstation and receive a short visual instruction: “You are not wearing safety goggles. Put them on to protect your eyes before starting the machine.”
Such systems would require careful validation and should not replace certified safety mechanisms. But the Smart Mirror example shows the underlying technical pattern clearly: a camera observes the situation, a model interprets it, and the application provides immediate guidance.
A reusable pattern for Physical AI
Advanced users like Kamitronix have already been experimenting with Smart Mirrors built with the Arduino® UNO Q board, providing real-time feedback and information as you check out your look before going out. But while these may appear to be mainly user-interface applications, they also point toward a broader Physical AI workflow. Instead of a text on a screen, the final response could activate a light, control a motor, change a machine setting, notify an operator, or trigger another application.
That is why examples like the Smart Mirror are useful. They make advanced AI capabilities approachable, but they also reveal a reusable architecture for building systems that interact with the real world.
We started with a simple question: What if a mirror could understand what you are wearing? Mapped to a real-world use case, it can become an AI-assisted fitting room that recommends matching products, connects customers with inventory, and improves the in-store journey. More broadly, the same architecture can support assistive technology, hospitality, personal care, and industrial operator guidance.
The most interesting part is the pattern it demonstrates: using local visual AI to transform a passive object into an interface that can understand its context, respond in real-time, and improve people’s experience.
VENTUNO Q is also available through our official distribution partners: DigiKey, Farnell,Kubii, Mouser, Robu.in, and RS, along with our other authorized distributors and resellers.
Arduino, UNO, VENTUNO, and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.
Luca Di Lorenzo (@LucaDilo on YouTube) recently worked with us on what was meant to be a simple robot assistant, but soon became something much more fun: a tiny, expressive desktop companion that notices you, listens to you, and talks back. Based on the Arduino® UNO Q board, Nuvi is designed to run everything it needs on-device, no internet required for the core experience.
We think it’s the cutest, but maybe our team is partial to the project because the whole Arduino office in Turin, Italy loves its real-life inspiration: Kaito, the Shiba Inu our colleague Assunto sometimes brings to work.
Di Lorenzo says Nuvi’s first design worked but felt like a machine. With Kaito as a reference, he was able to find the inspiration to build something we would all actually want on our desk.
Talk to it and control your smart home
Nuvi is under 30 cm tall (approximately 12 inches) and packs a surprising amount into that compact form. It is built to wake up when you approach, responds when called by name, and holds a conversation powered by Gemini – which handles both understanding speech and generating replies in a single step, with no separate speech-to-text layer. For speaking without the cloud, Nuvi uses Piper, a voice engine running entirely on the board, so responses feel immediate. It can search the web when needed, toggle smart home devices by voice or a hand gesture, and read out room temperature and humidity when you flash it an open palm.
Beyond conversation, Nuvi has animated eyes that express different moods, moving ears and arms, head pan and tilt, touch reactions on its head and belly, and — just for fun — a dance.
How UNO Q makes this possible
Nuvi runs on UNO Q, and the board’s dual-brain architecture is exactly what a project like this one needed. The real-time microcontroller side is designed to handle all the physical control: four servos for the arms and ears, two serial servos for the neck, the display, sensors, and touch inputs. Meanwhile, the Linux side is built to run the AI pipeline, the voice engine, and the application logic. Everything lives on the board itself, not on a connected PC. Two jobs, one board, no compromises.
Build your own desk companion!
Di Lorenzo shares everything you need right here on Arduino Project Hub: 3D files, electronics, code, and a full step-by-step tutorial. If you’ve been looking for a project that shows just how much personality you can pack into a UNO Q build, this is it. Of course, feel free to customize it to resemble your favorite pet!
UNO Q is available on the Arduino Store, and can be ordered from DigiKey, Farnell, Mouser, Newark, RS Components, Robu.in, and other authorized distributors and resellers worldwide.
Arduino,UNO, and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.
Expense calculations in the industrial world tend to be unintuitive to individuals, because service and maintenance often consume larger chunks of the budget than the equipment itself. For that reason, modifications to equipment are usually seen as too risky to justify — they can too easily impact serviceability. So, what do you do when you want to bring an old piece of equipment into the modern age? Michael Bryan Ross’ solution was to use AI to look at analog gauges.
Ross wanted to address a simple and common problem: the equipment has an analog gauge and it would be nice to have that value available in digital form for monitoring and logging.
Most of us, when presented with that problem, would take the easy and seemingly reasonable approach. That might be something like replacing the analog gauge with a microcontroller outfitted with an ADC (analog-to-digital converter).
But very few plant managers or manufacturing engineers are going to give the green light on a modification like that. Not only is there upfront downtime to consider, but it also puts the equipment and future serviceability at risk.
Ross’ solution, on the other hand, is much easier to approve. That’s because it doesn’t require any modification to the equipment at all. In fact, it doesn’t even need to make physical contact with the equipment.
It works by using a camera and AI running on the edge to read the analog gauge. In this case, “the edge” is an inexpensive Arduino® UNO Q and it looks at the gauge through a standard USB webcam. The UNO Q runs a MobileNetV3-Small model through ONNX Runtime.
To test that — and to gather the images needed to train the model in the first place — Ross built a physical device with a real analog gauge driven by an actual pressure sensor. To create a training data set, Ross simply collected a bunch of images of the gauge’s needle in different position, then had GPT-5.6 read the black ticks to classify them by numeric value.
Ross acknowledges that the resulting model isn’t perfect. In particular, it tends to lose accuracy at very high and very low ends of the gauge range. But that is a fixable problem (largely through training). The concept holds: that this approach makes it possible digitize analog gauges, without spending much money and without modifying equipment.
Go on your favorite online shopping platform, and you’ll find any number of smart doorbell options. Click to purchase, have it delivered, install it, download some app. But where’s the fun in that? And also, don’t you wonder how that thing works?
That thing that watches you and your loved ones go in and out, learning to recognize friends and delivery people, helping you check on your home even while you are gone. If you are thinking about the security of the place where you live, why not be more hands-on about your privacy while you’re at it?
Of course, we have an easy (even fun!) solution to these concerns: just build your own smart doorbell, and have complete control – not only over who comes and goes, but also over where your data is stored and how it’s handled.
Massimo Banzi and Andrea Richetta are going to show you how to build your own smart doorbell, based on a computer vision model that can run locally on the Arduino® UNO Q board.
Just click the ‘notify me’ button and follow the live build, on September 22nd at 3PM CET / 9AM ET. In one hour, we’ll see the whole project come together – and you’ll have a chance to ask questions directly to the Arduino team.
The heart of the entire cyberdeck movement is personalization. Instead of shopping within the limits of what manufacturers deem to be marketable, cyberdeck builders can create designs that reflect their own personal tastes. But even so, most cyberdecks fit within a fairly narrow aesthetic—usually some variation of cyberpunk or cassette futurism, fitting the original Gibson source material. Natasha Dzurny (AKA TechnoChic) took things in a completely unique direction by building her Arduino® UNO Q cyberdeck as an Avenue Q-style puppet.
Avenue Q is musical that originally appeared off-Broadway way back in 2003 and has since enjoyed stints on Broadway, the West End, and Las Vegas. It is, essentially, a humorous adult spin on Sesame Street, which means it has all kinds of Hensonian puppets. Dzurny’s interest in Avenue Q and its phonetic similarity to “Arduino Q” led to this creation.
The electronic components are standard fare for a cyberdeck and include the UNO Q (2GB), a mini Bluetooth keyboard/touchpad device, a portable USB battery pack, and a 5” HDMI display. There is also a mini USB webcam hidden away for recorded puppet shows.
The real magic and creativity went into the “enclosure,” which is really the body of the puppet. To craft that, Dzurny started with a spherical mold made of translucent plastic. She then cut that to shape and built a frame structure inside, onto which she could mount the components. Once covered in thick fur, the sphere became a puppet head that Dzurny could put her hand into, so she could open and close the mouth. A couple of big expressive eyes completed the look and a chain strap made the puppet/cyberdeck easy to carry.
Dzurny’s project is the perfect example of why people love cyberdecks: because they’re a perfect outlet for creative expression that reflects the builder’s own personality.
Every day, hundreds of thousands of kits are prepared in warehouses before components ever reach an automotive production line. While robots have become commonplace in modern manufacturing, many upstream logistics activities still rely heavily on human operators performing repetitive pick-and-place and kitting tasks.
What if robots could learn these operations the same way humans do: by simply watching a demonstration?
That question was at the heart of I-GENIUS, a research project coordinated by MYWAI within the European ARISE initiative with Centro Ricerche FIAT (CRF) and the University of Genoa’s Department of Mechanical, Energy, Management and Transportation Engineering (DIME).
The project explored new approaches to Human-Robot Interaction, combining AI, computer vision, and robotics to enable machines to acquire manipulation skills from minimal human guidance.
One of the project’s key outcomes was VILMA (Visual Imitation Learning for Manipulation Activities), an AI-powered toolkit integrated into MYWAI’s EDGE AI middleware platform. VILMA helps enable robots and humanoids to learn complex manipulation tasks from one-shot human demonstrations, aiming to significantly reduce programming effort while improving flexibility in dynamic industrial environments.
The technology was evaluated in a large-scale automotive warehouse use case developed together with CRF and reproduced within the robotics laboratories at DIME.
Today, MYWAI is bringing this technology to a broader community of developers, makers, and robotics innovators by porting the VILMA Toolkit to new Arduino products powered by Qualcomm Dragonwing processors, including both the Arduino®UNO Q and VENTUNO Q boards.
This demonstration showcases the potential for edge-native robotics applications that use imitation learning techniques on hardware platforms built to support compact form factors and efficient power consumption.
At the iGenius final presentation, the founder and CEO of MYWAI, Fabrizio Cardinali, stated: “The dual-brain architecture of the UNO Q and VENTUNO Q platforms is an ideal foundation for MYWAI’s next generation of Edge AI robotics. After validating distributed intelligence concepts within the ARISE I-GENIUS project, we are now leveraging these platforms to bring World Action Models closer to the edge through the latest release of the MYWAI EdgeAI Management Platform and its mobile tracker, HEDGELOG. By combining One-Shot Video Imitation Learning with edge-native AI execution, we aim to enable robots and intelligent industrial machines to acquire, distribute, adapt, and execute complex manipulation skills with unprecedented flexibility and scalability.”
Watch the full demonstration of the I-GENIUS project and see VILMA in action in this video.
The MYWAI VILMA agent
VILMA is a visual imitation learning toolkit that helps enable robots to learn manipulation tasks from human demonstrations. It is designed to process RGB-D recordings or MP4 videos to extract hand and object trajectories, generate reusable robot skills using Dynamic Movement Primitives (DMPs), and produce robot-ready trajectories for playback. It is constructed to serve as the demonstration learning module, supporting rapid robot programming, skill reuse, and deployment.
The AI pipeline
One-shot demonstration acquisition
The one-shot demonstration acquisition step is set to record a human performing the task or retrieve an existing demonstration from a selected MYWAI equipment event. It stages the video, RGB frames, depth data, and camera parameters, and allows the user to select the target object for tracking. This information provides the inputs required by the remaining pipeline stages.
Hand detection
Using MediaPipe, this stage is structured to detect 21 hand landmarks in each RGB frame and combine their 2D positions with depth data to calculate 3D camera coordinates. For demonstrations loaded from MYWAI, the staged RGB and depth data are processed through the same pipeline. Kalman smoothing and previous-position retention improve tracking robustness, and the resulting trajectories can be saved back to the MYWAI event.
Object detection
Using a YOLO model, this stage is designed to detect or track the object selected through the local or MYWAI interface. It combines the bounding-box centre with depth information to calculate the object’s 3D position, applies Kalman smoothing, and saves the trajectory and annotated frames. These results can then be included in the pipeline artifacts stored in MYWAI.
Trajectory and segmentation
This stage is constructed to load the smoothed hand and object trajectories, estimate the grasp point from the hand’s proximity to the object, and detect the release point from the object’s movement and stabilization. It uses the hand trajectory as the main motion path and divides it into reach, grasp, move, release, and post-release phases. The trajectories, event indices, and segmentation metadata can be packaged as MYWAI event data, a time and space data fusion format developed by MYWAI for its AI-IoT management platform particularly geared towards Multimodal AI and, next, towards World Action Models.
DMP generation
The DMP-generation stage is designed to learn separate Dynamic Movement Primitive models for the reach and move phases. It evaluates different regularization values, selects the model that provides the best accuracy and smoothness, validates the reproduced motion, and saves the trained models and trajectories. These DMP artifacts can be uploaded to MYWAI with the other pipeline results for later retrieval and reuse.
Demonstration
The demonstration stage is structured to convert the generated DMP trajectory into Cartesian robot positions using the configured scale, offset, and rotation, then apply inverse kinematics to calculate the joint trajectory. The robot model may be loaded from the selected MYWAI equipment, and the resulting motion is displayed through the MYWAI 3D Viewer, synchronized with the recorded video and its grasp and release events.
DMP adaptation with new goal and new object
The adaptation stage is set to load the learned skill – either from the current pipeline or a restored MYWAI event – and detect a new target object using RGB and depth data. It calculates the 3D offset between the original and new objects, redirects the reach and move trajectories toward the new pick and release positions, and preserves the demonstrated motion characteristics. The adapted trajectory can then be visualized with the MYWAI 3D Viewer or sent to the robot.
Live streaming adaptation and UNO Q and VENTUNO Q support
The Live stream phase represents the deployment and real-time inference stage of the VILMA Agent. While the initial learning phase is conducted on the MYWAI platform to generate Dynamic Movement Primitives (DMP), the Live stream phase focuses on shipping these DMPs along with a fine-tuned YOLOv8 model, supported today on UNO Q and VENTUNO Q.
Architecture and components
As illustrated in the system schematic below, the architecture is designed as a distributed setup divided into an Edge AI Layer for intelligence and a Communication Layer for hardware interfacing.
Let’s break down how the live stream pipeline is working considering the VENTUNO Q version.
1. Edge AI layer (VENTUNO Q)
Running on VENTUNO Q, this layer is structured to handle high-level decision-making.
VILMA Control Loop: The primary application logic responsible for the overall control loop. It It is designed to orchestrate object detection and performs DMP Adaptation to translate learned human motions into the current physical environment.
Video Object Detection Brick: This component runs on VENTUNO Q to manage the inference flow. It receives the incoming video feed and communicates with the inference service.
Docker: YOLOv8 Inference Service is formed as a containerized service that runs the quantized YOLOv8 model. This model is designed to be fine-tuned and deployed via the Edge Impulse platform using the “Bring Your Own Model” feature.
2. ROS 2 communication layer (Workstation)
A separate workstation connected directly to the devices manages the high-bandwidth data streams and robotic control via ROS 2.
ROS 2 Streaming Node: Interfaces with the ZED Camera/Depth Sensor to capture raw visual data, publishing it as a /camera_feed to VENTUNO Q.
ROS 2 Command Node: This node acts as a wrapper around the Fairino Python SDK. It is engineered to serve as the receiver for the /learned_trajectory sent from the edge device, utilizing the SDK to directly control the robot and help ensure it accurately follows the planned trajectory.
3. Physical hardware
External hardware is connected to complete the runtime VILMA ecosystem, namely:
ZED Camera: The stereo camera which is engineered to capture the image and depth data required for the vision system.
Fairino FR10 Robot: The robotic arm that is constructed to execute the pick-and-place tasks based on the trajectories computed by VILMA.
Component communication and data flow
The communication between these components is designed for low-latency execution as shown in the schema above:
Vision Input: The Workstation is engineered to stream the /camera_feed (image and depth) to VENTUNO Q.
Edge Inference: The VILMA Control Loop is designed to utilize a WebSocket stream to send frames to the Docker YOLOv8 Inference Service. The service returns the detected object bounding box to the control loop.
Motion Adaptation: The system is structured to take the detected object positions and adapts the human-learned DMP to calculate a precise pick-and-place trajectory.
Robotic Execution: The resulting /learned_trajectory is published back to the Workstation’s ROS 2 Command Node, which drives the Fairino FR10 robot to complete the task.
This modular approach is designed to allow the heavy vision processing and motion adaptation to happen on the edge (VENTUNO Q) while leveraging the robust ROS 2 ecosystem for robot communication and sensor streaming.
To learn more about the project and MYWAI’s EDGEAI Platform and Middleware, visit myw.ai.
Qualcomm branded products are products of Qualcomm Technologies, Inc. and/or its subsidiaries.
Arduino, UNO, and VENTUNO are trademarks or registered trademarks of Arduino S.r.l.
