ArduinoMania

The Arduino core for Zephyr RTOS has reached version 1.0.0. This release marks the completion of the transition away from the old MbedOS-based core. The new core provides a modern and flexible foundation for current and future Arduino boards. It also lets you use Zephyr RTOS features and APIs directly from the Arduino IDE, Arduino CLI and Arduino App Lab tools.

The project is built on a two-component architecture. The core generates a standalone elf file that is loaded dynamically by a precompiled Zephyr firmware called the loader. The loader handles the interaction between sketches and the underlying Zephyr system. After the initial bootloader installation, the loader automates the sketch loading process. Version 0.90.0 made the Zephyr loader installation procedure fully automatic.

The loader and its operating modes

The loader’s behaviour is set through the IDE’s Mode menu. In Standard mode, the loader loads the sketch automatically. In Debug mode, on the other hand, it requires you to type ‘sketch’ in the Zephyr shell. This flexibility makes debugging much easier. The loader design is generic: board-specific changes are made in the DTS overlay or fixup files.

The core is validated with version v0.16.8 of the Zephyr SDK. Development uses the standard tools of the Zephyr ecosystem, such as west and sync-zephyr-artifacts. The core also relies on components such as llext, the dynamic extension mechanism, and zephyr-sketch-tool for compiling sketches. Everything rests on ArduinoCore-API to maintain compatibility with the Arduino ecosystem.

What you need to get started

To try the Zephyr core you need a supported board and an up-to-date development environment. Here are the main steps:

• Install Arduino IDE 2.x.x or Arduino CLI
• Add board support through the Board Manager
• Install the Zephyr core from version 1.0.0
• Configure the loader mode from the IDE’s Mode menu

Version 1.0.0 of the Zephyr core is a milestone release. The move from MbedOS to Zephyr is complete. The new core offers a more solid foundation for the future of Arduino boards. Among the new features, support for the project’s code repository includes all the loader and core sources. In addition, the new Arduino UNO Q board is among the first devices to benefit from this architecture.

The Zephyr core represents a paradigm shift for Arduino. It is not just an update: it is an infrastructure built to last. The separation between loader and sketch makes the system safer and easier to update. What’s more, using Zephyr RTOS opens the door to advanced features such as support for numerous protocols and optimised power management. For anyone developing IoT applications, this is a solid foundation to build on.

The transition from MbedOS to Zephyr was not only technical, but also strategic. Zephyr is an open source RTOS with an active community and a regular release cycle. This guarantees long-term support for Arduino boards. In addition, version 1.0.0 of the core is validated with the Zephyr SDK v0.16.8, ensuring stability and compatibility. The future of Arduino boards goes through here.

Source: https://github.com/arduino/ArduinoCore-zephyr

Related products

• Arduino UNO Q 4GB – Complete kit with accessories

The post Arduino Zephyr core 1.0.0: the move away from MbedOS is complete appeared first on Open Electronics.

When you look into the night sky, you can’t help but wish to bring the outer worlds to your doorstep. One of the best ways to do that is to photograph the Moon’s surface to display in a frame. However, [Sebastian Lague] found a simple image too lackluster compared to something with a bit more style, such as a plotted image of the lunar terrain.

Why plotting? Well, the Moon is not defined in the same way with contrasting colors as Earth is. The Moon is peppered with craters and differing elevations that separate regions, so why not build an entire DIY plotter from scratch? [Sebastian Lague] did exactly this with a custom algorithm to take the elevation maps and create vector drawings which are plotted on his custom plotter.

The plotter’s design is simple on its face, using an Arduino and stepper motors, as many other plotters have. [Sebastian Lague] also shares insights into their process and iterative designs, moving from a level arm to raise a marker to a linear method. While the Moon plots are impressive on their own, why stop there? [Sebastian Lague] decided to plot Mars and then return home with Earth plots.

While the plotter itself is rather simple, all the work behind the contour maps and turning the ideas into reality is nothing to take for granted. However, if you want a more complicated side of plotting, make sure to check out this multi-colored delta plotter!

A group of children aged 7 to 13 is building a tactile zoo with 3D-printed robotic animals. The creatures, more than 20 in total, are equipped with LEDs, motors, buttons, and gears. At Maker Faire Bay Area, the group will also display their printing errors and failed prototypes. The goal is to show the iteration process that leads from an idea to a working object.

The project turns 3D printing into an educational and interactive activity. Mistakes are not hidden but become an integral part of the exhibition. Visitors can thus understand that making errors is a normal step in the work, not a failure. The maker’s website details how the children faced technical difficulties and what solutions they found.

From choosing the animal to the first print

Each young maker chooses an animal, real, mythological, or completely invented. Then they decide what behavior the creature should have. Some design the animals from scratch, others start from existing 3D models and modify them, cutting or redesigning sections to make room for the electronics. Once the body is ready, they add a function such as an LED, a servo, a motor, a button, or a set of gears.

The group includes eight creatures, among them Em. To make Plate the Armadillo roll into a ball, 11 prints were needed. Each failed attempt taught something new: a joint too tight, a motor off-axis, a wall too thin. The children learned to observe the error and correct it in the next print.

An exhibition you can touch and open

The zoo is not a simple showcase. Visitors can press buttons, flip switches, and open the animals to see the wires, gears, and electronics inside. This choice makes the electronics transparent and understandable even to those who have never opened a device. Next to the finished animals, broken prints, melted parts, and earlier versions are displayed, so visitors can ask what went wrong and how it was fixed.

For those who want to recreate the project, the electronic part can be built with simple, modular components. For example, a servo motor with metal gears can move an animal’s legs, while a shield for controlling RC servos allows managing multiple movements with an Arduino board. For light effects, a WS2812 LED matrix offers endless color possibilities. Finally, a compact board like the Arduino Nano Matter can handle logic and connectivity in a small space.

Mistakes on display: the educational value of failure

The choice to display printing errors is the heart of the project. In a world that shows only perfect results, these children reveal the behind-the-scenes. The broken prints tell the real difficulties of 3D printing: material shrinkage, parts detaching from the bed, motors that don’t find space. Visitors to Maker Faire will be able to talk with the young makers and discover how each problem was tackled.

This approach also changes the way the children work. They learn that a failed prototype is not wasted time, but a step forward. Each error provides valuable information for the next version. The iteration process thus becomes a mental habit, useful not only in 3D printing but in every design activity.

Source: https://view.protectedpdf.com/portal/AMR/LogIn

Related products

• Servo shield

The post 3D-Printed Tactile Zoo: Young Makers Show Off Their Mistakes appeared first on Open Electronics.

We’re living in 2026 and everyone knows that they can ask a large language model (LLM) a question and get an answer. But most people assume that requires an internet connection, because those LLMs live in massive data centers. The truth is that LLMs can run on local hardware, answering questions without any internet at all. Cameron Coward, of the Serial Hobbyism YouTube channel, took advantage of that fact, connecting an Arduino UNO Q to a vintage terminal.

That terminal is a Texas Instruments Silent 700 (Model 745), which is a paper terminal that was made in the 1970s. Back then, it would have been used as an input/output device for something like a minicomputer, connected through either an acoustic coupler (remote) or RS232 (local). Users would type commands on the keyboard and computer output would print on the thermal paper.

For this project, Coward connected the Silent 700 to his custom-built device, Termi3, to give it the ability to answer questions. The user types a question and a moment later, the terminal prints out the answer.

As the name suggests, Termi3 is the third version of the device. The first two required internet access, because they retrieved answers through the Wolfram Alpha API.

Termi3 doesn’t need any internet connection at all, because it generates an answer locally on an UNO Q (2GB). The Arduino runs a local LLM, Llama 3.2-1B, on the Linux side without ever touching a network. It interfaces with the terminal though bit-banging on the STM32 side, which goes through a MAX3232 transceiver (for level conversion) to the terminal’s RS232 port.

It is amazing that an LLM can run on the small and affordable UNO Q at all, especially with 2GB of RAM. So, the LLM isn’t particularly sophisticated and its answers aren’t always accurate — or even coherent. But they are often entertaining, which makes Termi3 a lot of fun to talk to. 

The post An Arduino® UNO™ Q lets this vintage terminal answer questions without internet access appeared first on Arduino Blog.

Not a lot of thought went into the “mouse droid” in the first Star Wars movie. It was just a bit of cute world-building, created by putting a box on an RC car. But it became a fan favorite and that in-universe model, the MSE-6, appears throughout subsequent movies, TV shows, and video games. All of them, however, are identical. Cass, the maker behind Chaos Theory, imagined how mouse droids would actually fit into the world and the result is this MSE-6 that knows how to party.

According to the lore, billions of MSE-6 droids were built. For those living in the Star Wars universe, they wouldn’t be any more special than toasters or Huffy bicycles. It is only natural that individuals in that universe would customize mouse droids and Cass’ creation is an exploration of the kind of personalization that Sabine Wren would perform.

For those who aren’t deep into Star Wars lore, the simpler explanation is that this is an adorable mouse droid capable of navigating autonomously and features blinky lights, a radical paint job, and a rave mode. In that mode, it turns into a graffiti-covered mobile party machine that spins around while blasting music and flashing its lights.

Underneath the 3D-printed shell in that iconic shape, this is an Arduino UNO Rev3-controlled rover robot. It has a pair of motors, which the Arduino controls through an L298N driver. Power comes from a 7.4V lithium battery pack, with a buck converter to reach 5V. An ultrasonic sensor prevents collisions and the sound plays through a DFPlayer Mini MP3 module. Finally, arrays of 5mm red LEDs provide visual flair.

That all came together thanks to Cass’ fantastic paint job. She explains her inspiration, thought process, and supplies, but the great results are mostly attributable to her artistic talent. It is exactly the kind of mouse droid that Sabine Wren would adopt. 

The post This mouse droid knows how to party appeared first on Arduino Blog.

• Read more about This Arduino UNO Q Headband Uses 13 Vibration Motors for Screen-Free Awareness Through Haptic Feedback
• Log in or register to post comments

An SO-101 robot arm, originally a desktop toy, now picks and places rubber ducks by reasoning with a vision-language-action model. Dmitry Maslov’s project swaps the original brain for an Arduino VENTUNO Q board, which runs Hugging Face’s SmolVLA model locally. The result shows that robotics tasks combining vision and language, once confined to costly labs, now fit on a 299-dollar board.

Hardware: two processors on one board

The Arduino VENTUNO Q board has a dual nature. On one side sits an SBC system with a Qualcomm Dragonwing IQ8 processor, equipped with an Adreno 623 GPU and a Hexagon Tensor NPU, built for AI processing. On the other side is an STM32H5F5 microcontroller with an Arm Cortex-M33 core running at 250 MHz, which handles real-time servo control. The board offers 16 GB of LPDDR5 RAM and 64 GB of integrated eMMC storage.

The original SO-101 arm carries gearmotors on every joint and two cameras: one fixed overhead and one on the gripper. The images and joint position data go to the Dragonwing IQ8 processor, where the SmolVLA model interprets them. The model was trained with 50 demonstrations of the task of grabbing and moving the rubber ducks.

The SmolVLA model and the system’s numbers

SmolVLA is an open source vision-language-action model from Hugging Face. It processes the camera images and joint data, then produces the commands for the servo motors. All the processing happens locally on the VENTUNO Q board, with no connection to external services. The board costs 299 dollars, against 399 dollars for the Jetson Orin Nano Super Developer Kit, cited as a competitor.

Dmitry Maslov’s system points the way to accessible robotics. What’s more, the fact that the model runs on a commercial board costing less than 300 dollars opens up new scenarios for makers. For anyone who wants to see the project in action, Dmitry Maslov’s video shows the arm grabbing and moving the rubber ducks.

• Arduino VENTUNO Q board with Qualcomm Dragonwing IQ8 processor and STM32H5F5
• Hugging Face SmolVLA model running locally
• 50 demonstrations to train the pick-and-place task
• Two cameras: one overhead and one on the gripper
• 16 GB of LPDDR5 RAM and 64 GB of eMMC storage

For anyone wanting to rebuild the project, the trickiest part is the integration between the SBC side and the microcontroller side of the board. The Dragonwing IQ8 processor runs the model, while the STM32H5F5 controls the servos. Communication between the two sides is essential to synchronise vision with movement.

Source: https://youtu.be/T0frBNASr3M?si=Wf1VPI8SoJ6tr18p

The post SO-101 Robot Arm Meets Arduino VENTUNO Q: Local-AI Pick-and-Place appeared first on Open Electronics.

• Read more about This Open-Source DIY Drone Uses FMCW Radar and RTK GPS for High-Resolution SAR Imaging and Ground Mapping
• Log in or register to post comments

A recent article revealed that OpenAI is purchasing tens of thousands of Mac minis and Mac Studios to give AI agents dedicated environments to run, make mistakes, and learn. It’s a smart infrastructure decision for agents meant to operate inside a computer clicking, navigating, using software: they need a full computer to practice on. But it got us wondering: is that always the right environment for an agent?

Why agents need their own environment

An AI agent isn’t a chatbot. It perceives a situation, takes an action, observes the result, adjusts, and tries again – in a loop that requires a persistent local environment with compute, I/O, and feedback. You can’t outsource the whole thing to a cloud API, because the agent needs somewhere to live and something to interact with. In OpenAI’s situation, the answer is: give it a computer. That works well when the goal is teaching agents to use software. But software isn’t the whole world.

Physical AI needs something different (and surprisingly cheaper)

A Mac mini today starts at around $900. At the scale OpenAI is reportedly operating, the infrastructure bill is substantial. That cost is justified when you need a full computing environment. But what if the agent’s environment doesn’t need to be a general-purpose computer? What if it needs to be a temperature sensor, a camera feed, a production line?

At a fraction of the cost, an Arduino^® VENTUNO Q board can provide a persistent Linux environment for the agent runtime, local AI inference, and direct access to real-world I/O: cameras, sensors, actuators. The economics of deploying agent environments at scale look very different when each node costs significantly less, and can be embedded directly in the physical context it’s meant to ultimately operate in.

What an Arduino agentic environment actually looks like

VENTUNO Q is built to combine a Linux-capable MPU with NPU acceleration and a dedicated real-time MCU on a single board. The Linux side is engineered to run the agent – its reasoning, its model, its decision logic. The MCU side is designed to connect it to the world: motors, sensors, cameras, industrial interfaces. No cloud dependency. No separate controller. One self-contained unit that perceives, decides, and acts.

Arduino^® UNO Q is structured to extend this further as a low-cost remote node. David Groom demonstrated this clearly leveraging OpenClaw, developing an agent framework on UNO Q designed to enable agents to interact with physical hardware. By connecting to Arduino shields and accessing additional hardware capabilities, the framework supports physical-world interactions while enabling deployment across multiple units simultaneously, each maintaining its own context and operational role.

Read about David Groom’s OpenClaw project here.

With these tools, it’s easy to envision a “swarm” model: VENTUNO Q built to serve as a local processing hub, with UNO Q units designed for distributed deployment as remote nodes, all supporting agent-based workflows that interact with physical environments rather than simulated ones.

More agents, more learning, lower cost

This is where the conversation becomes more interesting than individual compute specifications alone. Lower deployment costs can make broader deployment economically feasible, creating opportunities for more agent interactions, richer feedback loops, and exposure to a wider range of real-world operating conditions.

An agent that has operated across multiple physical environments, each with its own sensors, lighting conditions, and sources of noise, may be exposed to a broader set of inputs than an agent trained exclusively in software simulations.

Arduino can give agents something else to learn from: the physical world. By combining accessible hardware with scalable deployment models, Arduino platforms are designed to support the creation of large numbers of agent-enabled environments for experimentation, testing, and real-world interaction.

Ready to build your own agentic environment?

UNO Q is available on the Arduino Store, and can be ordered from DigiKey, Farnell, Mouser, Newark, RS Components, Robu.in, and other authorized distributors and resellers worldwide.

VENTUNO Q is also available on the Arduino Store or through our official distribution partners: DigiKey, Farnell, Kubii, Mouser, Robu.in, and RS, along with other authorized distributors and resellers.  

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

The post How little does an AI agent need, and how cheap can it get? appeared first on Arduino Blog.

This project builds a basic electronic door lock with the Arduino UNO R4 WiFi. A touch sensor detects contact, a relay controls a solenoid lock, and an OLED display shows the system status. The principle is simple: touch the sensor, the door unlocks for 5 seconds, then locks itself again. It is a starting point for customizable smart locking systems.

The central board is the Arduino UNO R4 WiFi, which manages the whole flow. The touch sensor sends a signal to the board, which activates the relay to power the lock. The 128×64 pixel OLED display shows the startup, locked, and unlocked screens. The system uses a relay module to separate the control circuit from the power circuit, so the solenoid lock operates safely.

The circuit and components of the lock

Assembly requires few components: the Arduino board, the touch sensor, the OLED display, the relay module, and a solenoid lock. Everything connects on a breadboard with jumper wires. The relay is essential because the lock runs at 12 VDC, while the Arduino operates at 5 V. Without the relay, the lock’s current would damage the board.

The OLED display connects via I2C, using the SSD1306 and Adafruit_GFX libraries. The 128×64 pixel resolution is enough to show the system status with clear characters. The touch sensor connects to a digital pin: when it detects a touch, it sends a high signal to the Arduino. The response is immediate, and the relay trips right away.

The firmware and unlock time

The code is written in the Arduino IDE and uses the SSD1306, Adafruit_GFX, and Adafruit_SSD1306 libraries. The sketch reads the touch sensor state and, when it detects a touch, activates the relay. The display shows the unlock screen for 5 seconds, then the system locks the door again. The unlock time is fixed at 5 seconds, but it can be changed in the code.

The operation is cyclic: startup, waiting, unlock, relock. The OLED display updates the status in real time, so you always know whether the door is locked or unlocked. The project demonstrates the principle of a basic electronic lock, and the maker’s website collects the details for replicating it. It is a simple but complete system.

For assembly you also need a universal acrylic support to keep the Arduino and breadboard tidy. 15 cm male-to-female jumper wires help connect the modules without soldering. The project can be expanded with a numeric keypad, an RFID reader, or a Wi-Fi module for remote control.

In short, this project is an excellent base for anyone who wants to understand how an electronic lock works. The components are few, the code is essential, and the result is functional. With the Arduino UNO R4 WiFi you also have the option to add connectivity in the future, turning the prototype into a real smart lock.

Source: https://srituhobby.com/how-to-make-a-solenoid-door-lock-system-using-a-touch-sensor/

The post Electronic door lock with Arduino UNO R4 WiFi and touch sensor appeared first on Open Electronics.