This DIY open-source drone project by Henrik Forstén uses custom FMCW radar and RTK GPS for high-resolution Synthetic Aperture Radar (SAR) imaging and Interferometric SAR (InSAR) for detailed ground…
A recent article revealed that OpenAI is purchasing tens of thousands of Mac minis and Mac Studios to give AI agents dedicated environments to run, make mistakes, and learn. It’s a smart infrastructure decision for agents meant to operate inside a computer clicking, navigating, using software: they need a full computer to practice on. But it got us wondering: is that always the right environment for an agent?
An AI agent isn’t a chatbot. It perceives a situation, takes an action, observes the result, adjusts, and tries again – in a loop that requires a persistent local environment with compute, I/O, and feedback. You can’t outsource the whole thing to a cloud API, because the agent needs somewhere to live and something to interact with. In OpenAI’s situation, the answer is: give it a computer. That works well when the goal is teaching agents to use software. But software isn’t the whole world.
A Mac mini today starts at around $900. At the scale OpenAI is reportedly operating, the infrastructure bill is substantial. That cost is justified when you need a full computing environment. But what if the agent’s environment doesn’t need to be a general-purpose computer? What if it needs to be a temperature sensor, a camera feed, a production line?
At a fraction of the cost, an Arduino® VENTUNO Q board can provide a persistent Linux environment for the agent runtime, local AI inference, and direct access to real-world I/O: cameras, sensors, actuators. The economics of deploying agent environments at scale look very different when each node costs significantly less, and can be embedded directly in the physical context it’s meant to ultimately operate in.
VENTUNO Q is built to combine a Linux-capable MPU with NPU acceleration and a dedicated real-time MCU on a single board. The Linux side is engineered to run the agent – its reasoning, its model, its decision logic. The MCU side is designed to connect it to the world: motors, sensors, cameras, industrial interfaces. No cloud dependency. No separate controller. One self-contained unit that perceives, decides, and acts.
Arduino® UNO Q is structured to extend this further as a low-cost remote node. David Groom demonstrated this clearly leveraging OpenClaw, developing an agent framework on UNO Q designed to enable agents to interact with physical hardware. By connecting to Arduino shields and accessing additional hardware capabilities, the framework supports physical-world interactions while enabling deployment across multiple units simultaneously, each maintaining its own context and operational role.
Read about David Groom’s OpenClaw project here.
With these tools, it’s easy to envision a “swarm” model: VENTUNO Q built to serve as a local processing hub, with UNO Q units designed for distributed deployment as remote nodes, all supporting agent-based workflows that interact with physical environments rather than simulated ones.
This is where the conversation becomes more interesting than individual compute specifications alone. Lower deployment costs can make broader deployment economically feasible, creating opportunities for more agent interactions, richer feedback loops, and exposure to a wider range of real-world operating conditions.
An agent that has operated across multiple physical environments, each with its own sensors, lighting conditions, and sources of noise, may be exposed to a broader set of inputs than an agent trained exclusively in software simulations.
Arduino can give agents something else to learn from: the physical world. By combining accessible hardware with scalable deployment models, Arduino platforms are designed to support the creation of large numbers of agent-enabled environments for experimentation, testing, and real-world interaction.
Ready to build your own agentic environment?
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.
VENTUNO Q is also available on the Arduino Store or through our official distribution partners: DigiKey, Farnell, Kubii, Mouser, Robu.in, and RS, along with other authorized distributors and resellers.
Arduino, UNO, and VENTUNO, and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.
The post How little does an AI agent need, and how cheap can it get? appeared first on Arduino Blog.
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.
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 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.
Source: https://srituhobby.com/how-to-make-a-solenoid-door-lock-system-using-a-touch-sensor/
The post Electronic door lock with Arduino UNO R4 WiFi and touch sensor appeared first on Open Electronics.
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.
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.
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:
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.
Source: https://youtu.be/FIu14vCvGfs?si=8SSW0K6O7J6Y07tz
The post Face-tracking robot with Arduino UNO Q appeared first on Open Electronics.
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 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.
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.
Several libraries make programming the MAX7219 easier; among them, in particular, the LedControl library, which is very widespread and simple to use.
The basic commands are as follows:
#include “LedControl.h” LedControl LC=LedControl (DIN, CLK, CS, number_of_modules)
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.
lc.setLed (module_number, row_number, column_number, state)
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.
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 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 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:
byte array [8]={B00000000,B00000000,B00000000,B00000000,B11111111,B11111111,B11111111,B11111111};
To display it on the screen you can proceed using the following code:
for (row=0; row<8; row++) {lc.setRow(0,row,array[row]);}delay (3000);
An editor that lets you obtain the binary codes of the most commonly used symbols more quickly is available at the following link: https://xantorohara.github.io/led-matrix-editor
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 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.
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.
The post MAX7219 LED Matrix with Arduino: Wiring and Library Guide appeared first on Open Electronics.
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.
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.
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.
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.
Source: https://www.qualcomm.com/internet-of-things/products/iq8-series
The post Arduino UNO Q 4GB: A Dual-Brain Board for Physical AI appeared first on Open Electronics.
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.
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:
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.
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 experience and connects visual understanding with real business information – providing a concise and relevant response.
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.
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.
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 flow could look like this:
Camera image > garment recognition > product matching > personalized recommendation > customer action
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.
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.
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.
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.
Ready to kickstart your journey in scalable smart interfaces and Physical AI? Get your VENTUNO Q from the Arduino Store today.
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.
The post Making retail smarter: build context-aware experiences with the Arduino® VENTUNO™ Q board appeared first on Arduino Blog.
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.
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.
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.
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.
The post Meet Nuvi: the AI desk companion that goes from Q to cute appeared first on Arduino Blog.
Are you ready for Maker Faire Bay Area? We sure are! The family-friendly festival of invention, creativity, and hands-on DIY culture – some call it the “the greatest show-and-tell on Earth” – is holding its special 20th anniversary edition this year, and we wouldn’t dare miss the celebrations.
Join us on September 25th–27th in Vallejo, California with thousands of makers, educators, and tech enthusiasts from all over the world: at Maker Faire, everyone brings their own ideas and leaves with loads of inspiration.
Stop by the Arduino Space inside the Make: magazine booth to hang out with the team, check out our latest hardware, and see what’s next for open-source electronics:
Plus, we’ll be offering a special discount code for Faire visitors!
Mark your calendars for Sunday, September 27th at 1PM PDT! Arduino co-founder Massimo Banzi will be taking the Foundry Stage for a special talk showcasing “One year of projects with the UNO Q.” We knew it was something special when it launched in October 2025, but the range of ideas you all have tested and brought to life in the past 12 months has been nothing short of incredible. Massimo’s talk will feature some of the most amusing, surprising, and advanced community-built ideas we’ve seen – and we know it will only inspire you to go further!
Get your tickets and find all the event’s info on the official website. We look forward to seeing you at Maker Faire Bay Area 2026.
Arduino, Plug and Make, UNO, and VENTUNO are trademarks or registered trademarks of Arduino S.r.l.
The post Bring ideas, leave inspired: Maker Faire Bay Area 2026 is coming! appeared first on Arduino Blog.
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.
The post Digitize analog gauge readings with edge AI appeared first on Arduino Blog.