ArduinoMania

You build something great on your Arduino^® UNO Q board. Now what? Arduino App Lab 0.11 is about taking your project further, whether that means shipping it to another board, getting help while you code, or teaching your device to recognize a tennis swing. 

Here is what’s new!

App release: deploy to production, at scale

App Lab 0.11 deepens our integration with the Works with Arduino program. 

App Lab now supports exporting production grade “Apps Releases,” so your project built in App Lab can be packaged for deployment without leaving the tool. 

How does it work?

1. Package an app into a ready-to-run file.
2. Install it on another board.
3. Run it on compatible third-party hardware included in the Works with Arduino program.

What’s the difference between this new App release and the export feature?

Export is great for sharing a project. An app release is designed to provide a consistent, ready-to-run package. An app release is a frozen, immutable package with locked dependencies to support consistent behavior across compatible devices. Sketches are pre-compiled, which can reduce startup times. Remote dependencies like AI models are downloaded at install time, which can streamline setup across multiple boards.

Check our documentation to learn more:

• Create an App release
• Install an App release

Agent Panel right inside the editor

Chat with an Agent Panel next to your code to build, troubleshoot, and brainstorm ideas. 

Agent Panel uses the app, files, and code open in your workspace as context, which can reduce the need to copy and paste or switch tabs. It will update files in your workspace as you chat with it in plain-language, and it keeps your chat history organized by app.

What’s the difference between the Agent Panel and Agent Mode?

Agent Mode, introduced in App Lab 0.10, is a full-window experience centered on the agent. You describe what you want and the agent creates and works on your app for you. The Agent Panel is a side chat that stays open while you work in your app. It uses the app and files you have open as context, updates them as you chat, and you run your app right there as usual.

New Pose Estimation Brick: teach your board the moves

The new Pose Estimation Brick runs locally on your Arduino^® VENTUNO Q and comes with two features: one with preconfigured capabilities and one that supports custom poses. 

Preconfigured skeleton tracking and pose detection

The Brick tracks a 17-point body skeleton at up to 10 frames per second and draws a live overlay on your video stream. It also recognizes standard poses like standing, sitting, or arms up and down, without a separate model-training step. The demo app is just six lines of code.

Make it yours: teach it a custom pose

Need something more specific? Give the Brick a folder of photos of the pose you want, plus a folder of photos that are not that pose. No separate model-training step or additional tool is required. The photos are the whole input, and App Lab performs a recognition check before the app starts.

Want to recognize a tennis stroke? Provide representative photos to configure the custom pose.

Bring your own model

Add language models for the LLM Brick straight from Hugging Face, using a model ID or URL. App Lab checks that the model is compatible and selects a support quantization based on the model. 

Check out the documentation at this link: Custom model import documentation

Your phone is now a sensor board

The Mobile Companion App now streams more than the camera. 

Microphone and IMU data now flow into App Lab through a new remote sensor peripheral, at high frequency over WebSocket, with password protection and encryption options. Data is sent as JSON, so you can define your own keys. Because it is built on WebSockets, compatible external devices can stream data to your board using the supported WebSocket interface, which can support remote-control and IoT use cases.

Know where you are, even when GPS struggles

In this short demo, Anthony Hebert and Stefano Implicito show how easy it is to get started and put TPS to the test by finding Andy in the middle of a crowded show floor.

We showed the Qualcomm Terrestrial Positioning Service (TPS) running on UNO Q at The Things Conference 2026 on September 28th. It uses nearby Wi-Fi, cellular, and Bluetooth LE signals to support positioning while managing power consumption. A new TPS brick and example provide a way to evaluate the service.

Also in Arduino App Lab 0.1

• VENTUNO Q flashing: flash your board from the built-in flasher in Settings.
• Board extensions: select and configure the carriers and JHAT add-ons attached to your board from the Settings page.
• Publish to Arduino Project Hub: upload your app as a project draft from the App menu.
• Editor improvements: Find All References for Python and C++, YAML syntax checking, any file or folder name, and a separate console tab for each Brick container.

Get started

Download Arduino App Lab 0.11 today and tell us what you build!

For the full list of changes, see the release notes.

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

The post Arduino® App Lab 0.11 is here appeared first on Arduino Blog.

STEMpedia and Arduino bring block-based coding to the Arduino® UNO R4 WiFi and UNO R4 Minima boards as well as the Arduino® Alvik robot.

Every maker remembers the moment something they built first came to life: an LED blinking, a servo sweeping, a sensor reacting to a hand wave. Today, that moment gets a lot easier to reach thanks to a new collaboration between STEMpedia and Arduino!

We’re excited to reveal that PictoBlox 10.0, STEMpedia’s coding and technology creation platform, has expanded its Arduino compatibility to include the UNO R4 WiFi, UNO R4 Minima, and Alvik robot. 

And what better place to celebrate this news than at Maker Faire Rome 2026? Join us from October 23rd–25th to explore the new integration and try PictoBlox for yourself! 

From first-time coder to confident creator

Arduino has long been a starting point in electronics for makers, students and educators.PictoBlox brings a visual, drag-and-drop programming experience that helps users to focus on programming concepts without having to start with coding syntax. Together, they can help beginners go from “I’ve never coded” to “I built a working project” in a single session.

But PictoBlox isn’t just for beginners – or just for programming. Beyond block-based coding and Python, the platform is designed to let users explore AI and machine learning, experiment with tinyML and intelligent systems, program compatible robotics and electronic hardware, and develop IoT projects. It also supports game and animation development, opening up even more opportunities for hands-on creativity and experimentation.

Announcing the collaboration, Dhrupal Shah, CEO and Co-Founder of STEMpedia, said: “Great innovations begin with the freedom to experiment. By expanding Arduino board support in PictoBlox, we are making it easier for learners and makers around the world to turn their ideas into working projects. 

“Students can create AI-powered projects and train their own Machine Learning models, making complex technologies more accessible. We’re excited to see how this collaboration inspires the global maker community to explore, build, and innovate.”

What you can do with PictoBlox and Arduino

Combining visual programming with Arduino hardware opens up all sorts of creative possibilities:

• Program with blocks: snap together scripts instead of typing code, and see how your Arduino responds right away.
• Work with sensors: read inputs such as an IR sensor and use them to trigger actions.
• Control actuators: drive LEDs and servo motors from your scripts.
• Go wireless: control your projects from a smartphone using Dabble, a project interaction and Bluetooth controller app.

By bringing together Arduino’s hardware ecosystem and PictoBlox’s versatile coding environment, the collaboration aims to make technology creation more approachable and open up new possibilities for the global maker community to learn, build, share, and innovate. 

Built for classrooms, clubs and makerspaces

Whether you’re teaching in a classroom, running a coding club or experimenting in a makerspace, this expanded integration is all about trying to lower the learning barrier and open up new possibilities for creative exploration.

By helping reduce the need to manage syntax, block-based coding means learners can focus on developing essential skills like logical thinking, problem-solving and understanding how code works. And as their confidence grows, they can build on these foundations, explore text-based programming and take on increasingly ambitious projects within the Arduino ecosystem.

For educators, it’s a compelling combination: an approachable software environment and a familiar, well-supported hardware platform, with plenty of room for students to learn, experiment and grow – all in one workflow! 

Get hands-on at Maker Faire Rome! 

Heading to Maker Faire Rome this year? Be sure to stop by booth N.02, where you can see PictoBlox and Arduino in action, try out the new integration for yourself and chat with the team. We’d love to see you there!

Download PictoBlox at: https://thestempedia.com/product/pictoblox/download-pictoblox/

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

The post More ways to code, more ways to create: PictoBlox expands Arduino support appeared first on Arduino Blog.

• Read more about Two Eyes, One Tiny Chip: This Open-Source Board Computes Stereo Depth So Your Arduino Doesn't Have To
• Add new comment

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.

Enroll now!

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.

The post Discover the Qualcomm Academy new AI Associate Certification: Model to App at Maker Faire Rome! appeared first on Arduino Blog.

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.

The matrix rows are currently 6, but by reading a whole port of the microcontroller they can be brought to 8. The key labels were printed with a 0.25 mm nozzle. For the audio and memory side, the project relies on components that have a direct counterpart in the catalogue: an audio decoding shield for compressed formats, a microSD card reader with an SPI interface for the files, and a board that combines an ATmega2560 with Wi-Fi connectivity for anyone who would rather start from a different base.

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.

Source: https://hackaday.io/project/206744-avr-laptop

Related products

• VS1053 MP3 Shield for Arduino
• MicroSD Card Reader module with SPI interface
• Board with ATMEGA2560 and ESP8266 Wi-Fi SoC Module

The post A DIY laptop built on the ATmega2560: real multitasking on 8 KB of RAM appeared first on Open Electronics.

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.

The post Build your own physical interface with the new Arduino® UNO™ Q SBC Controller Bundle appeared first on Arduino Blog.

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.

The post Five million to one: two Arduino boards, 20 years apart appeared first on Arduino Blog.

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.

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.

Dear Builders, Engineers, and Innovators,

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.

Marcello Majonchi
Chief Product Officer, Arduino

Get VENTUNO Q from the Arduino Store. Also available from our official distribution partners: Conrad, DigiKey, Mouser, Farnell, RS, Robu.in, and many others worldwide.

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 post A letter to our community: VENTUNO Q reaches its official price appeared first on Arduino Blog.

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.

• 0.96-inch size, 128 × 64 pixel resolution, SSD1306 driver;
• 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.

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.

Test with ESP32-C3 SuperMini

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.

Related products

• Mini ESP32-C3 module
• OLED Display I2C 0.96” – VCC/GND/SCL/SDA

The post 0.96-inch 128×64 OLED Display: SSD1306 and I2C appeared first on Open Electronics.