ArduinoMania

The Nano is one of the most recognizable Arduino boards in the world. Compact, accessible, and endlessly versatile, it has powered millions of projects across a variety of domains. Today, at electronica 2026 (Munich, November 10–13, 2026), we’ve announced what comes next for the ecosystem – and it’s designed to take everything the Nano does well into a new territory: industrial, home, and building automation.

Meet the Nano XL Link board and the Nano XL Link Connector Carrier.

A Nano designed for automation

Nano XL Link keeps what you love about the original form factor – compact dimensions, familiar pinout, and full Arduino^® ecosystem compatibility – while adding three on-board fieldbus transceivers: CAN FD, RS485, and 10/100 Ethernet. With no external interface hardware required, you can connect directly to industrial networks, motor drives, building automation buses, smart sensors, and touch panels from a board that fits in the palm of your hand.

Under the hood, Nano XL Link is powered by a Microchip PIC32CK2051SG01144 – a 32-bit ARM Cortex-M33 running at 120 MHz, with 2 MB of Flash and 512 kB of RAM. This is a microcontroller designed to deliver the deterministic real-time performance and reliability required for both demanding factory floors and complex building management systems. Plus, the extended double-row header expands the standard Nano pinout significantly, giving you the expanded I/O availability that complex automation applications may require.

That’s how Nano XL Link helps bridge the gap between the Arduino community’s fast prototyping culture and the demands of professional deployment. Real-time machine controllers, fieldbus gateways, smart lighting and HVAC zone managers, automated energy management nodes, and more! Nano XL Link is designed to give you the connectivity to do it all, on a platform you already know how to use.

From bench to cabinet

Every board needs a home in production. Nano XL Link Connector Carrier gives Nano XL Link exactly that: a DIN-rail-mountable form factor compatible with standard 4U industrial enclosures, with screw terminal connectors exposing the CAN FD and RS485 interfaces and a standard RJ45 port for Ethernet. Plug in your Nano XL Link, wire up your field devices, and start moving your prototype towards deployment. 

And Nano XL Link Connector Carrier is more than just a mounting solution. It’s also a reference design for teams who want to develop custom carrier boards for specific applications. The layout and interface choices are intended to address common industrial integration considerations, providing a starting point that can be adapted without starting from scratch.

Together, Nano XL Link and Nano XL Link Connector Carrier form an integrated industrial development and deployment platform, from the first line of Arduino code to a board installed in a control cabinet, with the potential to reduce hardware redesigns or platform changes along the way.

The beginning of something bigger

These two boards are the first step in a new ecosystem for Arduino. The Nano XL family is designed to grow, bringing the openness, accessibility, and developer experience of the Arduino platform to domains that have traditionally required expensive, proprietary hardware and specialized expertise.

If you’re at electronica 2026, come to the Qualcomm booth (Hall C5 #439) to find out more directly from our team. Make sure to sign up to be the first to know when Nano XL Link and Nano XL Link Connector Carrier are available.

Qualcomm branded products are products of Qualcomm Technologies, Inc. and/or its subsidiaries.
Arduino, Nano, and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.

The post Just announced at electronica: the Arduino® Nano™ family is now XL! appeared first on Arduino Blog.

As part of the Arduino UNO Q Dream Lab Challenge hosted in partnership with DigiKey, makers and innovators were challenged to push the boundaries of what is possible with the dual-brain Arduino^® UNO Q board and Arduino App Lab. From an incredible pool of creative submissions showcasing the board’s unique dual-brain architecture, this entry emerged as one of the top winning designs.

You likely have a local weather service that will provide you with free information about the environmental conditions in great detail. But how well can you make sense of that data? Is a value of 54 for PM2.5 good or bad? Most people only care if the values are bad enough that they should be concerned, which is why Next Builder designed Atmosis to automatically determine if that is the case.

On the hardware side, Atmosis isn’t that much different than a conventional DIY environmental data monitor. It has an UNO Q, an Adafruit DPS310 sensor (barometric pressure and altitude), a Waveshare X6 sensor (various gases, temperature, humidity), a Waveshare dust sensor, and an LED strip that acts as an indicator. All of that hardware fits inside of a compact and rather fetching 3D-printed enclosure.

But while most environmental sensor devices like this simply tell you the sensor readings, Atmosis is built to use onboard edge AI, deployed through Edge Impulse, to automatically analyze the data. It looks at all the sensor readings and lets the user know when it identifies data that may need attention.

In most cases, that is all the user needs. But sometimes, a user might want to explore the data with more nuance or receive a more detailed evaluation. That’s why Next Builder gave Atmosis the ability to also work through Google’s Gemini LLM. That can dig into the sensor readings, look up references, and provide information in response to users’ questions.

Whether or not Gemini gets involved, the user can view the information through a web interface. They can also choose to receive updates from a Telegram bot.

Most areas will have more comprehensive data available from local weather stations than Atmosis can provide. However, your exact location may be unique, either as a result of differing micro climates or because of localized conditions, such as dust at a worksite. In those cases, Atmosis aims to provide valuable information that is easy to digest.

Arduino, UNO, and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.

The post Atmosis provides a digestible report, rather than raw environmental data appeared first on Arduino Blog.

Driving the LCD display of a Sony car radio with Arduino is possible. Jose Luis Monteiro proves it on the detachable front panel of a Sony CDX-A250, talking directly to the LC75826W driver. The project gathers reverse engineering notes, the reference sketch and a guide to reproducing the experiment. The starting point is the driver datasheet alone, because the segment mapping is not documented.

The Sony CDX-A250 panel contains the LC75826W LCD driver, listed as IC901 in Sony’s service documentation. The driver exposes a serial interface on connector CN901. The wiring used in the project is direct: DATA-LCD to DI of the LC75826 on pin 11 of CN901 and pin D8 of the Arduino sketch, CE-LCD to CE on pin 12 of CN901 and pin D10, CLOCK-LCD to CL on pin 13 of CN901 and pin D9. The panel’s +B supply comes in on pin 14 of CN901 from an external bench power supply, while the panel ground stays common with the Arduino.

The CCB protocol of the LC75826W driver

The LC75826 uses SANYO’s CCB serial format. Every transfer starts with device address 41H and then sends one of four 72-bit groups, identified by the two DD bits. The groups cover the ranges D1-D52, D53-D104, D105-D152 and D153-D208. The first group also carries the control fields that configure the driver: P0-P3 for segment output or general-purpose selection, DR for LCD bias selection, DN for 200 or 208 segment selection, FC0-FC2 for frame frequency control, OC for internal or external oscillator mode, SC for display on/off and BU for normal or power-saving mode.

The reference code sends every byte starting from the least significant bit. The segment mapping, that is which visible symbol corresponds to which position in the matrix, has to be discovered experimentally because the datasheet does not provide it. The searchOfSegments() routine advances one test state at a time. A button on D2 advances the test, while the serial monitor prints the information needed to identify the current state. The sketch’s serial monitor is used at 115200 baud for debugging and for the segment identification output.

What you need to repeat the experiment

Only a few parts are needed to reproduce the project. In particular, the list includes:

• a detachable front panel from a Sony CDX-A250
• an Arduino-compatible board with Uno-style pin numbering
• a bench power supply to power the panel
• a button for the segment identification routine
• the CN901 connector to access the panel signals

Jose Luis Monteiro’s repository collects the reference Arduino sketch and documentation files on the connections, the protocol, the segment mapping, troubleshooting and references. The Sony CDX-A250/CDX-A250EE service manual is version 1.1, dated 2006-01, publication 9-879-865-02. The project is meant to be reusable on other displays based on the same LC75826, so the reverse engineering notes apply beyond this single car radio model.

Anyone who wants to start from an Arduino board for the test bench will find several options in the catalogue. The code and the documentation remain the heart of the project anyway, because the segment mapping has to be redone by hand on your own panel.

Source: https://github.com/emsyscode/lc75826-sony-cdx-a250

The post Driving a Sony Car Radio LCD Display with Arduino appeared first on Open Electronics.

Arduino has always had a special relationship with musicians. Makers in the community have been wiring up theremins and building MIDI controllers from scratch for decades, driven by the simple idea that if you want to play an instrument, you should be able to build it. It worked for Brian May, right?

When we launched the Arduino^® UNO R4 board, we noticed the experiments were evolving in step with the technology. Gustavo Silveira, a composer and self-described “nerd musician”, had already built his iconic XT Synth – a hybrid guitar-violin-MIDI controller – by learning everything he knew from the community and giving it straight back. Tigris Li used UNO R4 to build a custom DJ controller. And Clatters Machines, the Italian duo devoted to making “noisy machines for music lovers”, prototyped their very first product on an UNO and never really looked back.

And these aren’t outliers. Browse the Arduino Project Hub and you’ll find a variety of instruments, effects units, sequencers, and sound controllers powered by Arduino, made by people who just wanted to hear something that didn’t exist yet. And then, of course, there are synths. So many synths.

Which got us thinking two things. First, UNO Q brings huge new potential to musicians and artists – and we can’t wait to see what they’ll create. Second, what if we made it easier and faster to put together a working synth, so no creative juices were wasted figuring out which components to buy or how to wire sensors together? That’s how the UNO Q DIY synth bundle came to be.

Black Friday deal: the UNO Q DIY synth bundle is now 35% off on the Arduino Store, until November 30, 2026. If you’ve been waiting for the right moment to build your first instrument – or you’re looking for a gift for the music-maker in your life – this is it. 

The bundle: everything you need to start, nothing to hold you back

The bundle packages a UNO Q 4GB board with four Arduino^® Modulino nodes – Buttons, Movement, Knob, and Distance – plus Qwiic cables and a complete step-by-step guide available on Arduino Project Hub. You get a polyphonic synthesizer, a drum machine, gestural control, proximity-based sound shaping, and full Pure Data integration: all in one purchase, with no components to track down separately.

The Arduino Project Hub tutorial walks you through the whole build: how the Modulino nodes connect to the STM32 microcontroller side on UNO Q, how sensor data crosses the Bridge to the Linux side, and how Pure Data runs on UNO Q, and maps the synthesis parameters in real time. Tilting the Movement node changes pitch. Knob adjusts parameters. Buttons give you a drum pad. The Distance sensor adds proximity control over filter behavior. The tutorial also links to 3D-printable enclosure files on Printables, if you want to give the whole thing a proper physical form factor.

You need exactly zero coding experience to tackle all of this. The software comes pre-configured, and the assembly is straightforward thanks to mistake-proof Qwiic connectors and daisy-chaining. You’ll learn loads along the way, just like the first time you pick up a guitar. Technology with Arduino is a lot more about figuring things out through practice, rather than studying and preparing to get things right on the first try.

Where to take it next

And just like learning a new instrument, the fun part comes after mastering the basics. Once you’ve followed the tutorial and you have a working synth in front of you – tilt it, twist the knob, wave your hand near the distance sensor, feel how it responds – the question becomes: what do you actually want it to do?

Here are a few directions worth exploring:

VJ control. The same sensor data you’re already streaming to Pure Data can be routed to visual software like Processing, TouchDesigner, or VVVV. Tie your tilt angle to a visual parameter, your drum hits to a strobe effect, your proximity sensor to a color shift. Your synth becomes a performance instrument that controls both sound and image simultaneously.

RFID scene switching. Add an RFID reader to the setup and program different NFC tags to load different Pure Data patches or parameter presets. Tap a tag, change your entire sound setup instantly. It’s a physical, tactile way to switch between scenes in a live performance without touching a laptop.

Generative sequencing. The Linux side on UNO Q can run Python scripts alongside the Pure Data workflow. Feed sensor readings into a simple generative algorithm that creates evolving melodic patterns based on your movement or environment – a synth that reacts to the room, not just your hands.

Expand the sensor palette. The Modulino system is designed for daisy-chaining. Add a Modulino Thermo and map temperature to reverb depth. Add a Modulino Pixels LED strip as a visual feedback layer. Every node you add is a new dimension of control.

The UNO Q DIY synth bundle gets you set up. The Modulino ecosystem and the UNO Q dual-architecture give you the building blocks to go well beyond it. Anything you create with these tools, well, is music to our ears!

Ready to start? Get the UNO Q DIY synth bundle on the Arduino Store. 

Already sold out? Try Amazon for additional stock – just make sure to choose original Arduino. 

Follow the Project Hub tutorial, then create your own project and share with the community!

Arduino, Modulino, UNO, and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.

The post Learn to make your own music – with the Arduino® UNO™ Q board appeared first on Arduino Blog.

According to a 2025 report from the WHO and UNICEF, approximately an entire quarter of the world’s population currently lacks consistent access to safely managed drinking water. The report also states that many people without safely managed drinking water had access to basic drinking water services. Thomas Vikström developed WaterLens as a tool intended to help users assess certain water quality indicators.

WaterLens is a compact device designed to give communities an affordable ability to monitor their local water sources. It is not a substitute for comprehensive laboratory testing and should not be used by itself to determine whether water is safe to drink. The device is designed to provide supplemental information when laboratory testing is not readily available. Its creator also designed it to be constructed and operated without advanced technical skills.

A WaterLens device can be assembled using off-the-shelf components that connect without soldering. Those components include an Arduino^® UNO Q board, a Seeed Studio Grove Base Shield, a Grove OLED screen, a Grove dual-button module, and a host of Grove sensors. Those sensors are designed to measure pH, turbidity, total dissolved solids (TDS), and oxidation-reduction potential (ORP).

Displaying measurements from each sensor may be useful, but interpreting those measurements may require relevant water quality expertise. WaterLens runs a local model, trained and deployed with Edge Impulse, that is designed to identify potential anomalies in the sensor data.

WaterLens may help identify sensor readings that warrant further investigation. A sample with no detected anomalies should not be assumed to be safe to drink, and a detected anomaly does not by itself establish that the water is unsafe. WaterLens cannot and should not replace validated water quality testing. Where laboratory testing is not readily available, the device may provide supplemental information that can help users decide whether further evaluation is appropriate. 

Arduino and UNO are trademarks or registered trademarks of Arduino S.r.l.

The post WaterLens uses AI on the edge to detect water quality issues appeared first on Arduino Blog.

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.

If you’ve ever built a robot with ROS 2, you know the classic architectural split: a powerful computer running Linux handles high-level navigation, mapping, and planning, while an external microcontroller handles the deterministic, real-time job of toggling GPIOs, reading sensors, and driving motors. 

Getting those two worlds to talk to each other usually means wrestling with custom serial protocols, dedicated drivers, or heavy middleware wrappers. The Arduino® VENTUNO Q board was designed to make that boundary disappear.

Because VENTUNO Q is structured to combine a Linux-capable MPU and a real-time microcontroller on the exact same board, you get a true dual-brain architecture. A few weeks ago at ROSCon Global 2026 in Toronto, and again on November 3rd live at ROScon Italy, Giovanni Bruno from our R&D team shared a new open-source tool built specifically to connect those two brains to ROS 2: the Arduino_RouterBridge_ROS library. 

Here is a look at how it works and how you can start using it in your next robotics build.

How it works: under the hood of Arduino RouterBridge

To understand how Arduino_RouterBridge_ROS operates, we first have to look at Arduino_RouterBridge. 

At its core, Arduino_RouterBridge uses an RPC (Remote Procedure Call) protocol built on top of MsgPackRPC. It lets the Linux side (running Python) and the real-time microcontroller side (running a Zephyr-based Arduino sketch) execute code on each other using two straightforward methods: 

• Bridge.provide() to register a callable function on one side. 
• Bridge.call() to trigger that function from the other side.

Instead of writing custom serial parsing code, you simply call functions across the MPU and MCU boundary as if they were running in the same thread.

Bringing ROS 2 nodes directly into your Arduino sketch

Building on top of Arduino_RouterBridge, the new Arduino_RouterBridge_ROS library introduces a lightweight ROS 2 proxy that bridges microcontroller firmware directly to your ROS graph. 

Using the familiar ros2ino namespace, you can write ROS 2 nodes directly inside your Arduino sketch: 

• Full node capabilities: Instantiate ROS 2 nodes, publishers, subscribers, services, and actions right from the MCU. 
• RMW agnostic: Because it relies on the lightweight RouterBridge transport, it works independently of whichever ROS Middleware (RMW) vendor you run on Linux. 
• Native C++ interface: The API syntax mirrors standard ROS 2 C++ (rclcpp) patterns, keeping the learning curve virtually flat. 

Now, your real-time microcontroller code can interact directly with ROS 2 without requiring you to set up additional bridge nodes, helping simplify development for robotics applications. For example, you can stream IMU telemetry straight into a /imu/data topic or listen to motor velocity commands on /cmd_vel.

Ready to build your next robot?

Are you engineering an autonomous mobile rover, designing a precision robotic arm, or wiring up your very first ROS-powered creation? Strip away the old serial communication headaches and focus on what matters most: building smart, capable machines.

Head over to our documentation to explore the new guides, including Getting Started with ROS 2 on UNO Q and First ROS 2 Project on UNO Q. Grab your VENTUNO Q, check out the repository, and show us what you build!

^{Giovanni Bruno, Robotics and Solutions Architect, presented VENTUNO Q, ROS 2, and the huge potential of Arduino ROS Bridge at ROSCON Italia.}

The post Unveiled at ROSCon: the easiest way to bring Arduino I/O into ROS 2 appeared first on Arduino Blog.

As global adoption of solar energy continues to accelerate, researchers and engineers face a fundamental spatial challenge: how do you generate more electricity without consuming more land?

Cosimo Borrello and Ferdinando Gioia – co-founders of the Italian photovoltaic technology startup A.M.P.S. – together with a team of researchers from the “Mediterranea” University of Reggio Calabria developed and field-tested a dynamic double-layer photovoltaic prototype designed to maximize solar power output per square meter of ground area. 

The challenge: overcoming land constraints

Conventional single-layer solar farms require significant spacing between rows to avoid mutual shading during solar tracking. While tracking raises energy yields per module, the extra space reduces overall energy production per unit of land. 

To solve this, the innovators at A.M.P.S. and the university stacked two vertically aligned layers of bifacial solar mini-modules within the exact same ground footprint as a single-layer setup. Rather than accepting the inevitable shadows cast by the top layer onto the bottom layer, the team implemented independent solar tracking for the stacked panels. By dynamically controlling panel rotation, the system is built to actively manages mutual shading while harvesting direct, diffuse, and reflected sunlight across both active surfaces. 

The brain behind the setup: GIGA R1 WiFi

At the core of the experimental testbed in Reggio Calabria, Italy, is a GIGA R1 WiFi. Installed on a custom-designed control PCB, it acts as the central embedded manager for the entire installation: 

• Automated motion control: It is structured to coordinate twelve Nema23 stepper motors via dedicated DM542T drivers to independently adjust the rotation angles of twelve bifacial mini-modules across both layers. 
• Independent current sensing: It is engineered to acquire real-time current measurements from twelve INA260 sensors attached to each module to track energy performance. 
• Remote data logging: It is constructed to process the synchronized current sweeps and uploads the experimental data directly to a remote server for analysis. 

“We chose the GIGA R1 WiFi because it brings together everything a prototype like ours needs, with lots of I/O, a fast dual-core microcontroller and built-in Wi-Fi on a single board,” Cosimo told us. “We had to drive twelve stepper motors independently, read twelve limit switches and twelve current sensors, and send the data to a remote server, and very few boards can handle all of that on their own. Having used an Arduino Mega board in many past projects, GIGA R1 was the natural next step, with the same familiar format and far more power and connectivity. It gave us a reliable control platform quickly, so we could focus on the photovoltaic research rather than on the electronics.”

Real-world results and future applications

In field testing under clear-sky conditions, with the top layer tracking the sun and the bottom layer fixed, the researchers reported the following increases in short-circuit current, a test measurement that is not the same as total energy production, compared with a fixed single-layer installation occupying the same ground area:

• About +42% relative to a monofacial single-layer installation.
• About +27% relative to a bifacial single-layer installation.
• About +39% and +25% respectively with a simplified open-loop tracking model based on a five-parameter sigmoid function, which the researchers reported were close to the results obtained using closed-loop control.

The researchers identify potential applications ranging from compact rooftop modules for space-constrained urban environments to utility-scale plants and agrivoltaics. In agricultural settings, the dynamic rotation of both layers may also allow operators to adjust the amount of natural sunlight reaching crops, although these applications were not evaluated in the reported field test.

By serving as a reliable control platform, GIGA R1 WiFi helped enable the team to move rapidly from concept to field validation – demonstrating how accessible open-source hardware can support advanced research in clean energy and land-use efficiency. 

Want to explore the mathematical models, control algorithms, and complete test data? Read the coverage on PV Magazine or dive into the full published paper in Renewable Energy.

Arduino, Arduino Mega, GIGA R1 are trademarks or registered trademarks of Arduino S.r.l.

The post Doubling down on solar power density with the Arduino® GIGA R1™ WiFi board appeared first on Arduino Blog.

The Smart Mirror turns a mirror into a style consultant. With a tap on Scan your look, a USB camera frames the garment being worn and the system recognises its colour and type, then suggests how to complete the outfit. The example runs on the Arduino VENTUNO Q board and shows how local visual AI can become part of a context-aware retail experience. Here the inference happens on the board, not on a remote server: images never leave the device, so privacy and latency stay under control.

The flow is linear and reads well from start to finish. A USB camera provides a live video stream, and the most recent frame is saved into a shared buffer. When Scan your look is tapped, the last frame is analysed locally on the VENTUNO Q board by the Qwen3-VL model, accessible through the Arduino VLM Brick. The model identifies the main garment and its colour and returns two short sentences: a description of the outfit and a style suggestion.

Two App Lab Bricks and an MJPEG stream to the browser

The result is sent to the browser and shown over the live camera view. The browser displays the live feed through an MJPEG stream exposed by the backend. The application therefore uses two App Lab Bricks: the Vision Language Model Brick and the Web Interface Brick. The first handles frame analysis, the second the page and the stream. The prompt behaviour can also be customised through a single configuration file, prompt.py.

Arduino VENTUNO Q as the compute board

• USB camera for the live video stream
• Arduino VLM Brick to access the model
• Vision Language Model Brick for frame analysis
• Web Interface Brick for the page and MJPEG stream
• prompt.py to customise the prompt

Anyone who wants to rebuild the project will find the parts list here is fairly short overall. The VENTUNO Q board is the heart of the system, while the USB camera is the only sensor required. The Qwen3-VL model does not need training: it is used as it is, through the Arduino VLM Brick.

The physical assembly is not described in the example: the system relies on a USB camera connected to the VENTUNO Q board and on a backend that exposes the MJPEG stream. The rest, from the framing to the physical mirror, depends on how you want to build the mount. The software side, on the other hand, is all inside the two Bricks and the prompt.py file.

What changes with visual AI inference running locally

The interesting point is not the individual style suggestion, but where it is computed. The Qwen3-VL model runs on the VENTUNO Q board, so no image of the garment being worn is sent to a cloud service. As a result, latency stays low and privacy is simpler to guarantee: what the camera sees does not leave the mirror. The system also works without an internet connection, because inference is local.

The complete flow can be summed up like this: the camera produces the frames, the shared buffer holds the most recent one, the model analyses it on request and the browser shows the result over the live video. Every step stays on the board or on the local network, and the tap on Scan your look is the only trigger for the analysis. If you want to see how the project is built and which files it uses, the post on the Arduino blog is the place to start.

For those working in retail or in the maker world, this Smart Mirror is a concrete example of how local visual AI can power a complete, real-time user experience. No cloud is needed, no fast connection is needed, no images travelling outside the home are needed. A USB camera, a VENTUNO Q board and two well-chosen Bricks are enough.

Source: https://blog.arduino.cc/2026/09/23/making-retail-smarter-build-context-aware-experiences-with-the-arduino-ventuno-q-board/

The post Smart Mirror: local visual AI turns a mirror into a style consultant appeared first on Open Electronics.

• Read more about He Built a PC Hardware Monitor That Looks Like a Four-Gauge Aircraft Instrument Panel
• Add new comment