Makers and educators, we want to hear from you! Expert or novice, your perspective as an Arduino user matters – and right now, sharing it could win you something pretty special.

We’ve put together a short user survey to better understand how the community uses what we have to offer, what’s working well, and where we can do better. It takes about 10 minutes to complete, it’s open to everyone, and your answers directly inform how we develop our products, tools, and resources going forward.

The Arduino Mystery Box Giveaway is here!

To thank you for your time, we’re running a mystery box giveaway alongside the survey – from May 18 to September 1, 2026. 10 respondents will be randomly selected to receive one of 10 mystery boxes containing Arduino hardware and swag.

It’s quick, it’s open to all levels, and the more voices we hear from, the better we can serve the community. Share the link with your maker friends – the more the merrier!

Take the survey now!

Giveaway Full Official Rules are available here. No purchase necessary. Void where prohibited.

The Arduino logo is a trademark or registered trademark of Arduino S.r.l.

The post Tell us what you think – and enter for a chance to win one of 10 mystery boxes of Arduino gear! appeared first on Arduino Blog.

Pen plotters used to be very common in the engineering world, as they were economical for “printing” large technical drawings. They’re still around, but digital-only workflows and alternative printing methods have reduced their presence. But Elliot Madsen is an engineering student fascinated by his discipline’s history, so he constructed his own pen plotter using an Arduino^® UNO Q board and parts from an old 3D printer.

A pen plotter is just a machine that moves a pen around, relative to the paper, in the X and Y axes (plus lifting in Z). That’s why they were ideal for technical drawings that tend to be large and composed entirely of lines.

That kind of motion system also closely matches that of an FFF/FDM 3D printer, which is why Madsen was able to build his pen plotter using parts — like stepper motors, aluminum extrusion, and pulleys — from a 3D printer. He chose a CoreXY kinematic setup, with a solenoid-actuated lifter for the pen. (As a bonus, the solenoid provides a nice “clacking” noise when in use.) Madsen then added a clever vacuum table to hold down paper via four 12V fans, eliminating the need for mechanical clamps.

To control it all, Madsen selected the UNO Q. By leveraging the board’s dual-brain architecture, he was able to run the control software on the Linux side and then interface with stepper motor drivers directly through its STM32U585.

After setup, this pen plotter runs based on simple commands from the terminal, which means it can be controlled over SSH. Just tell it to plot with any arguments you like and add the path to the file.

It works great and is especially well-suited to the kinds of technical drawings that were the bread-and-butter of pen plotters for decades.

The post Old 3D printer becomes new Arduino UNO Q-controlled pen plotter appeared first on Arduino Blog.

A few months ago, UncleStem built a completely functional 7:1 scale Arduino UNO Rev3 development board. That was a big hit, for obvious reasons. But what can you do with an Arduino of that size? The answer is: create a matching 7:1 scale turtle robot for it to control.

This is a great pairing, because turtle robots are often the first big projects that new Arduino users tackle — usually soon after blinking an LED. Just like with the oversized Arduino, UncleStem wanted to honor that tradition with the power of enlargement. 

He started by building a classic example of a normal-sized turtle robot from a kit. That is, of course, controlled by an UNO Rev3. The Arduino turns the two motors through an L298N dual H-bridge driver and avoids obstacles using an ultrasonic sensor. The ultrasonic sensor is on a servo-actuated panning mount, so it can “look around” for the optimal path when it runs into anything. The frame is just a piece of laser-cut transparent acrylic.

With that as a reference, UncleStem began building the scaled-up version. Most of the components are 3D-printed shells that match the mundane originals, but that contain the closest functional matches. For example, the drive motors are 12-24V geared units intended for kids’ ride-on vehicles. The “L298N” hides a pair of high-power 300W drivers suitable for those motors. A laser-cut plywood panel replicates the L298N’s PCB.

UncleStem progressed through all of the components in the same manner. He even made giant jumper cables to connect the components together.

The best part is that the mega turtle robot functions just like the original. It looks around with its ultrasonic sensor to find ways around obstacles, which is really fun to watch. 

The post Massive 7:1 scale Arduino UNO gets matching 7:1 scale turtle robot appeared first on Arduino Blog.

We’re releasing version 0.55.0 of the Arduino^® Core on Zephyr today, and it’s a meaningful one. This update resolves one of the most common friction points users have reported, adds support for two widely-used libraries, and brings us noticeably closer to our June target for marking this core stable and ending the BETA program. Concurrently, we’ll begin deprecating the corresponding cores based on mbedOS.

If you’ve been following the beta, this one is worth updating to.

Unified monitor and serial

The single most requested fix in this cycle was simple and reasonable: Serial.println() should just work.

On previous releases, users running the Arduino^® UNO Q board had to be intentional about how they routed output — adding #include <Arduino_RouterBridge.h> and being mindful of target differences between IDE 2 and Arduino^® App Lab. That friction is gone in 0.55.

We’ve reworked how outputs are routed and introduced a transparent alias, so printing to Serial or Monitor now delivers the expected result in both Arduino IDE 2 and Arduino App Lab. No bridge header required. If your existing sketch includes Arduino_RouterBridge.h, it’ll still compile cleanly; it’s just redundant now.

Print to your monitor without thinking about it.

New library support

Real-Time Clock (RTC): Projects running on Zephyr-supported boards can now use a reliable RTC to track time independently of uptime counters. Sync with a network time server, maintain a running clock with full calendar features, and build time-aware applications with confidence.

CAN Bus: The CAN library opens the door to automotive and industrial applications right from your UNO Q. Add a small CAN transceiver to your setup and you have everything you need to prototype automotive dashboards, robotics control systems, or any device network built on the CAN fieldbus standard.

Also in the Zephyr 0.55 release

• Dynamic Interrupts for UNO Q
• shiftIn / shiftOut functions for serial data reading and writing on pins
• Zephyr workqueue support for managing low-priority interrupts
  • Fixes compilation of libraries that hard-require wiring_private.h and pins_arduino.h
  • Plenty of bug fixes: PWM, WiFi, and more

Board support

Nicla Vision joins the supported lineup with this release. 

The full compatibility list as of 0.55.0:

• UNO Q
• Arduino^® Portenta H7
• Portenta C33
• Arduino^® Opta board
• Arduino^® Giga Display Shield
• Arduino^® Nano Matter board
• Nano 33 Bluetooth^® LE
• Arduino^® Nicla Sense board
• Nicla Vision

How to get started

Search for “zephyr” in the Arduino IDE Board Manager, install the 0.55.0 release, and you’re ready to go. Check our full release notes available on GitHub and read our troubleshooting article for more information.

Contribute to the beta program!

This is your opportunity to shape the future of Arduino development! We welcome feedback, bug reports, and contributions to the core. Visit the GitHub Issues page to report bugs or suggest features. Your feedback will play a critical role in refining this integration and unlocking new possibilities for embedded systems.

Visit the Arduino Core-Zephyr GitHub repository today and start exploring this exciting new platform! Thank you for being a part of the Arduino community.

Thank you for being part of this!

Arduino, UNO, Portenta, Opta, Giga, Nano, and Nicla and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.

The post Arduino Core on Zephyr 0.55: Getting ready for the final mile appeared first on Arduino Blog.

Documenting a project is just as much work as the project itself. Capturing photos and video, listing parts, and describing each step takes a lot of time — which is why so many people don’t bother. But that documentation is critical if you want to share your work, which is why Kevin McAleer had the genius idea to create a “self-documenting workshop” called Nibsy.

While the details of a project vary dramatically, write-ups, and tutorials tend to follow pretty standard formulas. That includes a list of components, a description of each step, and visuals. Because there is a consistent workflow, it is possible to automate the documentation process. AI makes that automation much more effective, as it can make sense of everything and wrap it up into a presentable package.

McAleer used the dual-brain Arduino® UNO Q to pull off that automation. The STM32 microcontroller detects the start of work through either a button press or sensing current on McAleer’s soldering iron. That tells the Qualcomm Dragonwing QRB2210 processor brain to start recording the environment.

It records two things: audio as McAleer speaks and explains what he’s doing, plus images from an overhead webcam that points down at the desk. McAleer’s spoken explanations give the AI context, including critical information like the names of components and information about the connections he’s making. The explanations, plus image analysis, let the AI determine which image frames to keep for the documentation. All the while, the UNO Q’s onboard LED matrix displays icons representing the system’s status.

The AI in question is Claude’s Sonnet model, which offers a good balance of performance, cost, and capability. That does most of the work of sifting through the recorded data. Then, at the end of a session, Claude’s top-of-the-line Opus models refines that and distills it down into a project log or tutorial, ready to publish to McAleer’s blog.

The post Nibsy makes manual project documentation obsolete appeared first on Arduino Blog.

Bird feeders seem to attract both birds and squirrels in equal measure. But while birds tend to eat just a little when they’re peckish, squirrels are voracious and will happily gobble up all of the seeds — leaving nothing to entice birds. To keep the squirrels at bay, David Groom leveraged the Arduino® UNO Q to build a “bird-only feeder” called BirdFeedR.

BirdFeedR dispenses bird seed on demand, but only when it recognizes a bird. If something else, like a rascally squirrel, tries to get involved, BirdFeedR will simply refuse to do anything. It will log the event as something detected, but it won’t dispense food unless that thing is a bird.

Groom was able to easily pull that off without spending a fortune, thanks to the UNO Q along with a USB webcam. He was even able to take advantage of Arduino® App Lab‘s Detect Objects on Camera example, which is made possible through the Video Object Detection Brick. That works using the FOMO (Faster Objects, More Objects) model from Edge Impulse and performed so well that Groom used it as is. It runs on the SBC (single-board computer) brain of the UNO Q and communicates with the MCU (microcontroller) via the standard Bridge calls that make the UNO Q so powerful.

On the MCU side, the Arduino sketch simply tells the STM32 to sweep a servo motor a handful of times. The servo motor actuates a mechanism to push bird feed out from the hopper and on to a platform where the birds can get to it. 

Groom even made use of the onboard LED matrix to display a big “X” if the thing detected isn’t a bird, or an adorable bird face if the thing detected is a bird. Now he can rest easy, knowing dastardly squirrels aren’t chowing down on the bird seed.

More details on the project can be found in Groom’s Hackster write-up.

The post BirdFeedR is a bird-only feeder that keeps thieving squirrels away appeared first on Arduino Blog.

Have you ever met a person with an exceptionally neat, tidy, and well-decorated office? Everything is intentional, from the furniture finishes to the potted plants. Even the trash can needs to fit the aesthetic. That’s why Akashdeep Singh of The Wrench YouTube channel designed this fancy 3D-printed dustbin for his new workshop that features a very cool motion-activated iris mechanism. 

This is a small dustbin perfect for putting on a desk. Not only does it look awesome with cassette futurist aesthetics, but it is also functional. Wave your hand over the top and the camera aperture-like iris mechanism will open up for a moment, so you can toss your garbage in. A few seconds later, it will close, keeping smells contained and unsightly refuse out of view. Finally, the body of the dustbin attaches to the base with magnets, so getting access to empty the bin is quick and easy.

That iris magic happens thanks to a pretty simple gear ring mechanism actuated by a small hobby servo motor. That servo motor operates under the control of an Arduino Nano board, which tells the servo to spin when it sees motion through an ultrasonic sensor. To avoid external wires, power comes from an 18650 lithium battery with a voltage booster to get clean 5V to the Arduino and servo motor. A custom PCB designed by Singh ties those components together in a compact package.

All of the mechanical parts to build this dustbin are 3D-printable. If you want to do that yourself, you can find the necessary 3D files and Arduino sketch over on Cults3D.

The post This futuristic-looking dustbin features a motion-activated iris mechanism appeared first on Arduino Blog.

After-school workshops run by curious, driven students is where some of the most exciting engineering happens in the Arduino community! One of the most compelling examples of this is FermiLabs, the innovation hub at secondary school IIS “E. Fermi – R. Guttuso” in Giarre, Sicily, offering students afternoon lab sessions in robotics, automation, and experimental physics. The results speak for themselves: FermiLabs teams have earned multiple podium positions at RoboCupJunior Europe, one of the most demanding student robotics competitions in the world.

RoboCupJunior Rescue, in particular, challenges teams to design, build, and program fully autonomous robots capable of navigating disaster scenarios – from following lines across obstacle-laden terrain to exploring multi-level mazes and assisting simulated victims. For the 2026 season, two FermiLabs teams are pushing the limits of what student-built robots can do, with Arduino at the core of both machines.

Team Tachyons: solving the maze with Arduino GIGA R1 WiFi

The RoboCupJunior Rescue Maze requires a robot to autonomously explore a complex, multi-level labyrinth, identify victims, and deploy rescue kits with precision. The 2026 rulebook raised the bar significantly with the introduction of “cognitive targets” – five concentric colored circles that robots must decode in real-time to classify victim types. This shift from simple colored squares to dense visual patterns demands a substantial leap in processing power and sensor integration.

Team Tachyons – who showcased their work during Arduino Days 2026 and are led by YouTuber and TEDx speaker Etto Fins – met that challenge by centering their robot on the Arduino GIGA R1 WiFi, leveraging the board’s ability to handle complex, multi-threaded tasks with the reliability and low latency that competitive robotics demands.

The robot’s intelligence lives in a custom-designed Arduino shield that acts as its central nervous system. Four dedicated stepper motor drivers deliver sub-millimeter positioning accuracy, while a six-axis IMU (Inertial Measurement Unit), fused with data from six ToF (Time-of-Flight) distance sensors, feeds a PID control loop that keeps the robot precisely centered within each tile – even on ramps and uneven terrain. On top of all this, the software builds a live 3D matrix to map the labyrinth in real-time, allowing the robot to backtrack and optimize its path autonomously.

The mechanical design is equally thoughtful. Custom silicone wheels, molded in-house with an airless structure, maximize traction while minimizing weight and absorbing shocks. The rescue kit deployment mechanism uses a compliant mechanism and twin springs to fire rescue cubelets at high velocity – and the kits themselves are engineered with the lowest possible coefficient of restitution, so they drop dead in place when they reach a victim rather than bouncing away.

After a successful showing at the regional selections in Catania, Team Tachyons placed second in the Italian Nationals with a new and improved model based on UNO Q 4GB boards… winning the chance to fly to Incheon, South Korea to compete with the best 3,000 robotics students in the world.

Team Yellow Radiators: vision-first line following with Arduino UNO Q

The Rescue Line challenge tasks a fully autonomous robot with following a black line across a modular arena of tiles, overcoming obstacles, debris, and varying terrain – ultimately locating and rescuing simulated victims before navigating to an extraction zone. Speed, reliability, and real-time visual processing are everything.

Team Yellow Radiators chose to abandon traditional line-following sensors entirely in favor of a vision-first architecture built around Arduino UNO Q. Rather than running high-level logic and low-level motor control on separate boards, this allowed them to unify both on a single platform. 

A Python layer running OpenCV processes real-time camera data to identify the line and read intersection markers, while the Arduino side simultaneously handles the high-frequency motor control loop and sensor integration. A custom communication bridge between the Python vision layer and the Arduino language hardware layer makes this seamless two-brain operation possible.

For the competition, the team built a custom web control panel that transforms how the robot is calibrated on-site. Via a local Wi-Fi network, team members can view live camera buffers, toggle between different image masks to debug line detection in real-time, and adjust color calibration or sensor thresholds wirelessly using on-screen sliders – no code re-upload required. The dashboard even allows direct remote function calls to the Arduino core, so specific subsystems like the rescue kit grabber can be tested manually. In the variable lighting conditions of a competition arena, this kind of live debugging capability is a genuine competitive advantage.

On the AI side, the team deployed a custom-trained YOLO object detection model using the NCNN runtime, optimized for the UNO Q Arm-based Qualcomm Technologies’ SoC. Their next milestone: enabling GPU passthrough to leverage Vulkan acceleration on the onboard Qualcomm Adreno GPU, further reducing inference latency. Development has been eased significantly by the full Debian OS running on the board, letting the team work directly from VS Code via Remote Development – a proper professional workflow on a compact edge device.

From Sicily to the world championship

Both projects illustrate something FermiLabs has made a habit of demonstrating: that with the right tools, a secondary school team can engineer solutions that rival professional-grade systems. Arduino’s role in both robots isn’t incidental – it’s the platform that makes rapid iteration, hardware control, and connectivity available to students who want to build things that actually work under pressure. 

After multiple successes at the national level in Catania in April, FermiLabs is now gearing up to take two teams to the RoboCupJunior European Championships in Vienna, and two more to the RoboCup Federation Junior World Championships in South Korea. Follow fermilabs.it on LinkedIn to see their progress, or check out their call for partners to find out how you can support them.

Qualcomm branded products are products of Qualcomm Technologies, Inc. and/or its subsidiaries. Arduino, GIGA R1, and UNO are trademarks or registered trademarks of Arduino S.r.l.

The post How FermiLabs builds championship-level robots with Arduino appeared first on Arduino Blog.

We’re bringing the maker community behind the scenes with a new live format: Built with Arduino, a candid conversation between our own Andrea Richetta (Senior Product Manager) from Arduino (for Qualcomm Europe) and Rafik from Kamitronix, the creator behind a smart mirror project built entirely on the Arduino^® UNO Q board.

No polished demos, no scripted walkthrough. Just an honest, back-and-forth discussion about what it’s actually like to prototype with the UNO Q ecosystem: Bricks, Modulino, App Lab, and all.

Over 40 minutes, we’ll dig into the real architectural choices every UNO Q developer faces: what belongs on the Linux side, what belongs in the real-time MCU, and how the latest updates from Arduino^® App Lab reduce the friction in between. The final 20 minutes will be open for audience questions.

Three live quizzes will keep the session interactive. Come ready to participate: May 13th @ 4PM CET.

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

The post Real talk: building with Arduino UNO Q appeared first on Arduino Blog.

Most embedded projects don’t stay simple for long. You start with a microcontroller (MCU), reading sensors and controlling outputs. Then you add connectivity, maybe a user interface, maybe even AI. At that point, a single MCU starts to feel limiting. So you introduce a Linux-based system. Now you have flexibility – but also a new layer of complexity: two processors, two toolchains, and a growing amount of glue code just to keep everything in sync.

You want the flexibility of Linux. You need the precision of real-time control. The Arduino^® UNO Q board is designed to bring these two worlds together and make this friction a thing of the past.

A dual-brain architecture gives you the best of two worlds

UNO Q combines two distinct processing environments on a single board.

A Linux-capable microprocessor (MPU) handles high-level workloads such as networking, AI inference, and application logic. Alongside it, a microcontroller manages real-time I/O, deterministic timing, and direct hardware interaction. This separation is intentional.

The MPU runs tasks that benefit from an operating system: multitasking, connectivity stacks, and model execution. The MCU handles tasks where timing and reliability are critical: reading sensors, generating signals, and controlling actuators.

Instead of forcing one processor to do everything, each side does what it’s best at – and the magic happens when the two “talk” to each other through the UNO Q bridge mechanism. 

In practice, this means your Python code can interact directly with hardware-level events handled by the microcontroller (such as a button press, change in temperature, movement, etc.), and your MCU can react to high-level decisions made on the Linux side (e.g. updating a web interface, logging data, or triggering an AI-driven response). Without complex setup, you’re working within a single, coordinated architecture.

Arduino^® App Lab offers a unified application model

The dual-brain architecture enables a different coding experience – so the real shift is not just in the hardware, but in how you develop for it.

With Arduino App Lab, the MPU and MCU are exposed as parts of a single application. 

Arduino App Lab provides developers with a unified, single-console environment. This centralized environment eliminates the need to switch between separate terminals or tools to monitor the two distinct environments. Within this consolidated interface, developers can monitor the logging output from both the primary application processor and the real-time microcontroller in parallel, offering a complete, time-correlated view of the entire system’s execution flow.

From a developer perspective, this removes the need to manually manage communication or synchronization between two separate systems.

The best part? If you want to see how Arduino App Lab is working behind the scenes, the Github repo contains all the source code, no secrets here! If you’re curious, just check it out here.

Arduino App Lab AI workflows bridge data insight and real-world action

Edge AI often becomes complex at the integration stage. Running a model is one thing, but connecting it to real-world signals, managing timing, and triggering actions reliably is where things usually break down.

This is exactly where the dual-brain architecture of the UNO Q changes the game. By combining an MPU running Linux with an MCU handling real-time control, you can naturally split AI workflows: the MPU takes care of model execution, orchestration, and the MCU takes the role of the king of deterministic land. 

It’s not just about running AI, it’s about making it fit and work reliably inside a real system.

Arduino App Lab acts as the bridge between these two worlds, enabling seamless data exchange and coordinated execution across the MPU and MCU. With the integration of Edge Impulse, the path from model training to deployment becomes much more direct. You can move from data collection to inference without reworking your entire stack.

Now you can build and deploy custom models in a unified flow: start from the Arduino App Lab “Train New Model,” move to Edge Impulse for training and validation, and deploy back to Arduino App Lab – ready to run across the dual-brain system, from insight to action.

You can even switch between different models with a simple click of the mouse!

If you want to explore the full workflow step by step, you can dive deeper into the dedicated article on training and deploying AI models in App Lab, as well as the overview of the expanding UNO Q ecosystem.

From architecture to applications

This dual-brain approach is not just theoretical – you can already see it in action across different types of projects.

From installing widely available tools like Node-RED to vision-based inspection systems, image processing can run on the Linux side while the microcontroller handles precise triggering and control. This allows you to process complex visual data without sacrificing timing accuracy. You can even process images and short videos with text prompts to generate descriptions or answers, like in this project where local LLMs and VLMs run on UNO Q.

In energy monitoring and smart sensing applications – like this accident response system that leverages physical AI – the MCU continuously samples real-world signals, while the MPU aggregates data, runs analytics, and exposes results through services or dashboards.

Three reasons, one simpler way to build

When you put it all together, UNO Q makes building complex systems simpler for three clear reasons.

First, a single, coordinated setup makes your builds more straightforward and efficient. You have two different brains, each one doing what it’s best at.

Second, the unified application model with Arduino App Lab turns two processors into one coherent development experience. You write, monitor, and debug everything from a single environment – no more switching between terminals, no different hardware for different tasks, no more glue code just to keep the two sides talking.

Third, AI workflows actually fit the system. With Edge Impulse, Qualcomm^® AI hub, Hugging Face that can be integrated into the flow, you can go from data collection to a deployed model without rebuilding your stack along the way. The microprocessor runs the inference, the microcontroller handles the signals, and Arduino App Lab keeps them all together using code and Bricks – so edge AI stops being an integration headache and starts being just another part of your application.

Flexibility of Linux, precision of real-time control, and a development ecosystem that is able to handle every side of your next project without you having to jump around between platforms: it’s all in a single board, designed to make building simpler from day one.

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

The post One board, two brains? Three ways a dual architecture board makes building simpler appeared first on Arduino Blog.