Today we’re diving into one of the most beginner-friendly – yet surprisingly powerful – hardware ecosystems Arduino has ever released: the Modulino series of plug-and-play sensor and actuator modules.

Introduction

If you’ve ever been frustrated by tangled jumper wires, confusing schematics, or the dreaded breadboard, Modulino is going to change your world. These compact modules connect to your Arduino board using a single Qwiic cable – no soldering, no wiring diagrams, no fuss. Just plug in and start coding.

And coding with Modulino is just as simple, thanks to C++ and MicroPython libraries and code examples provided by Arduino.

Today, we are going to look at the Modulino series of modules and run through some example code. You’ll soon see how easy these modules are to use, and it should inspire you to build a few Modulino projects yourself.

What is Modulino?

Modulino is a growing family of pre-assembled sensor and actuator modules from Arduino. Each module performs a specific function – measuring temperature, detecting distance, flashing LEDs, buzzing a tune, and more – and every single one communicates with your microcontroller over the I²C bus using a Qwiic (also known as STEMMA QT) connector.

The Modulino modules are a bit like other I²C modules you may have seen from companies like Adafruit and SparkFun. However, there are some important differences. First, all Modulino modules are intelligent. Most of them have built-in microcontrollers or very intelligent controllers, and they can be programmed. Things like their I²C address can be changed through software. Another key advantage is that all Modulino modules share the same form factor – 25.36 mm wide and 41 mm long – making them very easy to work with and to physically stack.

Arduino has provided libraries for both C++ and MicroPython that make coding for these modules incredibly easy. The pre-processing built into the modules is also noteworthy – for example, the light sensor outputs directly in lux, the distance sensor in millimeters, and the temperature sensor has an accuracy of ±0.2°C. This built-in intelligence makes your code simpler and your projects more accurate.

All Modulino modules have two Qwiic connectors for easy I²C daisy-chaining. You can also make an I²C connection using the breakout pins on the side of each module. The other side of each module has function-specific pins that depend upon what the module does. Modulino modules work on 3.3-volt logic and will not support 5V power or logic.

The Plug and Make Kit

Modulino was introduced as part of the Arduino Plug and Make Kit – a beginner kit built around the Arduino UNO R4 WiFi. The kit includes seven Modulino modules, a Modulino Base (an aluminum mounting plate), Qwiic cables, and all the hardware needed to neatly bolt everything together. It includes guided online projects and is designed to get a complete beginner up and running within a single session.

Since then, the Modulino range has expanded. Today, there are twelve individual modules available, covering inputs, outputs, sensing, and display. You can buy modules individually or as part of the kit. Every module works with the Arduino UNO R4 WiFi, Arduino Nano boards (using a Nano Connector Carrier), and any board with a Qwiic interface.

The quality of these modules is excellent. They are built on high-quality printed circuit boards with precision components, and they are surprisingly inexpensive. You can collect them a few at a time by adding them to your shopping cart at distributors like Digi-Key.

Modulino Modules

Let’s meet the full Modulino family. There are currently twelve modules in the range, covering inputs, outputs, sensors, and displays. Every module communicates over I²C and shares the same compact 41 mm × 25.36 mm form factor.

The following table provides a quick-reference summary, and we’ll explore each group in more detail below.

Module	Key Chip	Function	I²C Addr
Buttons	STM32C011	3 push-buttons with 3 orange LEDs, I²C via onboard MCU	0x7C
Knob	STM32C011	Rotary encoder with push-button, I²C via onboard MCU	0x76
Joystick	STM32C011	Dual-axis analog joystick with push-button	0x7C
Buzzer	STM32C011	PWM piezo buzzer with onboard tone generator	0x3C
Vibra	DRV2605L	Haptic feedback driver with two vibration motors	0x5A
Latch Relay	STM32C011	Latching relay, 30V DC @ 2A, retains state without power	0x36
Distance	VL53L4CD	Time-of-flight sensor, 1 cm to 130 cm range	0x29
Light	APDS-9960	Ambient light sensor, reports value in lux	0x39
Thermo	HS3003	Temperature (±0.2°C) and humidity sensor	0x44
Movement	LSM6DSOX	6-DOF IMU (accelerometer + gyroscope)	0x6A
LED Matrix	IS31FL3745	12×8 LED matrix, same as UNO R4 onboard matrix	0x20
Pixels	IN-PI55TAT	8 addressable NeoPixel RGB LEDs	0x6C

Input Devices

Modulino Buttons

The Buttons module features three independent push-buttons, each paired with an orange LED that can be individually controlled via I²C. The onboard STM32C011 microcontroller handles debouncing and provides press, long-press, and release callbacks through the Modulino library. This makes it ideal for menu navigation, user input, and triggering events in interactive projects.

Modulino Knob

The Knob module includes a rotary encoder with a push-button, interfaced through an onboard STM32C011 MCU. It outputs a position value that you can read and set through the library. The knob is similar to the rotary encoder modules that many makers are already familiar with, but the Modulino library makes it much simpler to use. It’s well-suited for setting values, scrolling through menus, and precision control applications.

Modulino Joystick

The Joystick module provides a dual-axis analog joystick with an integrated push-button. It outputs positive and negative values for both the X and Y axes (ranging from -127 to +127) as well as a button output. Internally, the joystick has 4,095 resolution increments, which are scaled down by the onboard STM32C011 MCU. A configurable dead zone can be set in software to prevent jitter around the center position. This module is perfect for gaming controllers, robotics navigation, and interactive interfaces.

Output Devices

Modulino Buzzer

The Buzzer module is more than a simple buzzer – it features a pulse-width-modulated piezo buzzer with an onboard PWM generator handled by the STM32C011 MCU. You can send it commands specifying a frequency in Hertz and a duration in milliseconds, making it easy to create simple sounds, musical notes, or alarm tones in your projects.

Modulino Vibra

The Vibra module is a haptic feedback driver built around the DRV2605L. It has pre-programmed effects for the two different vibration motors included on the module. This is a rare find at this price point and opens up haptic feedback projects – such as wearable alerts and tactile notifications – that were previously complicated to implement.

Modulino Latch Relay

The Latch Relay module is a latching relay that only needs power applied momentarily to change state – it retains its position even when power is removed. It can handle 30V DC at 2 amps on its contacts, making it suitable for switching external DC loads. Because it is a latching relay, it is very low power compared to conventional relay modules.

Sensors

Modulino Distance

The Distance module uses the VL53L4CD time-of-flight sensor, providing accurate distance measurement from 1 cm to 130 cm. The sensor outputs readings directly in millimeters, so there is no need for any conversion in your code. It’s a sensitive sensor that updates quickly, making it suitable for obstacle detection, gesture sensing, and level measurement.

Modulino Light

The Light module is built around the APDS-9960 sensor and is more than a simple photoresistor. It reports ambient light directly in lux, greatly simplifying programming for light-aware projects. You can use it for automatic brightness control, day/night detection, and environmental monitoring.

Modulino Thermo

The Thermo module uses the HS3003 sensor to provide both temperature and humidity readings. The temperature accuracy is impressive at ±0.2°C, making this module suitable for precision environmental monitoring. The library provides simple methods to read temperature and humidity values directly.

Modulino Movement

The Movement module is a 6-degree-of-freedom inertial measurement unit (IMU) built around the LSM6DSOX sensor. It combines a 3-axis accelerometer and a 3-axis gyroscope, making it ideal for motion tracking, orientation detection, tilt sensing, and robotics applications.

Light

Modulino LED Matrix

The LED Matrix module features a 12×8 LED matrix that matches the one on the Arduino UNO R4 and Uno Q and can be programmed in the same way using the Arduino LED Matrix library. It’s driven by the IS31FL3745 LED driver, and you can display scrolling text, patterns, icons, and simple animations. It is a great visual output for data display and status indication.

Modulino Pixels

The Pixels module has eight individually addressable NeoPixel RGB LEDs. Each LED can be set to any color and brightness, making this module useful for status indicators, bar graphs, decorative lighting, and visual feedback. In many demo projects, it serves as a colorful indicator bar alongside other sensor modules.

Modulino with Arduino

Let’s start using the Modulino modules with the Arduino IDE. For these demonstrations, we’ll be connecting Modulino modules to an Arduino UNO R4 WiFi board using Qwiic cables, but you could use any microcontroller that has 3.3V I²C – it doesn’t even have to be an Arduino, and it doesn’t have to have a Qwiic connector, although that does make things easier. Every Modulino module comes with a short Qwiic cable, so you don’t need to purchase them separately.

Installing the Modulino Library

The Modulino library is available directly from the Arduino Library Manager. This single library covers every Modulino module – you don’t need separate libraries for each one.

To install the Modulino library:

1. Open the Arduino IDE and make sure you have the latest updates installed.
2. Go to the Library Manager. You can find this in the sidebar or under Sketch → Include Library → Manage Libraries.
3. Filter for the word “Modulino” in the search box.
4. Find “Arduino Modulino by Arduino” and click Install.
5. Install all dependencies when prompted – this is important.

When you install the library, several example sketches are also installed. There are examples for virtually every module, plus utility sketches, including one that allows you to change the I²C address of any Modulino module – useful if you have two of the same module or if there is an address conflict in your circuit.

Demo 1: Simple Melody with the Modulino Buzzer

Our first demonstration uses the Modulino Buzzer module to play a simple sequence of eight musical tones. The circuit is as simple as it gets – just one Qwiic cable between the Buzzer module and the UNO R4 WiFi.

This sketch is included with the Modulino library as the “Simple_melody” example under the Modulino_Buzzer examples.

Here is the code:

How the Sketch Works

The sketch begins by including the Modulino library – this single include file is all you need for any Modulino module. We then create a ModulinoBuzzer object called “buzzer”.

Next, we define an array of eight integer values representing the frequencies of musical notes in Hertz. These correspond to the notes C4 through C5 (one octave of the C major scale). A value of zero in the array would represent a rest or silence.

In the setup function, we call Modulino.begin() to initialize the I²C bus, and then buzzer.begin() to initialize the Buzzer module specifically. Notice how simple the setup is – this pattern is the same for every Modulino module.

The loop function uses a simple for loop to step through each note in the array. For each note, it calls buzzer.tone() with two parameters: the frequency in Hertz and the duration in milliseconds (250 ms in this case). A second delay of 250 milliseconds between notes provides a brief pause. The result is a continuous repeating melody. The sketch is intended to play the beginning of Happy Birthday, although you may or may not recognize it!

This example demonstrates how the Modulino library abstracts away the complexity of I²C communication. You don’t need to worry about registers, addresses, or protocols – just tell the buzzer what frequency and how long.

Demo 2: Joystick Direction Detection

Our second demonstration uses the Modulino Joystick module. This is the “Advanced Example – Direction Detection” from the Arduino documentation. It determines whether the joystick is moving up, down, left, right, or centered, and also detects button presses. The circuit is once again a single Qwiic cable between the Joystick module and the UNO R4 WiFi.

Here is the code:

How the Sketch Works

Once again, we include the Modulino library and create a ModulinoJoystick object. We also define a constant called MOVE_THRESHOLD – this is the amount of movement we need to detect before we consider the joystick to have actually moved in a direction. The joystick outputs values between -127 and +127 for both the X and Y axes, even though it has an internal resolution of 4,095.

In setup, we initialize the serial monitor, the Modulino I²C bus, and the joystick. We also set a dead zone of 20 – this prevents jitter when the joystick is at rest. You can adjust this value to change the sensitivity.

The loop function calls joystick.update() to check for new data. If data is available, we read the X and Y positions and the button state. We start with a direction of “CENTER” and then compare the Y-axis against our threshold to determine if we’re moving up or down, and the X-axis for left or right. If the button is pressed (you push down on the joystick), we append “[ACTION]” to the output.

In our demonstration, moving the joystick in different directions correctly reported RIGHT, LEFT, UP, and DOWN in the serial monitor, and pressing the button registered as well. You could use this as the basis for a game controller or a robot’s navigation system.

Modulino with MicroPython

Modulino modules are not limited to the Arduino C++ environment. Arduino provides an official MicroPython library that works with any MicroPython-capable board.

There is a bit of a backstory to this section. I tried, without success, to get MicroPython running on the Arduino UNO R4 WiFi. Arduino has an online utility for installing MicroPython, but it would not recognize my board – and I tried four different UNO R4 WiFi boards. So I switched over to the Arduino Nano RP2040 Connect, a board built around the Raspberry Pi RP2040 microcontroller.

Installing MicroPython on the Nano RP2040 Connect was straightforward – not through the Arduino utility, but through the standard MicroPython website, where you download the UF2 firmware file and copy it to the board’s storage. That worked just fine.

Installing the Modulino MicroPython Library

Arduino has an official MicroPython library for Modulino on GitHub. I ran into problems with Arduino’s own package installer utility – the installation kept failing, although installing other packages through the same utility worked fine. I suspect there is an issue with the Modulino package specifically.

The workaround was to use mpremote to install the library directly from the GitHub repository:

This installed the Modulino library successfully. You can verify the installation by checking the lib folder on your board; you should see a modulino directory containing code for each Modulino module.

Connecting Modulino to the Nano RP2040 Connect

The Nano RP2040 Connect does not have a Qwiic connector, so I soldered header pins to the Modulino Buttons module and connected the SDA and SCL lines directly to the Nano board’s corresponding I²C pins. This is a good example of how you can use Modulino modules with just about any microcontroller – the breakout pins on the side of each module make it possible to connect without Qwiic.

Demo: MicroPython Buttons Example

With MicroPython and the Modulino library installed, I ran the Buttons example from the Arduino Modulino MicroPython repository. This script demonstrates how to use the ModulinoButtons class to interact with the module’s three buttons and three LEDs.

Here is the code:

How the Script Works

The script begins by importing the ModulinoButtons class from the modulino library and the sleep function from the time library. We then create a ModulinoButtons object called “buttons”.

Next, we assign callback functions for each button event. The MicroPython library provides callbacks for press, long press, and release events on each of the three buttons (A, B, and C). In this example, each callback simply prints a message to the REPL window – for instance, “Button A pressed” or “Button B long press.” In a real project, you would replace these print statements with whatever actions you want to trigger.

Before entering the main loop, the script performs a brief LED startup sequence: it turns on LED A, waits half a second, turns on LED B, waits again, turns on LED C, waits, and then turns all three LEDs off. This visual confirmation indicates that the script is running.

The main while loop continuously calls buttons.update() to check for state changes. If a button state has changed, it reads the pressed status of each button (indexed 0, 1, and 2 for buttons A, B, and C, respectively) and sets the corresponding LED to match. So pressing button A lights up LED A, pressing button B lights up LED B, and so on.

In our demonstration, pressing each button correctly printed the corresponding message to the REPL window and illuminated the LED above that button. Holding a button down triggered the long-press callback, and releasing it triggered the release callback. It worked exactly as advertised and demonstrates that MicroPython is a fully viable alternative to C++ for Modulino development.

All Modulino Demo

If you’re looking for project ideas, a great place to visit is the Arduino Project Hub. I went looking for a project that used multiple Modulino modules and found an excellent one: the “Arduino Plug and Make Kit All-Modulino Demo” by Mete Hoca.

This project demonstrates seven Modulino modules working together in a single sketch on the Arduino UNO R4 WiFi. It uses the Buttons, Buzzer, Pixels, Knob (encoder), Distance, Movement (IMU), and Thermo modules, along with the onboard 12×8 LED matrix on the UNO R4 WiFi.

What the Demo Does

The sketch performs the following tasks:

• On startup, it plays a sequence of 8 musical notes through the Buzzer while lighting the corresponding LEDs on the Pixels module green.
• It displays a heart pattern on the UNO R4 WiFi’s onboard LED matrix.
• In the main loop, it continuously reads and outputs IMU data (X, Y, Z acceleration), temperature, humidity, distance, and encoder position to the Serial Monitor.
• It responds to button presses and the encoder button by sounding the buzzer and changing Pixel LED colors from green to red, providing interactive visual and audio feedback.

How the Code Works

Here is the code for this project:

The code starts by including the Modulino library and the Arduino LED Matrix library. It then creates objects for each of the seven Modulino modules plus the onboard LED matrix. This is a great example of how you initialize multiple Modulino modules – you simply create an object for each one and call begin() on all of them in setup.

An array of eight note frequencies defines the melody, and a uint32_t array defines the heart pattern for the LED matrix. In setup, after initializing all components, a for loop plays each note while simultaneously lighting up a green LED at the corresponding position on the Pixels module. After the melody, the heart pattern is loaded onto the LED matrix.

The main loop uses a millis-based timing approach (rather than delay) with a 200-millisecond interval. This is a better practice than using delay() because it doesn’t block other processing. Within each interval, the sketch reads the IMU, temperature, humidity, distance, and encoder values and prints them to the serial monitor. The encoder value is bounded between 0 and 100, and it resets if it exceeds the range.

The interactive section checks the three buttons and the encoder button. When a button is pressed, the corresponding Pixel LED turns red, and the buzzer plays a short tone. When released, the LED returns to green. This gives satisfying visual and audio feedback for each button press.

In our demonstration, the serial monitor displayed a continuous stream of sensor data – you could see the IMU values, temperature, humidity, distance readings (which responded when you moved your hand near the sensor), and the encoder position. Pressing the buttons triggered audible tones and visible LED changes. It’s a really good example of how to use multiple Modulino modules together in a single project.

Conclusion

The Arduino Modulino system represents one of the most accessible and well-designed plug-and-play ecosystems available for microcontroller projects today. In this article, we’ve covered a lot of ground:

• We explored all twelve Modulino modules, from the simple Buttons and Buzzer through to the sophisticated Movement IMU, Distance sensor, and the unique Vibra haptic feedback module.
• We set up the Arduino IDE, installed the Modulino library from the Library Manager, and demonstrated two example sketches – the Simple Melody buzzer demo and the Joystick direction detection example.
• We installed MicroPython on an Arduino Nano RP2040 Connect, loaded the Modulino MicroPython library using mpremote, and demonstrated the Buttons example – proving that MicroPython is a fully viable alternative for Modulino development.
• We ran the All Modulino Demo from the Arduino Project Hub – a fantastic showcase of seven modules working together in a single interactive sketch.

The consistent I²C interface, Qwiic connectivity, and comprehensive libraries make Modulino an outstanding platform for a wide range of users:

• Students will appreciate the gentle learning curve – no soldering, no wiring diagrams, and example code that gets you up and running in minutes.
• Educators will find the consistent API and plug-and-play connectivity ideal for structured lessons and hands-on workshops. The dual-language support (C++ and MicroPython) also means you can teach both languages with the same hardware.
• Engineers and prototypers will love the ability to go from idea to working prototype in minutes. Swap modules in and out as your project evolves – no re-wiring required.
• Makers and hobbyists will enjoy the sheer fun of these modules. The quality is excellent, the prices are reasonable, and the range of available sensors and actuators means there’s always something new to try.

Whether you’re building a home climate monitor, a robot controller, a musical instrument, or just exploring the world of microcontrollers for the first time, Arduino Modulino modules are an excellent choice. They take the frustration out of wiring and let you focus on what really matters – writing code and bringing your ideas to life.

Resources

General Modulino Overview – Arduino’s Guide to the Modulino Series

Arduino Modulino MicroPython Library – The Library for MicroPython on GitHub