Want real-world experience developing AI models and deploying applications using cutting-edge technologies such as the Arduino® UNO Q board? Qualcomm Academy has a new second-level program for you! The AI Associate Certification: Model to App is a hands-on, online, and self-paced program designed to provide experience with the end-to-end ML workflow, including data preparation, model creation, optimization, deployment, and on-device inference.
Through approximately five to six hours of build-along training, you’ll enjoy a combination of technical depth and practical application, helping you develop the confidence to create accurate, efficient, and production-ready AI solutions at the edge.
Three projects. One complete edge AI journey.
To achieve their certification, participants use a learning-focused development kit based on UNO Q to complete three real-world projects that span voice, vision, and sensor-based AI:
Wake Word Detection: Create and optimize a voice-enabled application that recognizes predefined wake words.
Person Recognition: Build a computer vision application that processes image data and performs real-time inference on an edge device.
Gesture Recognition: Train a model using IMU sensor data to detect and classify movements in real time.
Each project connects model architecture, training, validation, quantization, deployment, and application integration so learners can explore the ML lifecycle in practice.
Build skills for real-world edge AI development
By completing the certification, you will gain hands-on experience with developing ML models, preparing data, quantizing and optimizing models to explore tradeoffs among accuracy, latency, power consumption, and performance, and visualizing model graphs. You will also gain experience with AI development toolchains, explore MCU and MPU capabilities, develop real-time applications, and work with FastRPC communication for AI workloads.
The program is designed for developers and engineers, embedded systems professionals, IoT and robotics developers, students, and industry professionals interested in gaining practical experience with ML and edge AI. Learners should have basic Python skills, familiarity with an IDE, introductory knowledge of PyTorch and ML concepts, and prior hands-on experience equivalent to the Qualcomm Academy foundational AI certificate programs.
Flexible learning, practical results
The AI Associate Certification: Model to App is available online and can be completed at each learner’s own pace. You may purchase the program via Qualcomm Academy. After successfully completing the certification requirements, you will receive a Qualcomm Technologies certificate and badge that can be displayed on your CV and LinkedIn profile.
Start building – from model to app!
Take the next step in your AI development journey. Enroll in the AI Associate Certification: Model to App and gain hands-on experience applying ML concepts to applications running at the edge.
Visiting Maker Faire Rome (October 23rd–25th)? Make sure to stop by the Arduino booth to talk to the team about how you can get your AI Associate Certification: Model to App.
Qualcomm Academy is a program of Qualcomm Technologies, Inc. and/or its subsidiaries. Arduino and UNO are trademarks or registered trademarks of Arduino S.r.l.
An ATmega2560 with 8 KB of RAM can support a multitasking desktop environment, complete with games, file management and video playback. That is what Vladimir demonstrated by building a DIY laptop around an Arduino-compatible board with an ATmega2560, the Mega 2560 Pro Mini. The device measures 12x11x3.4 cm and packs a QWERTY keyboard, a 128×64 monochrome display, audio, microSD, an RTC and an 18650 battery into a 3D-printed enclosure. The firmware runs on FreeRTOS and offers real multitasking, with task switching via Alt-Tab. So a video that has been started keeps playing its audio while you play Sokoban.
The architecture of independent tasks is the core of the project. Applications receive events and draw through the UI engine, while the shell handles registration, stacks, switching and events. As a result, adding a new application does not require touching the others. A new task is a class with setup and loop plus a couple of methods for its menu entry and icon.
The UI engine and the applications on FreeRTOS
The interface engine handles forms, buttons, checkboxes, lists, input fields and dialogs. It takes care of key presses, tabbing, redrawing and the events sent to the owning task. On top of it run the ready-made applications:
file manager
video player
music player
clock
calculator
Sokoban
Snake
Game of Life
text editor
The ST7920 display is driven in parallel mode with a custom-written driver and a 1 KB video buffer in SRAM. The graphics functions range from a single pixel to text and XBM images. The AVR microcontroller runs at 16 MHz and everything runs on 8 KB of RAM, half of which is already taken up by global variables. That is why every byte of the buffer counts.
8×8 keyboard, debouncing and a 4-to-16 decoder
The keyboard has 64 keys in total, arranged in an 8×8 matrix that requires two 8-bit ports of the microcontroller. The keys were laid out in an 11×6 rectangle. Scanning happens column by column at hundreds of hertz, with software debouncing. In one revision a diode was added for each key and column selection moved to a 4-to-16 decoder. This way four pins are enough to select a column and the keyboard can expand to 16 columns.
24 fps video and XBM format plus MP3 in a single file
The video player uses a custom format with an XBM stream and MP3 in a single file. This way the player comfortably handles 24 fps video with audio, without keeping more in RAM than needed. The rest of the board is taken up by the RTC and the 18650 battery, which make the device self-contained. The enclosure was machined with a CNC3018 and 3D printed, while the schematics were drawn in EasyEDA.
Anyone who wants to rebuild the project will find the story of the work and the information to recreate it on the project page on Hackaday.io signed by Vladimir. Alternatively, an enclosure for an Arduino Mega can serve as a dimensional reference for the electronics, even though this laptop’s case is printed to measure.
When running UNO Q as a standalone single-board computer, navigating its Linux desktop environment doesn’t have to mean reaching for a standard mouse and keyboard. One of the most rewarding aspects of combining microcontrollers with a full operating system is the freedom to design custom physical interfaces – turning buttons, knobs, and joysticks into direct, tactile controls for your software.
To support that experience, we’re introducing the UNO Q SBC Controller Bundle. Designed for makers, learners, and innovators, this kit brings together hardware, software, and step-by-step guides to help you build a customized control setup.
What’s included in the box?
At the heart of the bundle is the dual-brain UNO Q 4GB board. To create a physical input layout as an alternative to certain traditional input functions, the kit includes a curated set of Arduino® Modulino nodes: Buttons, Joystick, Knob, and Pixels for dynamic visual feedback.
The included components connect through the Arduino®App Lab development environment. To give your finished project a clean, product-like appearance, we also offer a downloadable, 3D-printable enclosure that you can print or modify for your design.
Bringing physical control to your Linux workflows
Running Linux directly on your development board supports a range of potential applications, as we recently explored in our overview of what Linux unlocks on the UNO Q board. Whether you’re managing local Home Assistant dashboards, launching retro games, or controlling edge AI routines, physical controls provide another way to interact with your system.
Building your own controller offers a hands-on way to explore human-machine interaction, helping you learn how physical inputs translate into operating system commands. Thanks to the modular nature of the Modulino ecosystem, the setup is designed to be flexible – you can reconfigure supported input mappings or swap in compatible components as your project evolves. Detailed walkthroughs are already available here on Arduino Project Hub with instructions for assembling the featured configuration.
Completing your desktop setup
If you’re turning your UNO Q into a complete desktop station, a few optional accessories can round out your build. The Arduino®USB-C Hub (8 in 1) adds HDMI output, Ethernet, and extra USB ports, while the official Arduino USB-C Power Supply (45W) and Arduino USB-C Cable (24 pin) are designed to provide compatible power delivery for the UNO Q setup.
Head over to the Arduino Store to explore the new UNO Q SBC Controller Bundle, download the 3D-printable files, and start crafting your own custom hardware interface today!
Arduino, UNO, and Modulino are trademarks or registered trademarks of Arduino S.r.l.
By Marcello Majonchi, Chief Product Officer at Arduino
Sitting on my desk I have two boards. They carry the same logo, have a somewhat similar name. Their technology could not be more different, and yet the philosophy behind them is exactly the same.
On the left I have an early Arduino® UNO Rev3, featuring a Microchip ATmega328P, a fingernail-sized piece of silicon dating back the 2000s, that powered the original Arduino revolution. On the right sits the Arduino® VENTUNO Q, running a Qualcomm Dragonwing IQ-8 chipset with eight-core CPU and an NPU able to go up to 40 dense TOPS, making it the most capable AI-focused Arduino boards to date.
Both are Arduino. Both share the same pin headers. In just a few steps, you can blink an LED on one, or on the other deploy an 8-billion parameter LLM, then ask it how to program the original board to blink an LED.
Crazy how technology has evolved in the last 20 years, but naturally the obvious question is by how much exactly?
Well, you already know the answer from the headline, but getting to the real figure reveals a common pitfall in how performance specifications are presented and offers a better way to evaluate any performance claim.
The problem with specs
The Dragonwing chipset (IQ-8275) on VENTUNO Q carries a headline specification of 40 dense TOPS, representing forty trillion dense operations per second.
The 2009 ATmega328P is, on the other hand, the workhorse of the embedded electronics world: a single 8-bit AVR RISC core clocked at 20Mhz, known for its long-standing use in embedded applications, straightforward architecture, and broad accessibility.
The ATmega has no performance metric on its datasheet because nobody was tracking this type of stuff back then. But, if you estimate its compute ceiling manually, you land at roughly 8 million operations per second.
Divide 40 trillion by 8 million and you get 5 million. Case closed?
Not quite. That simple division hides a common trap in how performance numbers are interpreted: operations aren’t created equal.
Computers do math in different formats: think of them as different currencies. Small integer formats (often used for basic pixel brightness) require relatively few computational resources. High-precision floating-point decimals (often used for physics or navigation) typically require more computational resources. As a result, a chip optimized to blast through basic integers can look ordinary when forced to handle complex decimals.
Marketing materials for AI hardware usually quote the small-integer format, INT8 or INT16. Comparing those figures with an ATmega328P estimate derived from general-purpose clock cycles is similar to comparing different currencies without applying an exchange rate. The resulting number may appear dramatic, but it does not provide a meaningful like-for-like comparison.
So here’s Rule #1 of meaningful performance comparisons: both sides must be measured using the same “currency.”
Designing a fair race
To run a meaningful comparison, both chips should perform the same operation on the same data and produce equivalent results.
A representative workload for this operation is the mathematical backbone of modern machine learning: multiplying two numbers, adding the result to a running total. It’s called multiply-accumulate or, colloquially, MAC.
Repeat this loop millions (or trillions) of times, and you can get to things such as Image Classification (aka deciding whether a photo contains a dog, a car, or a birthday cake), Voice Recognition (aka continuously looking for a specific wake word while filtering out background noise) or even funkier stuff like Autonomous Navigation (aka evaluating sensor data in real time to distinguish a wall from a person).
These tasks are all the same underlying math, an aggregation of MAC operations, just at different scales, making them a useful ruler.
The actual benchmark
Let’s go for image classification to keep things simple.
We’ll need test images to be fed into both systems, originated as standard digital photos cropped and resized to a uniform resolution of 224 × 224 pixels across three RGB color channels. This preprocessing converts each photograph into an input data array (aka a tensor) containing 150,528 individual pixel values (224 times 224 times 3). The image data is formatted as 8-bit quantized integers (INT8), mapping every color value to a whole number between 0 and 255 to match the low-precision integer format required by modern hardware.
Evaluating one photo requires streaming this tensor through a vision model containing roughly 100 megabytes of stored parameters, generating a workload of 8 billion total operations (4 billion MAC steps). VENTUNO Q is designed to process roughly 5,000 photos every second; at that rate, the system could sort an entire photo archive (or just a fancy meal worth of pictures of a millennial) in a single heartbeat. Under the same benchmark assumptions, the original UNO Rev3 would take about 17 minutes to analyze the same photo, so think twice before taking a pic of that tiramisu.
To process the 5,000 photos that VENTUNO Q is built to handle in one second, UNO Rev3 would need approximately 58 days at the benchmarked throughput rate. If you started on January 1st, it wouldn’t finish until late February.
Within the context of this benchmark, the performance difference remains on the order of five million to one.
Why this is actually all meaningless
Here’s the catch: UNO Rev3 cannot practically execute this benchmark workload because the model exceeds the device’s available memory resources.
An AI vision model requires roughly 100 megabytes of memory to store its parameters. The ATmega328P has 32 kilobytes of flash memory and 2 kilobyte of RAM, which is insufficient to store the model.
The “58-day” metric just assumes the infinite external memory attached. It’s a mere thought exercise, but there is something even more relevant.
The gap between 2008 and today isn’t just that the old chip is slow. It’s that an entire category of work moved from impractical on earlier hardware to routinely achievable on modern AI platforms. No amount of patience can stretch 8 kilobytes of memory into 100 megabytes.
Real technological leaps rarely feel like “the same thing, faster.” They manifest as entirely new categories of capabilities opening up for the first time.
What does really matter
While this thought exercise suggests a five-million-fold difference in arithmetic capability, the significance of VENTUNO Q extends beyond raw compute performance.
One of the platform’s key contributions is helping make edge intelligence more accessible by lowering barriers to experimentation and development. The goal is to make it easier for developers to move from exploring AI software to building physical AI systems.
Whether toggling a GPIO pin on an 8-bit ATmega or deploying a computer vision model on a modern NPU, both boards are built around a similar development philosophy: connect the hardware, open an accessible development environment, and begin building.
That emphasis on developer accessibility is what matters most. Despite substantial differences in compute capability, both boards are designed to provide an approachable path into hardware development and experimentation.
Preserving accessibility while dramatically expanding compute capabilities represents a significant engineering achievement. For me, that is the real story. Making AI technologies more accessible helps more people move from using AI tools to building AI-enabled applications of their own.
Qualcomm branded products are products of Qualcomm Technologies, Inc. and/or its subsidiaries. Arduino, UNO, and VENTUNO, and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.
All [Hannah Robertson]’s Birduino needs is for one to tap an NFC-enabled card to the reader, and the device plays one of the vocalizations associated with the bird shown on the card. It ties together a few different components into a whole, and acts as a good reference design for similar work. There are a few time-saving construction tips worth keeping in mind, too.
The major components are an Arduino Nano, an RC522 RFID reader, and an MP3 player module. Using hardware modules and breakout boards means simpler wiring and being able to take advantage of existing libraries and sample code. There are also a few other things in this build that avoid re-inventing the wheel.
A deck of bird cards plus a roll of NFC stickers equals a ready-to-scan assortment without having to design it oneself.
Rather than design, print, and cut a set of bird cards, [Hannah] found a set of bird-themed playing cards with a different North American bird on each. The back of each card gets an NFC sticker off a big roll purchased online. The result? A set of NFC-enabled bird cards with a minimum of work and fuss. The RC522 RFID reader doesn’t fully support NFC, but it works well enough to read the ID off the stickers.
When the user touches a card to the reader, the device plays one of the vocalizations from a collection of sounds for each bird. Creating the manifests and linking each card’s ID to them was a lot of manual work, but the result is great. The sound themselves come from the Cornell Guide to Bird Sounds of the United States and Canada, a $20 USD curated compilation of vocalizations from a staggering 908 bird species of North America. In a way, the biggest bottleneck is the card deck itself. At 52 cards plus two Jokers, it contains only a small subset of the total birds in the Cornell collection.
The enclosure is laser-cut clear acrylic, and here [Hannah] offers some time- and money-saving advice for anyone looking to glue acrylic to acrylic in a way that doesn’t frost or cloud the clear acrylic: Clear Gorilla Glue Gel. There are of course other glues made for this purpose, but Clear Gorilla Glue Gel (the one in a squeeze tube) is something one should be able to find in just about any hardware store. Another tip: double-check before buying, because many Gorilla Glue products are very similarly named despite being significantly different products.
Watch (and listen to) the video embedded below. If birds and their vocalizations are something that intrigues and inspires you, Cornell also has a resource for identifying birds by sound alone — we’ve seen it implemented with a Raspberry Pi and USB microphone.
At Arduino, we have always believed that the most powerful technology should be in the hands of the many, not the few. That belief is the very reason VENTUNO Q exists, to put real AI into the hands of more creators. This includes access to the product itself, and when we introduced VENTUNO Q back in March we made the promise of an introductory price of under $300. A promise we honored when we made the product available for order in August for $299.
The cost of the many key components that make a board like this possible, in particular memory modules, has risen sharply across our entire industry, and continues to climb. We absorbed those increases for as long as we possibly could, because a commitment is a commitment, and your response made every bit of that effort worthwhile. VENTUNO Q sold out (twice!) in no time at all, and the orders have not stopped since. To everyone who pre-ordered, built, and believed in this board from day one, thank you! You proved what we hoped: that there is a real, deep hunger for open, powerful, physical AI.
But, what moves me most is not the numbers, but what you are already doing with it. In these first weeks we have begun to see projects arrive from our online community, and in person at events: Agentic AI reasoning assistant, depth camera multitool, industrial production line vision inspection, humanoid service robot, JetArm face-tracking, voice control, etc. You even have Half Life 2 & Skyrim running on it. From personal robotics experiments to serious edge AI industrial applications, this range of ideas is exactly why the VENTUNO Q exists. Take a look at what the community is already making, it’s truly impressive!
So here is where we stand. From October 19, VENTUNO Q graduates from its special introductory price to its official retail price, at $399. This is not a number we chose lightly, it is the honest price of delivering this AI computer, and this much ambition, in today’s market. If you have already pre-ordered VENTUNO Q, nothing changes for you, the introductory price will be honored in full.
What I want you to know is this: at $399, VENTUNO Q still delivers unprecedented value. In a single open platform, it brings together an Qualcomm® Hexagon NPU rated at 40 dense TOPS for local LLMs and vision AI running on-device, a dedicated STM32H5 sub-millisecond brain to act on the physical world, 16 GB of RAM, and a genuine path from prototype to production through the Works with Arduino program powered by Qualcomm Dragonwing processors.
And we are only getting started. The board you hold is one half of the story; the software keeps evolving continuously and at no extra cost. Our next Arduino® App Lab release will bring new AI models, support for 3rd-party accessories like the Raspberry Pi HATs and MIPI CSI cameras, and many more new features. Qualcomm® Linux® software stack support for VENTUNO Q is already live in beta on GitHub for you to experiment with today. There is a lot more on the way in the coming weeks. So stay tuned.
Thank you, as always, for the trust you place in Arduino. I cannot wait to see what you build next.
Qualcomm branded products are products of Qualcomm Technologies, Inc. and/or its subsidiaries. Arduino, VENTUNO, and Works with Arduino are trademarks or registered trademarks of Arduino S.r.l. Linux® is the registered trademark of Linus Torvalds in the U.S. and other countries.
The 0.96-inch 128×64 OLED display is a compact module widely used in electronics projects. It uses the SSD1306 driver and communicates over I2C, so it connects to Arduino, ESP8266 and ESP32 with just a few wires. It shows text, sensor data, symbols and graphics. AdriRobot tested it with an Arduino UNO and with an ESP32-C3 SuperMini.
128×64 OLED display: technology and colours
OLED stands for Organic Light Emitting Diode. Each pixel emits its own light, so contrast is high and no backlight is needed. Power consumption is lower than that of a backlit LCD, and readability stays good both in the dark and in bright light. The module comes with white, blue or yellow pixels, or in a two-colour version with a yellow top strip and the rest in blue.
supply from 3.3 to 5 V, 0.06 W consumption in normal display mode;
viewing angle greater than 160°;
operating temperature from -30 to +70 °C;
glass screen, lifetime of at least 16,000 hours;
module dimensions: 29.28 × 27.1 mm.
Pins, I2C address and power supply
The connector has four pins: VCC (3.3-5 V), GND, SCL and SDA. The reset circuit is on board, so no extra pin is needed. On the Arduino UNO the I2C pins are A5 for SCL and A4 for SDA, on the Mega they are 21 and 20.
Watch out for the two power pins, because on some modules their order is reversed. Displays marked JMDO.96C.1 let you choose: two pads on the PCB, shorted with 0 Ω SMD resistors or with a blob of solder, swap the two pins. Before connecting, it is therefore worth checking the silkscreen.
On some modules VCC and GND are swapped: read the silkscreen (photo: AdriRobot)
The I2C address is 0x3C, the same as other SSD1306 displays, and it cannot be changed. If other peripherals with that address are on the bus, another solution is needed.
Test with Arduino UNO
For the test, the display is mounted on a small breadboard and connected to an Arduino UNO. First you read the address with the i2c_scanner sketch (File, Examples, Wire): if nothing shows up, try swapping the SDA and SCL wires. Then install the Adafruit SSD1306 library from the Library Manager, accepting the Adafruit GFX dependency as well with Install all.
The test sketch then fills the screen, draws a pixel in each corner and writes a few lines of text. On the two-colour model, in fact, the first line comes out yellow because it sits in the top strip.
The test sketch running on the 128×64 OLED display (photo: AdriRobot)
Test with ESP32-C3 SuperMini
Connecting the display to the ESP32-C3 SuperMini (diagram: AdriRobot)
With the ESP32-C3 SuperMini the display uses 3.3 V, GND, GPIO9 as SCL and GPIO8 as SDA. In the IDE you select ESP32C3 Dev Module and enable USB CDC On Boot and Erase All Flash Before Sketch Upload, as in the other tests. Finally the sketch initialises I2C on pins 8 and 9, starts the display at address 0x3C and writes a few lines of text.
AdriRobot also used it on a board with an ESP8266 12F, to show temperature and humidity from a DHT11, and on a shield with a DFPlayer Mini, to print messages. The white-pixel model is available as a 0.96-inch I2C OLED display.
Source: AdriRobot’s original article includes the circuit diagram, the downloadable sketches and the test video.
A boxing band that counts your punches and analyses them as you throw them. Manivannan’s project brings together an Arduino Nesso N1, a Pulse Sensor and a machine learning model trained in Edge Impulse. The built-in 1.14-inch touch display shows the count and changes colour according to heart rate. That way the athlete immediately knows whether they are working in the rest zone or at peak intensity, without looking at an external app.
The Nesso N1 is the board that carries the whole system. The ESP32-C6 microcontroller mounts two 32-bit RISC-V processors, with an HP core up to 160 MHz and an LP core at 20 MHz. Memory amounts to 16 MB of NOR flash and 512 KB of SRAM, figures that leave room for the model and the firmware. On board there is also an SX1262 LoRa module in the 850-960 MHz band, useful if you later want to send data to a second device. The dimensions are 18 mm x 45 mm, so the band stays compact. Power comes from an integrated lithium-polymer battery, with a nominal 5 V input.
From the Nesso_IMU.ino firmware to the four punch classes
The Nesso_IMU.ino firmware initialises the Nesso N1’s IMU, configures the sampling pipeline and sends the readings from the 3-axis accelerometer over the serial port. The serialised motion frames are then acquired by Edge Impulse through the data forwarder. Here the work moves to Edge Impulse Studio, where the frames are segmented and labelled into four classes: Idle, Hook, Jab-Cross and UppeCut.
The preprocessing block is Spectral analysis, the learning block is Classification. The analysis window is 1200 ms and the stride is 750 ms, so the system looks at a little over one second of movement at a time and advances by three quarters of a second. The neural network is trained with 100 training cycles and a learning rate of 0.05. The stated result is 100% accuracy in both the training and the testing phase.
The trained model is exported as an Arduino library and imported into the IDE. From that point on, inference runs locally on the device, with no cloud dependency. The results update the punch count variables, while the Pulse Sensor continuously reads heart rate. Anyone who wants to retrace the path will find the full account of the workflow, from data collection to library export, on Manivannan’s project page on Hackster.io.
The Pulse Sensor on pin GPIO5 and the backlight colours
The pulse sensor must be connected to pin GPIO5, not to the default pin. The PulseSensor Playground library therefore has to be modified: inside PulseSensor.cpp the InputPin variable goes from 7 to 5. The sensor sits on the tip of the index finger and is secured with a hook-and-loop strap, so it stays in contact during the punches.
Heart rate sets the colour of the LED backlight, which becomes an intensity indicator you can read out of the corner of your eye:
Below 100 bpm the backlight turns green, rest zone or low intensity.
Between 100 and 140 bpm it turns blue, moderate activity.
Between 140 and 160 bpm it turns yellow, high intensity.
Above 160 bpm it turns red, peak intensity.
Rebuilding the band takes only a few parts: the Nesso N1, a Pulse Sensor, hook-and-loop tape and a 5 cm jumper wire kit. Assembly requires no special soldering, because the connections go through the jumpers. What is more, the hook-and-loop strap holds sensor and band together without 3D printing. Anyone looking for a board from the same family for other IoT experiments will find the board with Matter and Bluetooth LE in the catalogue, intended for home automation rather than for sports wearables.
The delicate point is calibrating the heart-rate thresholds. The four ranges on the board hold true for this project, but every athlete has different maximums. So it is worth recording a few rounds and comparing the colours with the real values before trusting the feedback. Sensor position matters too: if it shifts even slightly, the reading wobbles and the colour changes for no good reason.
Punch counting relies on the model’s four classes. Idle increments nothing, while Hook, Jab-Cross and UppeCut push the counter up. Consequently the number on screen is not a simple accelerometer peak, but the result of a classification. The limitation is that the model was trained on one person’s movements: with a different boxer, or with the opposite hand, performance can drop.
Maker Faire Rome is back! On October 23rd–25th makers, engineers, educators, and tech enthusiasts will gather for three incredible days of innovation, hands-on demos, and live talks.
We’re proud to be Gold Sponsors of this edition and, as always, we’ll be right in the middle of the action! We’re setting up shop with live demos, talks on stage, special offers, and plenty of new hardware to explore. Come visit booth N.02 to experiment with new boards and kits, take your first steps into physical AI, or just to catch up – we love seeing you all!
Here is a quick look at what we’re bringing to Rome this year.
Live demos and partner highlights
Stop by our booth to see a selection of Arduino products and new launches in action. This year, we invite you to go deeper into what’s possible when open source meets physical computing:
Social Robot Demo (with STMicroelectronics): We’ve teamed up with STMicroelectronics to build a collaborative social robot demo! You can check it out live at both the Arduino booth and the ST booth, where ST will also be highlighting industrial monitoring, e-scooters, and edge sensing. Plus, catch us on stage at the ST booth for a joint talk
Get hands-on at the booth!
We’re bringing a selection of hardware to test drive at the booth, including:
Arduino®UNOQand VENTUNO Q: Explore our dual-brain boards built to bridge real-time microcontroller control with Linux runtimes and local AI capabilities.
UNO Q DIY Synth Bundle: For the music makers, come hear how digital signal processing and Python scripts can be used to create custom synthesizer projects.
Arduino®USB Camera: Check out our new launch for computer vision projects and real-world sensing.
And more new launches we’ll unveil soon!
Planning to expand your setup? Visitors who sign up for our newsletter at the booth will score a 10% discount on their next hardware purchase!
Explore AI learning with Qualcomm Academy
Since the beginning, Arduino has maintained a longstanding focus on education, supporting students and educators with hands-on electronic tools and resources. At Maker Faire Rome, that focus will include AI learning opportunities. If you’re looking to build AI skills, our friends from Qualcomm Academy will be joining us at the booth. They’ll be presenting new certification programs designed for developers who want to build AI skills in deployment using our compatible edge platforms.
From UNO Q to VENTUNO Q: Arduino’s First Year with Qualcomm Speaker: Stefano Implicito, Marketing Director at Arduino When: October 23 at 4:30 PM What: A look into how Arduino and Qualcomm Technologies are shaping the future of edge AI and accessible compute.
One Year of Projects with Arduino UNO Q Speaker: Massimo Banzi, Co-founder of Arduino When: October 24 at 4:00 PM What: Massimo takes the stage to showcase a selection of creative and technically sophisticated community-built projects created with UNO Q over its first year. If you missed his talk at Maker Faire Bay Area, this is your chance to catch him.
Get your tickets online, come meet us in person!
If you’re planning to attend, please note that there will be no physical ticket counter at the venue in Rome. All tickets must be purchased in advance online at the official Maker Faire Rome website.
Purchase your tickets, drop by booth N.02 to say hi to the team, and let us know what you’re building. Ciao!
Qualcomm Academy is a program of Qualcomm Technologies, Inc. and/or its subsidiaries. Arduino, UNO, and VENTUNO are trademarks or registered trademarks of Arduino S.r.l.
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 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:
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.
