ArduinoMania

Pick Zigbee® from a menu in the Arduino® IDE, upload an example, and your board joins the smart home network that bulbs, sensors, and switches already share.

The Arduino® Nano Matter board has always been about the low-power side of the smart home. Until now, your sketches had two ways into the smart home: Matter over Thread and Bluetooth® LE wireless technology, both on its Silicon Labs MGM240S module. On September 15th a third arrived: update the Arduino® core for Silicon Labs to 5.0, and your sketches can speak Zigbee too.

It lives where the other two already are. Open Tools › Protocol stack, choose Zigbee, and the sketch you upload is compiled with the Zigbee 3.0 stack instead. Same board, same IDE, a different stack.

Start with a project

Before any datasheets, here is what it looks like when it all comes together.

The Zigbee Smart Clock is a desk clock built on Nano Matter, an Arduino® Modulino Thermo, a Modulino Light, and a 32×8 LED matrix. It was developed alongside the new library, as a real-world test of what the library can do. Once it joins your network, Home Assistant receives its temperature, humidity, and light readings and can switch the display on or off. The clock asks the network for the current time, so you never set it by hand, and it dims or brightens itself to suit the room.

The full build (wiring, the 3D-printable base and the code) is on Arduino Project Hub.

Your first Zigbee device, in one screen of code

The new Zigbee library wraps Silicon Labs’ EmberZNet stack in Arduino-style classes. A sensor is an object: give the device a name, call begin(), and report values. Here is a trimmed zigbee_temp_sensor:

#include 
#include 

ZigbeeTemperatureSensor sensor;

void setup()
{
  Serial.begin(115200);

  Zigbee.setVendorName("Arduino");
  Zigbee.setProductName("Zigbee Temperature Sensor");
  Zigbee.begin();
  sensor.begin();

  // Wait until the coordinator lets the board in
  Serial.println("Connecting to Zigbee network...");
  while (!Zigbee.isConnectedToNetwork()) {
    delay(200);
  }
  Serial.print("Connected to Zigbee network; Channel: ");
  Serial.print(Zigbee.getChannel());
  Serial.print(" | PAN ID: 0x");
  Serial.println(Zigbee.getPanId(), HEX);
}

void loop()
{
  // Measure the chip's own temperature and report it over Zigbee
  float celsius = getCPUTemp();
  sensor.set_measured_value_celsius(celsius);
  Serial.printf("Current CPU temperature: %.02f C\n", celsius);
  delay(2000);
}

Put your Zigbee coordinator in pairing mode and upload. Joining can take a few minutes, depending on your network. The Serial Monitor tells you where the board landed:

Home Assistant’s ZHA integration picks it up like any other Zigbee device:

The paired network is stored in the board’s non-volatile memory, so after a reset or a new upload the board is still part of it.

What’s in the box

14 ready-to-run examples cover 11 device types. Lights come as on/off, dimmable and color bulbs, plus an on/off plug-in unit. One switch type sends on/off and dimming commands. Sensors report temperature, humidity and light level, and a contact sensor tells you whether a door, window or drawer is open. Two helpers round it out: a power-source reporter and a time client that asks the network for the current time.

Devices join as a router (the default, relaying traffic for the mesh) or as an end device.

Two features stand out:

• Direct control with bindings: once a switch is bound to a light, the switch controls the light directly, without waiting for a hub automation. For the library’s own switch, you create the binding once in Home Assistant ZHA. The light and plug-in classes can also act as a Find-and-Bind target: call start_find_and_bind() (for example on a button press, as the library documentation shows), and Zigbee remotes that support Find-and-Bind can bind to them without the hub setting up the binding.
• Identify: when your hub sends an Identify request, the library tells your sketch, so it can blink an LED; the zigbee_lightbulb_identify example does exactly that. Handy when five identical boards are sitting on your desk.

One honest caveat: out of the box, the humidity and light level examples send made-up values, and the temperature example measures the MG24 chip itself, not the room. Read a real sensor instead (a Modulino Thermo, for example) and a few changed lines make them real.

Both ends of the network

A Zigbee home network is built around a coordinator, the radio that forms the network and lets devices join. Commercial hubs do this job, and the Zigbee section of the Nano Matter user manual names several that work with the board: Amazon Echo and SmartThings models, Hubitat Elevation (C-8), the IKEA DIRIGERA hub, and Home Assistant with a Zigbee radio.

The coordinator can also be another Nano Matter. The core includes prebuilt Zigbee EZSP coordinator firmware (since version 4.0), and a Python script in the core turns a board into the Zigbee radio for Home Assistant’s ZHA integration.

Open a terminal in the core’s extra/firmware folder (on macOS: ~/Library/Arduino15/packages/SiliconLabs/hardware/silabs/5.0.0/extra/firmware;
on Windows: %LOCALAPPDATA%\Arduino15\packages\SiliconLabs\hardware\silabs\5.0.0\extra\firmware, where the command is py instead of python3; on Linux: ~/.arduino15/packages/SiliconLabs/hardware/silabs/5.0.0/extra/firmware) and run:

python3 extra_firmware_flasher.py nano_matter zigbee

Python 3 is required. With no arguments, the script prints the boards it supports.

Plug that board into the machine running Home Assistant (a Raspberry Pi works well), add it in ZHA as the Zigbee radio, and build the lights, switches and sensors with your other boards. Every radio in the network is then an Arduino-programmable board. To turn the coordinator back into a device, run Tools › Burn Bootloader with Tools › Programmer set to OpenOCD (this erases the coordinator firmware and its network), then upload a Zigbee sketch.

Ideas to try this weekend

• A door-left-open alert: the contact sensor example with a reed switch on a spare pin, and a Home Assistant automation that pings you.
• A real room sensor: the temperature example with a Modulino Thermo, reporting to Home Assistant.
• A desk lamp and its switch: two boards running the dimmable light and on/off switch examples, bound once in Home Assistant ZHA, so the switch board’s button toggles the lamp directly.
• A clock that sets itself: the time client example is the core of the Smart Clock above.

A board that grows with you

The protocol menu is only one of the ways Nano Matter grows. Zigbee now sits next to Matter over Thread and Bluetooth LE. One stack runs per sketch, so you switch by picking another and uploading again.

When a project needs more than the common device types (a custom cluster, an unusual device, a different endpoint layout), the same hardware runs Silicon Labs’ full Zigbee SDK in Simplicity Studio. For Bluetooth LE projects, Nano Matter can also run native Zephyr.

Get started

1. Open Boards Manager in the Arduino IDE, search for Silicon Labs and install version 5.0.0.

2. Choose Nano Matter as the board and set Tools › Protocol stack to Zigbee. New board, or switching over from Matter or BLE? Set Tools › Programmer to OpenOCD and run Tools › Burn Bootloader once. It erases the board, including any saved network.

3. Open File › Examples › Zigbee, pick an example and upload.

4. Put your coordinator in pairing mode and watch the board join.

The Zigbee section of the Nano Matter user manual walks through each step, and the library documentation covers every class. The core is open source, and issues and pull requests are welcome on GitHub.

What will you build with it? Share it on Project Hub.

Arduino, Modulino, and Nano are trademarks or registered trademarks of Arduino S.r.l.

The post Your Arduino Nano Matter board now speaks Zigbee appeared first on Arduino Blog.

The Arduino ecosystem is expanding with a new USB-connected accessory designed to help simplify edge AI and computer vision: meet our first official, standalone Arduino USB Camera!

And if you are thinking “Well, it’s just a camera” – think again. When paired with single-board computers like the Arduino® UNO Q and Arduino® VENTUNO Q, it is built to unlock real-time visual perception and audio processing without requiring additional driver setups, custom kernel compiles, or complex hardware configurations. Instead of spending hours troubleshooting connections, you can plug it in and route high-fidelity video feeds and microphone audio directly into local AI models for real-time inference.

Ready for a hands-on experiment? In a recent online workshop, Andrea Richetta, Senior Product Evangelist at Arduino (Qualcomm Europe), built a face recognition system from scratch with UNO Q and Arduino® App Lab. Now imagine giving that project a pair of eyes made for the job: the brand-new Arduino USB Camera. Follow along, plug it in, and see your first face recognition system come to life.

The complete audio-visual hardware

Let’s dive deeper into what the Arduino USB Camera is and can do.

It’s a workspace-ready device that integrates HD imaging and audio into your next project:

• Minimal-configuration setup: Plugs directly into the USB ports of UNO Q or VENTUNO Q, designed so you can begin running computer vision models quickly.
• Integrated HD microphone: Captures audio alongside video, helping enable voice-and-vision multimodal applications without secondary audio hardware.
• Adaptive ring lighting: Features a touch-dimmable LED ring with adjustable color temperature, created to help maintain image consistency in varying ambient light.
• Flexible mounting: Includes a monitor clip, flat desk stand, and standard tripod thread.

Now for the fun part: the exciting feature is not what it can do but what you can do with it!

Because it’s designed for the AI models available in Arduino App Lab, the Arduino USB Camera connects directly into local, on-device workflows for a huge range of practical applications. Here are just a few examples we’ve brainstormed while developing the new accessory for you:

• Object detection and classification: Run YOLO-X or MobileNet on UNO Q or VENTUNO Q to detect faces, count objects, and trigger low-latency physical responses through the onboard real-time MCU.
• Touchless gesture control: Deploy MediaPipe gesture recognition to translate hand movements into control commands for robotics and user interfaces.
• Scene understanding via VLMs: Feed real-time video into local vision-language models like Qwen VLM on VENTUNO Q to generate on-device natural language scene descriptions.
• Multimodal assistants: Combine image feed and HD microphone audio with local ASR and LLM models to build interactive desktop companions and automated kiosks.

Ready to simplify your next AI vision project? Light up your AI vision projects with our new USB Camera. Check out the documentation.

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

The post Bring USB-connected AI vision to your projects with the new Arduino® USB Camera appeared first on Arduino Blog.

A buzzer module emits a sound to signal a danger or the end of a set time. It also serves to confirm a command. There are two types: passive, such as the KY-006 and Ks0019, and active, such as the KY-012 and Ks0018. AdriRobot tested them with an Arduino UNO, with a Multi Test Shield and with the micro:bit board.

Active and passive buzzer module: the difference

The buzzer is an audio signalling device. It can be mechanical, electromechanical or piezoelectric. In the active module there is an internal oscillator: you just power it and the sound starts. The passive module has none, so the control circuit must supply it with a square wave between 2 and 5 kHz.

The piezoelectric buzzer is based on a ceramic disc with a metallic layer. It is robust and cheap. That is why it is used for narrow-band alarm signals, for example in household appliances and in medical technology. Electromagnetic buzzers, on the other hand, have a metal diaphragm set vibrating by an electromagnetic circuit, with the electronics already integrated.

The four modules compared

The KY-006 and KY-012 have the same circuit, made up of a connector and the buzzer. Only the type of buzzer changes, passive in the first and active in the second. Of the connector only GND and signal are used, so the current comes from the Arduino pin. Each module also measures 15 × 19 × 9 mm and weighs 2.4 g.

The Keyestudio Ks0018 (active) and Ks0019 (passive) modules are more elaborate. An NPN S8050 transistor acts as a switch between the control pin and the buzzer. There are two resistors: one on the base and one in series with the power supply. This way the control pin only supplies the current for the transistor. The connector therefore has three connections: GND, signal and 3.3 or 5 V power. Finally, these modules measure 30 × 20 × 10 mm and weigh 3 g.

Testing with Arduino: square wave and tone()

To test a passive module you need an Arduino UNO, some Dupont jumpers and the KY-006 or the Ks0019. In the first sketch digital pin 3 goes from high to low with short pauses. This way the square wave is built by hand. Alternatively you use tone(pin, frequency, duration), which generates a square wave with a 50% duty cycle.

The command also produces only one tone at a time. If another pin is already playing, the call has no effect, while on the same pin it changes the frequency. To stop the sound you use noTone(pin). In AdriRobot’s example the buzzer sounds at 500 Hz and at 1000 Hz for one second each. Then it stays silent for five seconds.

The active module is simpler. With the KY-012 or Ks0018 a signal pin at high level makes the buzzer sound. At low level it stops it.

Multi Test Shield and micro:bit

The Multi Test Shield is a shield built by AdriRobot, compatible with the Arduino UNO R3. It is used to test the sensors of the 37-in-1 kit. The KY-012 is inserted on the JP2 connector. This way the sketch alternates sound and silence and shows the various phases on a small OLED display.

The Ks0018 and Ks0019 modules can also be connected to a micro:bit board. You need the Keyestudio Micro:bit Sensor V2 shield and three female-female Dupont cables. The program is also written with the MakeCode block editor and saved directly onto the board.

Where to find the modules

The individual modules are in the catalogue: the passive buzzer module KY-006 and the active buzzer module KY-012. Both are also part of the box of 37 sensors for Arduino, Raspberry Pi and robotics.

Source: the original article by AdriRobot includes the complete sketches, the MakeCode programs and other examples of buzzer use in projects.

Related products

• Passive Buzzer Module, 3.5V to 5.5V Operating Voltage
• Active Buzzer Module with 3.5V to 5.5V Operating Voltage
• Box of 37 sensors for Arduino/Raspberry Pi/robotics

The post Active and passive buzzer modules: KY-006 and KY-012 with Arduino appeared first on Open Electronics.

There is a vast gulf between making a one-off prototype and mass-production at scale. Within that gulf, there are innumerable small teams and businesses churning out PCBs in relatively low quantities – say dozens or hundreds a month. Inspection needs in that market are under-served, but Mukesh Sankhla designed a solution: a very affordable automated PCB inspection system.

This is a small, desktop-friendly setup intended for vision-based PCB inspection. It has a turntable with six stations and can automatically rotate through those, analyzing the PCB in each slot. It can identify specific components and check for anything missing, as well as defects. It does so with a camera view and YOLO vision models, deployed using Edge Impulse.

That is especially impressive because the system is easy and affordable to build. All it requires is an Arduino^® UNO Q board, a LED, a webcam, and a servo motor. The servo rotates the platform underneath the webcam, which resides in an overhead mount. The STM32 in the UNO Q is able to control the servo movement, while the Linux side can run the vision models.

The entire structure is 3D-printable and can be adapted to the user’s needs. The turntable, for example, is customizable to cradle the PCBs being inspected. It would also be simple to alter the size of the turntable and decrease or increase the number of stations. For instance, four stations would allow for a workflow that inspects both sides of unpopulated boards and both sides of populated boards.

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

The post Building a super-affordable automated PCB inspection system appeared first on Arduino Blog.

The BH1750 sensor converts light intensity into a digital value and makes it available on the I2C bus. Its measurement range goes from 1 to 65,535 lux. On the GY-302 breakout the sensor comes ready to use with Arduino, ESP32 and other boards. AdriRobot tried it with an Arduino UNO and writes about it on his blog.

What the BH1750 sensor measures

The lux is the unit of measurement for illuminance: it corresponds to one lumen per square metre. It therefore describes the light falling on a surface, evaluated as the human eye perceives it. For reference, light reflected by a full Moon is about 1 lx, a bright office is about 400 lx, and sunlight ranges between 32,000 and 100,000 lx.

Measurement modes and resolution

The BH1750 works in six modes, divided into two groups: continuous measurement and single measurement. In continuous mode the sensor detects light without stopping. In single mode it takes one measurement and then shuts down, so it must be reconfigured before the next reading. The library used in the article does this automatically.

Each mode offers three levels of precision:

• low resolution: 4 lx precision and 16 ms measurement time;
• high resolution: 1 lx and 120 ms;
• high resolution 2: 0.5 lx and 120 ms.

By default the library selects continuous high resolution. In low and high resolution modes the maximum value is 54,612.5 lx, while in high resolution 2 it stops at 27,306.25 lx. In practice the sensor returns a 16-bit integer, which the library converts into lux by dividing it by 1.2. A result of -1 means no valid data arrived, while -2 signals an unconfigured device.

You can also change the time interval in which the sensor counts light, through the MTreg register. The value ranges from 32 to 254 and the default is 69.

The GY-302 module: power, pinout and address

On the GY-302 the sensor is joined by a 3.3 V LDO regulator, marked 662K, and its capacitors. The module therefore accepts Arduino’s 5 V on the VCC pin. The regulator supplies up to 250 mA and withstands a maximum of 6.5 V at its input. On the SCL and SDA lines there are also two 4.7 kΩ pull-up resistors. The breakout is sold as a light intensity sensor.

The connector has five pins: VCC, GND, SCL, SDA and ADDR. The last one is used to choose the I2C address and comes into play when several BH1750 sensors share the same bus. With ADDR at a low level the address is 0x23, with ADDR high it becomes 0x5C. On the module tested the pin is tied to ground through a 4.7 kΩ resistor, so the sensor responds at 0x23.

• measurement range: from 1 to 65,535 lux;
• supply voltage: from 3 to 5 V;
• operating temperature: from -40 to +85 °C;
• dimensions: 18.5 × 13.9 × 2.5 mm, connectors excluded.

Connecting it to an Arduino UNO and an OLED display

For the first test you only need an Arduino UNO board, the GY-302 module and a few male-to-female jumper wires. VCC and GND go to the power supply, while SDA and SCL connect to Arduino’s I2C pins. Before uploading the sketch it is worth running the IDE’s i2c_scanner example: if the wiring is correct, the serial monitor reports a device at address 0x23.

The reading uses Christopher Laws’ BH1750 library, which is installed from the Library Manager together with the Wire library, already included in the IDE. The sketch reads the value every second and also writes it to the serial monitor.

The project is then completed with a 0.96-inch OLED display, 128×64 pixels, SSD1306 driver and I2C interface. The display responds at address 0x3C, so it shares the same bus as the sensor. The Adafruit SSD1306 and Adafruit GFX libraries are needed, and the lux meter shows the lux directly on the screen.

Anyone who wants to see the BH1750 at work in a larger project can read the ESP32 weather station with a live web dashboard, which pairs it with a DHT22 and a BMP280.

Source: the original AdriRobot article also contains the complete schematic, the sketches and the test video.

Related products

• Light intensity sensor
• OLED Display I2C 0.96” – VCC/GND/SCL/SDA

The post BH1750 Sensor: Measuring Lux with Arduino and the GY-302 appeared first on Open Electronics.

Flying and driving simulators can go as far as money will take you, and at some point it might end up being cheaper to buy a plane or race car than to keep adding capabilities to some of the sim rigs we’ve seen. But it can also be a fairly affordable hobby as well, with entry-level components being within reach for many. The price can drop precipitously from there too, provided some parts can be sourced and a 3D printer is made available, and [Jason] is demonstrating one of the lowest-cost H-shifters we’ve seen which only uses two parts at its core.

The two components only cover the electronics for the build, but this gets almost everything needed for the shifter squared away. A joystick like those found inside many game controllers is paired with an Arduino Pro Micro, with a very straightforward wiring configuration between them. These components are paired with a prototype 3D printed case and shift knob which provides the H pattern of choice. From there it’s as simple as uploading some readily-available firmware, which [Jason] also demonstrates, and which has many options for various configurations of shifters.

Although this was just a prototype, it shows was just a few off-the-shelf components and a 3D printer can provide to an affordable driving sim setup. Even then a 3D printer is not always necessary, like this three-pedal setup using extruded aluminum frame as a base. From there, all kinds of other features can be added like force feedback on the steering wheel.

GIGA R1 WiFi is built as a powerful development board, thanks to its dual-core, 32-bit STM32H747XI microcontroller, designed to operate at clock speeds of up to 480 MHz and equipped with 1 MB of RAM. Arduino Forum users KurtE and Merlin513 developed a ZephyrOS-based weather station app for it, showcasing its capabilities. What’s more, they recently published a demonstration that it also works on the less powerful UNO R4 WiFi.

The original project with GIGA

ZephyrOS is an RTOS (Real-Time Operating System), which we chose as a replacement following the end of active Mbed development in 2024. With the Arduino Core on Zephyr 0.90.0 now officially stable, it provides a foundation for applications designed to support process management, task scheduling, and real-time operation.

KurtE and Merlin513 built their weather app for ZephyrOS on the GIGA R1 WiFi with a paired touchscreen (like the GIGA Display Shield). That app is engineered to show the local weather through a nice GUI, with touch-selectable detailed information on specific days.

The result was relatively resource-intensive for a microcontroller, but the GIGA R1 WiFi’s processing and memory resources were designed to support the application.

The new, limit-stretching version

The UNO R4 WiFi is a more resource-constrained board, featuring a single-core Renesas RA4M1 microcontroller operating at 48 MHz and 32 kB of RAM. It also includes 256 kB of flash storage, compared with the GIGA R1 WiFi’s 2 MB.

This translates into two challenges: shaving the package size down to fit in the available flash storage and reducing resource usage for the available RAM. Fortunately, solving the first challenge also eliminated the second. KurtE did that by switch display libraries and simplifying the GUI elements. Most of that came down to reducing the color palette and minimizing image sizes where possible.

With these optimizations in place, KurtE demonstrated that the weather application could run on the UNO R4 WiFi and described the result as operating “reasonably well.”

The great challenge of smaller platforms

Optimizing software for constrained hardware isn’t just an exercise in trimming code – it’s a mindset that encourages thoughtful engineering. While high-spec boards give you room to dream big, figuring out how to squeeze a full RTOS, graphical interface, and real-time data onto a board with 32 kB of RAM demonstrates how practical constraints can inspire creative solutions.

Porting projects like this weather station down to smaller platforms helps make complex applications more accessible, showing that with the right optimizations, you don’t always need massive compute power to build impressive, responsive systems.

Have a similar project to share? Add it to your next post on the Arduino Forum, or document it on Arduino Project Hub so the entire community can benefit from your experience and build on it!

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

The post Porting a weather station app from the Arduino® GIGA™ R1 to the Arduino® UNO™ R4 boards appeared first on Arduino Blog.

A year ago, we shared two pieces of news at once. Arduino was joining the Qualcomm Technologies family, and the Arduino® UNO Q board was on its way.

The promise was simple: bring real computing power and edge AI to makers, students, and professionals, without losing the openness and joy that make Arduino what it is.

Twelve months later, you have responded to our biggest announcement ever in ways we could not have scripted.

Thank you.

The year in numbers*

You didn’t just try UNO Q. You built an ecosystem around it.

• 270,000+ UNO Q shipped worldwide
• 400+ events across the ecosystem
• 4,000+ contest participants, who delivered 250+ official builds
• 850+ topics about UNO Q on the Arduino Forum

One year in, the Arduino community continues to grow and thrive. The number of projects shared on Project Hub has nearly doubled year on year, while Arduino library downloads grew roughly 50% year on year, reaching 244+ million downloads in the last 12 months, compared with 165+ million in the previous year. The Arduino IDE also reached 35+ million downloads

Behind those numbers is something more interesting: a year of people discovering what happens when Arduino meets serious computing and AI. 

*As of September 29, 2026

Where it started

UNO Q brought together two worlds that had rarely lived on the same Arduino board: a Qualcomm Dragonwing QRB2210 microprocessor, with AI acceleration, quad-core performance and graphics, coupled with a real-time STM32U585 microcontroller. 

That combination is what makes UNO Q different. One side can run Linux, AI models, and demanding applications. The other can handle deterministic, real-time control. Together, they let developers bring the two worlds together in a way that feels like Arduino.

UNO Q launched alongside Arduino® App Lab, introducing a new way to build: an Arduino sketch on the MCU working together with a Python program on the MPU, packaged as one application. Suddenly, projects that once needed separate boards, computers or more complicated setups could start from a single Arduino.

Debian Linux for UNO Q brought a curated Linux environment to the board, making it easier to get started with the MPU side of the board. Arduino App Lab evolved throughout the year, adding new capabilities and workflows. We also brought Qualcomm Linux to UNO Q, giving developers another path into the Qualcomm ecosystem while keeping Arduino at the center of the experience. 

In August, Agentic Mode brought AI-assisted development to an Arduino desktop IDE for the first time. 

Your ideas, our proudest moments

From computer vision and local LLMs to music, healthcare, and smart everyday tools, we’ve seen an incredible range of ideas take shape.

We selected 12 standout projects that capture just some of the creativity and ambition of the UNO Q community.

And the creativity is still unfolding. Our Invent the Future with Arduino UNO Q and App Lab contest with Hackster is wrapping up, with the winners set to be announced on October 9. See the contest on Hackster

• JBR-001, a desktop companion robot
• XGO-Duck, a fully open-source robot
• DIY-ECG, exploring real-time health monitoring
• Local LLMs and VLMs on UNO Q
• NetraHz: Camera-free fall detection
• DIY Synth
• Gesture Detection
• Arcade Cabinet
• Inverted Pendulum
• Local Weather Station
• Smart Mirror
• AI Plant Guardian

Open by design: UNO and beyond

When Arduino joined Qualcomm, some wondered what it would mean for Arduino’s open approach. One year later, the answer is simple: openness remains at our core.

Arduino remains open source, with open hardware schematics and software under MPL, AGPL, and GPL. And this year, we continued to open up the tools behind UNO Q, including Arduino App Lab, available on GitHub for developers to explore, contribute to, and build on.

And the work this year has not been limited to UNO Q. Throughout this time period, we also unveiled several new products under the same ethos, ranging from the Arduino® Starter Kit R4 and Arduino® Nesso N1 to no less than eight (eight!) new Arduino® Modulino nodes. Motors, Joystick, Latch Relay, Light, LED Matrix, Vibro, Hub, and Extender may be tiny in size, but easily add so many different functionalities to your projects: you can check out the Arduino® UNO Q DIY synth bundle and Arduino® UNO Q Arcade bundle to get an idea of how well they work to bring ideas to life. Plus, Arduino Cloud got even better!

Meanwhile, Arduino Core on Zephyr reached version 1.0, moving beyond its beta phase and providing a solid RTOS foundation for Arduino boards with an MCU, including UNO Q as well as the new Arduino^® VENTUNO Q board.

Stronger together

Qualcomm is deepening its own open source commitment as well. Its business success depends on open standards, upstream collaboration, and transparent participation in the ecosystem.

A couple of months ago, we introduced VENTUNO Q, bringing substantially more computing and AI capability to Arduino developers. It opens the door to more demanding applications while keeping the development experience familiar.

A year ago, UNO Q was a new board. Today, it’s a growing platform, a new way of developing with Arduino, and, most importantly, a community of people finding out what it can do. Arduino and Qualcomm are stronger together!

A prototype is only the beginning

You can start with a prototype on UNO Q or VENTUNO Q and, as your requirements evolve, move to more advanced platforms and commercial-ready solutions while keeping the tools, models, and applications you already built. 

Beyond it, the wider Qualcomm Dragonwing family supports industrial and production-scale deployments.

The software stack follows you, too: 

• Arduino App Lab for building and packaging your application
• Edge Impulse for production-grade pipelines
• Foundries.io for secure updates and fleet management once you deploy at scale.
• Qualcomm AI Hub for optimized models

Finally, this year we also launched Works with Arduino, a program enabling partners to certify their System on Modules and developers to take apps built with UNO Q or VENTUNO Q to compatible hardware without changing a line of code. With App Lab, applications are packaged as a single App Release, making it possible to move from prototype to production in minutes, not weeks.

It is a direct bridge from prototype to commercial-ready hardware, and a path to the 33M+ Arduino developer community for partners.

And the community came together beyond the projects too. Alongside Qualcomm, we brought UNO Q to CES, MWC, and the Mission44 Workshop, meeting developers, makers, students, and industry leaders, while showing what this new generation of Arduino-powered computing can do.

^{The Arduino team at the Qualcomm booth at CES (January 2026)!}

^{Mission 44 students at Silverstone getting hands-on with UNO Q and AI-powered racing telemetry (June 2026).}

It is just the beginning

Year one showed that powerful, open, and simple can go together. It showed us what happens when you put new tools in the hands of a curious community, and let them take it somewhere you didn’t expect.

Year two is about going further: more tools, more partners, and more ways to turn an idea into something real.

Happy first birthday, UNO Q! 

And to everyone who built, shared, taught, hacked, and dreamed with it this year: thank you. The best is still ahead.

Qualcomm branded products are products of Qualcomm Technologies, Inc. and/or its subsidiaries. 

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

The post One year of UNO Q: built together, open by design appeared first on Arduino Blog.

Cyberdecks don’t all have to be chunky slabs of aluminum and plastic chasing after an ‘80s cassette futurism aesthetic. Cyberdecks can be whatever their builders want them to be — that’s the whole appeal. Jen Looper is a creative technologist who loves nature, plants, and cozy gardens, so she built this #cottagecore cyberdeck to do literal fieldwork.

As an aesthetic, cottagecore is all about cozy, rustic vibes. As a subculture, it is about comfortable sustainability and “slow living.” B.L.O.O.M. (Bridging Local Observations, Openly Mapped) is a cyberdeck designed to encompass all of that. Looper built it for collecting field notes on regional plants and animals. It harkens back to the descriptive logging and taxonomic classification work of Victorian naturalists.

The physical construction is also the polar opposite of what we typically see from the cyberdeck community. The enclosure is a “train case,” which is a traditional piece of luggage used for carrying cosmetics and grooming supplies. All of the hardware components nestle inside, with plenty of room to spare for some paper notebooks.

The hardware consists of an Arduino® UNOQ (4GB), a 5” HDMI screen, a Bluetooth keyboard, a Bluetooth mouse, and a power bank to power it all. It also has a USB camera and a USB microphone, which can be used for data collection.

To that end, it connects with a companion app (Field Notes) to compile that data in the Grinnell format. It can also run local AI models directly on the UNO Q to help with that work. As an example, Looper employed the Edge Impulse integration in Arduino App Lab to create a custom model that can recognize avian species based on their birdsong.

This is the kind of functionality that Victorian naturalists wouldn’t have even been able to dream of, but Looper was able to achieve it on a modest budget. At the same time, she proved that cyberdecks can come in any form.

The post This #cottagecore cyberdeck is perfect for literal fieldwork appeared first on Arduino Blog.

The single-board computing market is shifting rapidly, and we are moving into an era of unprecedented possibilities where edge AI, computer vision, real-time control, and rich sensor streams converge locally. Yes, it’s exciting – but even amidst this “explosion” of hardware, an age-old rule holds true: define what you want to build before picking your tool.

No single board can (nor should!) excel at everything. A low-power embedded sensor, an autonomous robot, and a high-throughput video server all demand different architectures. For example, if you are weighing hardware choices for a general-purpose Linux setup versus a hybrid microcontroller, read this in-depth review to evaluate how different design philosophies match your requirements.

In concrete terms, it’s great to get a sense of what each board can do – and even better if you can look at a variety of cool projects at the same time! So here is a selection of what we are seeing developers build across key domains with the Arduino^® UNO Q board, leveraging its dual-brain to bridge high-level AI workloads with deterministic physical control. 

Dive into perception-driven robotics

Robotics excels on hybrid platforms because physical movement requires tight, real-time microcontroller timing while visual recognition requires heavy AI processing.

•  A robot arm that sees you: Uses camera vision designed to recognize people and a robotic arm built to deliver items, with a Modulino LED Matrix providing visual feedback.
• UNO Q Braccio: Integrates Edge Impulse AI and ROS 2 in a platform engineered to support robotic arm control, including simulation in Gazebo.
• Face-following robot: Uses Edge Impulse computer vision designed to track faces and convert tracking data into physical servo movements.
• AI agent robot: Uses a local AI agent built to support physical navigation and decision-making tasks in real-world environments.

Explore the world through computer vision and spatial sensing

Instead of just streaming video, local machine learning turns cameras and sensors into environmental perception engines.

• Gesture-controlled input system: Uses a standard webcam and Edge Impulse in a workflow built to convert hand gestures into inputs for digital applications.
• Real-time LiDAR room mapper: Pairs LiDAR sensors with Edge Impulse ML in a system engineered to help interpret spatial data and interpret room layouts locally.

Create smart environments with interactive AI

Local AI allows devices to run full “sense, interpret, decide, act” loops without relying on cloud latency or external servers.

• Talk to your house: An all-in-one smart home hub engineered to support wake-word detection, voice commands, sensor management, and a web interface.
• Clawrophyll: A smart houseplant system designed to run a local AI agent directly on the board.

We don’t need every platform to do the same thing

The technological landscape is expanding, giving us more tools to build with: the goal was never to find one ultimate board “to rule them all”, but to match your project’s unique demands to the right architecture. Whether you need a raw Linux computing hub or a dual-brain setup like UNO Q, starting with a clear target can help you build smarter, faster, and more effectively. Today, we have more options, more possibilities – and this may ultimately be the most exciting part in the current era of single-board computing.

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.

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

The post What can you build, when AI can interact with the real world? appeared first on Arduino Blog.