ArduinoMania

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.

Source: https://www.hackster.io/manivannan/smart-ai-boxing-band-bddc39

Related products

• Arduino Nano Matter – IoT Board with Matter® and Bluetooth

The post Boxing Band Counts Punches and Analyses Them in Real Time appeared first on Open Electronics.

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:

• Tangible Tech with the Arduino^® VENTUNO Q board: Get an up-close look at physical AI with the Tangible Tech demo powered by VENTUNO Q, demonstrating how supported hardware can process inputs and respond to physical interactions with low latency.
• 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^® UNO Q and 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.

Don’t miss the keynotes and stage talks 

As many of you will remember, Maker Faire Rome 2025 was the first public event where we presented UNO Q. After one year, we take the stage to celebrate! 

Mark your calendars for two key presentations:

• 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.

The post See you at Maker Faire Rome 2026! appeared first on Arduino Blog.

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

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

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

Start with a project

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

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

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

Your first Zigbee device, in one screen of code

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

#include 
#include 

ZigbeeTemperatureSensor sensor;

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

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

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

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

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

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

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

What’s in the box

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

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

Two features stand out:

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

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

Both ends of the network

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

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

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

python3 extra_firmware_flasher.py nano_matter zigbee

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

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

Ideas to try this weekend

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

A board that grows with you

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

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

Get started

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

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

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

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

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

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

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

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

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

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

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

The complete audio-visual hardware

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

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

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

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

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

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

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

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

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

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

Active and passive buzzer module: the difference

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

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

The four modules compared

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

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

Testing with Arduino: square wave and tone()

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

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

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

Multi Test Shield and micro:bit

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

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

Where to find the modules

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

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

Related products

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

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

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

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

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

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

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

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

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

What the BH1750 sensor measures

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

Measurement modes and resolution

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

Each mode offers three levels of precision:

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

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

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

The GY-302 module: power, pinout and address

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

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

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

Connecting it to an Arduino UNO and an OLED display

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

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

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

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

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

Related products

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

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

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

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

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

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

The original project with GIGA

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

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

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

The new, limit-stretching version

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

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

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

The great challenge of smaller platforms

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

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

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

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

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

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

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

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

Thank you.

The year in numbers*

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

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

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

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

*As of September 29, 2026

Where it started

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

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

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

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

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

Your ideas, our proudest moments

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

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

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

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

Open by design: UNO and beyond

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

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

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

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

Stronger together

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

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

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

A prototype is only the beginning

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

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

The software stack follows you, too: 

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

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

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

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

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

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

It is just the beginning

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

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

Happy first birthday, UNO Q! 

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

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

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

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