diff --git a/content/hardware/11.accessories/modulino-nodes/modulino-buttons/tutorials/how-buttons-ardu/how-to-buttons-ardu.md b/content/hardware/11.accessories/modulino-nodes/modulino-buttons/tutorials/how-buttons-ardu/how-to-buttons-ardu.md index bb984214db..23b7518510 100644 --- a/content/hardware/11.accessories/modulino-nodes/modulino-buttons/tutorials/how-buttons-ardu/how-to-buttons-ardu.md +++ b/content/hardware/11.accessories/modulino-nodes/modulino-buttons/tutorials/how-buttons-ardu/how-to-buttons-ardu.md @@ -12,7 +12,9 @@ software: - ide-v2 - web-editor --- + The Modulino Buttons is a modular sensor that provides tactile input and visual feedback, making it perfect to add interactive controls to your projects! + The Modulino form factor is shaped with two QWIIC connectors and the I²C protocol integration, allowing the connection and programming of multiple modulinos in a very simple way. In addition to the QWIIC's connectors, the Modulinos also expose solderable pins that can be used in multiple ways and make them compatible with boards that are not QWIIC compatible. ![Module demonstration](assets/connection-guide-buttons.gif) @@ -20,7 +22,7 @@ The Modulino form factor is shaped with two QWIIC connectors and the I²C protoc Pressing a button pulls the signal LOW, and each button has an onboard pull-up resistor. The LEDs can be controlled independently through the onboard microcontroller. -# General Characteristics +## General Characteristics The **Modulino Buttons** module uses three tactile buttons and LEDs, which do not have native I²C capabilities. Instead, the buttons and LEDs are controlled by the Modulino's onboard microcontroller (STM32C011F4U6TR). This microcontroller provides I²C communication, allowing for flexible reading of button states and control of the LEDs. One unique feature of this setup is the ability to change the I²C address via software. This means the address can be modified based on your application needs, making it adaptable to different system configurations. @@ -40,6 +42,7 @@ The default I²C address for the **Modulino Buttons** module is: | 0x7C | 0x3E | Any custom address (via software configuration) | When scanning for I²C address on the bus, you might find the modulino using the **Hardware I²C Address**. However, you should always use the **Modulino I²C Address** when using the official Modulino library. + Later in this article we teach how to [change the address](#how-to-change-i2c-address). ## Pinout @@ -105,58 +108,77 @@ The Modulino Buttons uses a simple circuit, as shown in the schematic below: ![Full Schematic Modulino Buttons](assets/schematic.png) The main components are the **three tactile buttons**, **three user-programmable LEDs** and the **STM32C011F4U6TR** microcontroller (U1), which handles button state reading, LED control, as well as I²C communication. + You can connect to the I²C pins (SDA and SCL) using either the **QWIIC connectors** (J1 and J2, this is the recommended method) or the **solderable pins** (J4). The board runs on **3.3V**, which comes from the QWIIC cable or the **3V3 pin** on J4. + There's also a small power LED indicator that lights up when the board is on. You can grab the full schematic and PCB files from the [Modulino Buttons](https://docs.arduino.cc/hardware/modulinos/modulino-buttons) product page. ## How To Connect Your Modulino The easiest and most reliable way to connect your Modulino is through the QWIIC Connect System. It’s plug-and-play, uses standard I²C, and makes it easy to join multiple modules. If your board supports QWIIC, this is the recommended way to go. + Note that the dedicated I²C pins will differ from board to board meaning it is always a good idea to check your specific model. ![Modulino Wiring Options QWIIC(A - recommended) and Header(B)](assets/connection-guide-buttons.png) -## QWIIC Connector +### QWIIC Connector + Whenever available, the **QWIIC Connect System** is the preferred method. Connecting to the Modulino is extremely simple, just use a standard QWIIC cable to connect your board to either of the QWIIC connectors on the Modulino. Because the cable and connectors are polarized, there is no need to worry about accidentally swapping connections. + QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connectors: + - GND - 3.3V - SDA (Data) - SCL (Clock) ![Connection Guide QWIIC](assets/connection-guide-buttons-qwiik.png) + The Modulino features two QWIIC connectors, which are internally connected in parallel. This means you can daisy-chain multiple modules easily by connecting additional QWIIC cables between them. -## Solderable Header +### Solderable Header + When QWIIC is not available, you can use the exposed solderable pins on the module. You can solder pins to the unpopulated pads; just remember the pinout provided in this guide to connect to the right pins of your board. ![Connection Guide Solder Pads](assets/connection-guide-buttons-jumper.png) -## Daisy-Chaining Multiple Modulinos +### Daisy-Chaining Multiple Modulinos Regardless of whether you connect the first Modulino via QWIIC or through the solderable pins, you can still take advantage of the extra QWIIC connector to daisy-chain additional modules. Each Modulino includes two QWIIC connectors wired in parallel, allowing you to connect one module to the next in a chain. As long as each module is configured with a unique I²C address, they can all communicate on the same bus. + This approach keeps your setup clean, modular, and expandable without adding extra wiring complexity. ![Modulino Wiring Options](assets/connection-guide-buttons-qwiic-chain.png) + ***The number of modules you can connect will depend on what modules you are chaining together, as this system allows for multiple sensors from different manufacturers to be added. Also, the cables you use for these connections will play a significant role in the setup’s performance. Ensure your cables are properly connected and capable of handling the required data transfer. Each module should have a unique address on a chain if you plan to address them individually. Later in this article we teach how to [change the address](#how-to-change-i2c-address). Multiple modules with the same address will cause conflicts on the I²C bus and will not allow you to address them individually.*** -# How To Use Your Modulino -## Installing The Modulino Library +## How To Use Your Modulino + +### Installing The Modulino Library + You need the official Modulino library available [here](https://docs.arduino.cc/libraries/modulino/) to use the Modulino Buttons. With the Arduino IDE you get some tools that make adding a library easier. To learn how to install the IDE please visit our [page](https://docs.arduino.cc/software/ide-v2/tutorials/getting-started/ide-v2-downloading-and-installing/). + After opening the IDE, a tab should be visible on the left. Press the book icon for "library" as highlighted in the image. + ![IDE Library Tab](assets/IDE-Left-Tab.png) + The process should look like this: + ![Library Install](assets/library-install.gif) + A message will appear after the installation is successful. -# Getting Button Press Data +### Getting Button Press Data Interacting with the Modulino Buttons module is simple using the `Modulino` library. + For the **Buttons** module, there are two key functions: + - `update()`**:** Requests new data from the button module. - `isPressed(index)`**:** Checks if a specific button (`A`, `B`, or `C`) is pressed. - `setLeds(A, B, C)`**:** Sets the state of the LED (`A`, `B`, or `C`). @@ -195,11 +217,12 @@ void loop() { ``` The code example provided shows how to initialize the button module, read button states, and control the LEDs. The program begins by turning on all three LEDs, then continuously checks for button presses and reports them through the serial monitor. Each button is identified by its index (0 for A, 1 for B, 2 for C), making it easy to expand the functionality for more complex interactions. This simple interface can be adapted to trigger various actions in your projects, from controlling other components to navigating menus or implementing game controls. -# Detecting Button Events +### Detecting Button Events The Modulino Buttons module can be enhanced with the [Button2 library](https://docs.arduino.cc/libraries/button2/) to detect various button events beyond simple presses. This approach allows you to respond to single clicks, double clicks, triple clicks, and long presses. For the **Button Events** functionality, there are several key functions: + - `setButtonStateFunction(function)`**:** Sets a custom function that provides the button state. - `setClickHandler(function)`**:** Sets a handler for single-click events. - `setDoubleClickHandler(function)`**:** Sets a handler for double-click events. @@ -264,16 +287,19 @@ void loop() { The code example provided shows how to integrate the Button2 library with the Modulino Buttons module to detect advanced button interactions. It creates a virtual button connected to Button A (index 0) and sets up handlers for different types of clicks. The `button0StateHandler()` function serves as a bridge between the Modulino hardware and the Button2 library by converting the button state to the expected format. When running, the program will detect and report single clicks, double clicks, triple clicks, and long presses through the serial monitor. This approach enables more sophisticated user interfaces in your projects, from navigating multi-level menus to implementing different functions based on how a user interacts with a single button. -## How To Change I2C Address +### How To Change I2C Address An example sketch, AddressChanger, is also included with the library inside the `Utilities` folder and available [here](https://github.com/arduino-libraries/Modulino/blob/main/examples/Utilities/AddressChanger/AddressChanger.ino). This sketch changes the I²C address at a software level on the Module's microcontroller. + ![Example location on the IDE](assets/AdressChangeIDE.png) - Connect the module to your board, remove any other modules that might be in the chain. Connection must be via I²C. - Upload the sketch. - Open the Serial Monitor. - Text should now appear. Make sure the correct bauld-rate is selected if the displayed characters seem corrupted. + ![Expected console output](assets/adressChanger.png) + - Select the address and confirm. Valid I²C addresses range from 0x08 to 0x77 (7-bit values in hexadecimal format, e.g., 0x42). - Your address should now have changed. Make sure to take note of the selected address. @@ -285,30 +311,37 @@ ModulinoButtons buttons(0x3E); // Replace 0x3E with your specific address ``` -# Troubleshooting +## Troubleshooting + +### Buttons Not Responding -## Buttons Not Responding If your Modulino's power LED isn't on or the buttons aren't responsive, first check that the board is properly connected: + - Ensure both the board and the Modulino are connected to your computer, and that the power LEDs on both are lit. - If the issue persists, make sure the Qwiic cable is properly clicked into place. -## Library Not Installed Properly +### Library Not Installed Properly + If you encounter an issue with the `#include "modulino.h"` command, verify that the Modulino library is correctly installed: + - Check your IDE to ensure the library is installed and up-to-date. - Re-install the library through the Library Manager. -## LEDs Not Working +### LEDs Not Working + If the LEDs aren't lighting up as expected, make sure: + - The correct LED states are being set in your code (true for on, false for off). - All exposed electronics are not touching any conductive surfaces, as this could interfere with the operation. -# Conclusion +## Conclusion The **Modulino Buttons** is a digital input and output device that communicates over I²C and follows the Modulino form factor. It includes standard Qwiic connectors for quick, solderless connections and easy daisy-chaining with other modules. Paired with the Modulino library, it makes detecting button presses and controlling LEDs straightforward, allowing you to focus on experimenting or building your system logic. It's a small, reliable module suited for both user interfaces and interactive control systems. -# What Is Next? +## What Is Next? Now that you've learned how to use your Modulino Buttons, you're all set to integrate it into your projects! + - Create a simple menu system where each button performs a different function. - Build a game controller for a simple arcade-style game. - Use the buttons to control other Modulino devices in your project. diff --git a/content/hardware/11.accessories/modulino-nodes/modulino-buttons/tutorials/how-buttons-mp/how-to-buttons-mp.md b/content/hardware/11.accessories/modulino-nodes/modulino-buttons/tutorials/how-buttons-mp/how-to-buttons-mp.md index d693d1dda4..ee45a1c402 100644 --- a/content/hardware/11.accessories/modulino-nodes/modulino-buttons/tutorials/how-buttons-mp/how-to-buttons-mp.md +++ b/content/hardware/11.accessories/modulino-nodes/modulino-buttons/tutorials/how-buttons-mp/how-to-buttons-mp.md @@ -12,7 +12,9 @@ software: - ide-v2 - web-editor --- + The Modulino Buttons is a modular sensor that provides tactile input and visual feedback, making it perfect to add interactive controls to your projects! + The Modulino form factor is shaped with two QWIIC connectors and the I²C protocol integration, allowing the connection and programming of multiple modulinos in a very simple way. In addition to the QWIIC's connectors, the Modulinos also expose solderable pins that can be used in multiple ways and make them compatible with boards that are not QWIIC compatible. ![Module demonstration](assets/connection-guide-buttons.gif) @@ -20,7 +22,7 @@ The Modulino form factor is shaped with two QWIIC connectors and the I²C protoc Pressing a button pulls the signal LOW, and each button has an onboard pull-up resistor. The LEDs can be controlled independently through the onboard microcontroller. -# General Characteristics +## General Characteristics The **Modulino Buttons** module uses three tactile buttons and LEDs, which do not have native I²C capabilities. Instead, the buttons and LEDs are controlled by the Modulino's onboard microcontroller (STM32C011F4U6TR). This microcontroller provides I²C communication, allowing for flexible reading of button states and control of the LEDs. One unique feature of this setup is the ability to change the I²C address via software. This means the address can be modified based on your application needs, making it adaptable to different system configurations. @@ -105,85 +107,103 @@ The Modulino Buttons uses a simple circuit, as shown in the schematic below: ![Full Schematic Modulino Buttons](assets/schematic.png) The main components are the **three tactile buttons**, **three user-programmable LEDs** and the **STM32C011F4U6TR** microcontroller (U1), which handles button state reading, LED control, as well as I²C communication. + You can connect to the I²C pins (SDA and SCL) using either the **QWIIC connectors** (J1 and J2, this is the recommended method) or the **solderable pins** (J4). The board runs on **3.3V**, which comes from the QWIIC cable or the **3V3 pin** on J4. + There's also a small power LED indicator that lights up when the board is on. + You can grab the full schematic and PCB files from the [Modulino Buttons](https://docs.arduino.cc/hardware/modulinos/modulino-buttons) product page. ## How To Connect Your Modulino The easiest and most reliable way to connect your Modulino is through the QWIIC Connect System. It’s plug-and-play, uses standard I²C, and makes it easy to join multiple modules. If your board supports QWIIC, this is the recommended way to go. + Note that the dedicated I²C pins will differ from board to board meaning it is always a good idea to check your specific model. ![Modulino Wiring Options QWIIC(A - recommended) and Header(B)](assets/connection-guide-buttons.png) -## QWIIC Connector +### QWIIC Connector + Whenever available, the **QWIIC Connect System** is the preferred method. Connecting to the Modulino is extremely simple, just use a standard QWIIC cable to connect your board to either of the QWIIC connectors on the Modulino. Because the cable and connectors are polarized, there is no need to worry about accidentally swapping connections. QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connectors: + - GND - 3.3V - SDA (Data) - SCL (Clock) ![Connection Guide QWIIC](assets/connection-guide-buttons-qwiik.png) + The Modulino features two QWIIC connectors, which are internally connected in parallel. This means you can daisy-chain multiple modules easily by connecting additional QWIIC cables between them. -## Solderable Header +### Solderable Header + When QWIIC is not available, you can use the exposed solderable pins on the module. You can solder pins to the unpopulated pads; just remember the pinout provided in this guide to connect to the right pins of your board. ![Connection Guide Solder Pads](assets/connection-guide-buttons-jumper.png) -## Daisy-Chaining Multiple Modulinos +### Daisy-Chaining Multiple Modulinos Regardless of whether you connect the first Modulino via QWIIC or through the solderable pins, you can still take advantage of the extra QWIIC connector to daisy-chain additional modules. Each Modulino includes two QWIIC connectors wired in parallel, allowing you to connect one module to the next in a chain. As long as each module is configured with a unique I²C address, they can all communicate on the same bus. + This approach keeps your setup clean, modular, and expandable without adding extra wiring complexity. ![Modulino Wiring Options](assets/connection-guide-buttons-qwiic-chain.png) + ***The number of modules you can connect will depend on what modules you are chaining together, as this system allows for multiple sensors from different manufacturers to be added. Also, the cables you use for these connections will play a significant role in the setup’s performance. Ensure your cables are properly connected and capable of handling the required data transfer. Each module should have a unique address on a chain if you plan to address it independently. Later in this article we teach how to [change the address](#how-to-change-i2c-address). Multiple modules with the same address will cause conflicts on the I²C bus and will not allow you to address them individually.*** -# How To Program Your Modulino +## How To Program Your Modulino + +### Installing The Modulino Library -## Installing The Modulino Library To program your Modulino it is recommended you use the official ```Modulino``` micropython library available [here](https://github.com/arduino/arduino-modulino-mpy). The library is fully compatible with the no **Arduino Lab for MicroPython**. + For information on installing the **Arduino Lab for MicroPython** please visit our [page](https://docs.arduino.cc/micropython/first-steps/install-guide/). The ```Modulino``` library is not available by default on MicroPython devices hence installation is needed. + To simplify the process the [MicroPython Package Installer](https://github.com/arduino/lab-micropython-package-installer/releases) is recommended as it will provide a graphical interface to guide installation. + After installation, you should now be able to: 1. Open the tool. 2. Plug in your board to the computer. -![USB Connection](assets/mp-usb-connection.png) -If the board does not appear in the Detected Boards section, click Reload. If the board is still undetected, ensure no other programs (e.g., a code editor) are using the board's COM port. + ![USB Connection](assets/mp-usb-connection.png) -4. Search for the ```Modulino``` package by filling in the text box on the search feature. -5. Click Install and wait for the installation confirmation. -6. Disconnect the board from the tool before returning to your code editor to avoid conflicts due to a busy COM port. + If the board does not appear in the Detected Boards section, click Reload. If the board is still undetected, ensure no other programs (e.g., a code editor) are using the board's COM port. + +3. Search for the ```Modulino``` package by filling in the text box on the search feature. +4. Click Install and wait for the installation confirmation. +5. Disconnect the board from the tool before returning to your code editor to avoid conflicts due to a busy COM port. ![Package Installer Overview](assets/package-installer-overview.png) The module should now be includable in your program using: + ```from modulino import ModulinoThermo``` -# Getting Button Input and Controlling LEDs +### Getting Button Input and Controlling LEDs Interacting with buttons using the `Modulino` library is straightforward. For the **Modulino Buttons** module, there are key functions to detect button presses and control the LEDs associated with each button. -## Detecting Button Presses +### Detecting Button Presses Each button supports different interactions: + - **`.on_button_a_press`**, **`.on_button_b_press`**, **`.on_button_c_press`** Triggers when a button is pressed. - **`.on_button_a_long_press`**, **`.on_button_b_long_press`**, **`.on_button_c_long_press`** Triggers when a button is held down for a longer duration. - **`.on_button_a_release`**, **`.on_button_b_release`**, **`.on_button_c_release`** Triggers when a button is released. + By default the Modulino library uses ```Wire1``` if your board model has a different pinout for the dedicated I²C pins you might have to edit it as instructed [here](https://github.com/arduino/arduino-modulino-mpy/tree/main/docs#%E2%84%B9%EF%B8%8F-using-3rd-party-boards). More information on **Wire** can be found [here](https://docs.arduino.cc/language-reference/en/functions/communication/wire/). -## Reading Button Inputs And Controlling LEDs +### Reading Button Inputs And Controlling LEDs ```python from modulino import ModulinoButtons @@ -235,34 +255,42 @@ A sketch is also available included with the library named `AddressChanger` and To keep track of the address in use, the module has a white rectangle on the back. Feel free to use this to write the address that was chosen. When using a custom address in your MicroPython sketch, you'll need to specify this address when creating the module object. For example: + ```python buttons_module = ModulinoButtons(address=0x45) # Replace 0x45 with your specific address ``` -# Troubleshooting +## Troubleshooting + +### Buttons Not Responding -## Buttons Not Responding If your Modulino's power LED isn't on or the buttons aren't responsive, first check that the board is properly connected: + - Ensure both the board and the Modulino are connected to your computer, and that the power LEDs on both are lit. - If the issue persists, make sure the Qwiic cable is properly clicked into place. -## Library Not Installed Properly +### Library Not Installed Properly + If you encounter an issue with the `import ModulinoButtons` command, verify that the Modulino library is correctly installed: + - Check your library installer to ensure the library is installed and up-to-date. - Re-install the library through the Library Manager. -## LEDs Not Working +### LEDs Not Working + If the LEDs aren't lighting up as expected, make sure: + - The correct LED states are being set in your code (true for on, false for off). - All exposed electronics are not touching any conductive surfaces, as this could interfere with the operation. -# Conclusion +## Conclusion The **Modulino Buttons** is a digital input and output device that communicates over I²C and follows the Modulino form factor. It includes standard Qwiic connectors for quick, solderless connections and easy daisy-chaining with other modules. Paired with the Modulino library, it makes detecting button presses and controlling LEDs straightforward, allowing you to focus on experimenting or building your system logic. It's a small, reliable module suited for both user interfaces and interactive control systems. -# What Is Next? +## What Is Next? Now that you've learned how to use your Modulino Buttons, you're all set to integrate it into your projects! + - Create a simple menu system where each button performs a different function. - Build a game controller for a simple arcade-style game. - Use the buttons to control other Modulino devices in your project. diff --git a/content/hardware/11.accessories/modulino-nodes/modulino-buzzer/tutorials/how-buzzer-ardu/content.md b/content/hardware/11.accessories/modulino-nodes/modulino-buzzer/tutorials/how-buzzer-ardu/content.md index ec039cf6f4..af0ba7c3c3 100644 --- a/content/hardware/11.accessories/modulino-nodes/modulino-buzzer/tutorials/how-buzzer-ardu/content.md +++ b/content/hardware/11.accessories/modulino-nodes/modulino-buzzer/tutorials/how-buzzer-ardu/content.md @@ -12,7 +12,9 @@ software: - ide-v2 - web-editor --- + The Modulino Buzzer is a modular sensor that generates audio output, making it perfect to add sound feedback to your projects! + The Modulino form factor is shaped with two QWIIC connectors and the I²C protocol integration, allowing the connection and programming of multiple modulinos in a very simple way. In addition to the QWIIC's connectors, the Modulinos also expose solderable pins that can be used in multiple ways and make them compatible with boards that are not QWIIC compatible. @@ -25,7 +27,7 @@ The Modulino Buzzer based on the buzzer (PKLCS1212E4001-R1) is capable of genera | Frequency | - | - | 4,000 | - | Hz | | Sound Pressure Level | - | 75 | 85 | - | dB | -## Sensor Details +### Sensor Details The **Modulino Buzzer** module uses the **PKLCS1212E4001-R1** buzzer, which does not have native I²C capabilities. Instead, the buzzer is controlled by the Modulino's onboard microcontroller (STM32C011F4U6T). This microcontroller provides I²C communication, allowing for flexible control of the buzzer. @@ -39,6 +41,7 @@ The default I²C address for the **Modulino Buzzer** module is: When scanning for I²C address on the bus, you might find the modulino using the **Hardware I²C Address**. However, you should always use the **Modulino I²C Address** when using the official Modulino library. + Later in this article we teach how to [change the address](#how-to-change-i2c-address). @@ -73,6 +76,7 @@ The PKLCS1212E4001-R1 buzzer is the core component of this module. This audio ou ### 1x4 Header (I2C) + The pinout for the Modulino Buzzer is shown below. While the recommended connection method is via the QWIIC connectors, this solderable header provides a connection option when using the modulino with a non-QWIIC compatible board. | Pin | Function | @@ -110,7 +114,7 @@ There's also a small power LED indicator that lights up when the board is on. You can grab the full schematic and PCB files from the [Modulino Buzzer](https://docs.arduino.cc/hardware/modulinos/modulino-buzzer) product page. -# How To Connect Your Modulino +## How To Connect Your Modulino The easiest and most reliable way to connect your Modulino is through the QWIIC Connect System. It’s plug-and-play, uses standard I²C, and makes it easy to join multiple modules. If your board supports QWIIC, this is the recommended way to go. Note that the dedicated I²C pins will differ from board to board meaning it is always a good idea to check your specific model. @@ -118,7 +122,7 @@ If your board doesn’t have a QWIIC connector, you can still access the same I ![Modulino Wiring Options QWIIC(A - recommended) and Header(B)](assets/connection-guide-buzzer.png) -## QWIIC Connector +### QWIIC Connector Whenever available, the **QWIIC Connect System** is the preferred method. Connecting to the Modulino is extremely simple, just use a standard QWIIC cable to connect your board to either of the QWIIC connectors on the Modulino. Because the cable and connectors are polarized, there is no need to worry about accidentally swapping connections. @@ -132,12 +136,13 @@ QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connec The Modulino features two QWIIC connectors, which are internally connected in parallel. This means you can daisy-chain multiple modules easily by connecting additional QWIIC cables between them. -## Solderable Header +### Solderable Header + When QWIIC is not available, you can use the exposed solderable pins on the module. You can solder pins to the unpopulated pads; just remember the pinout provided in this guide to connect to the right pins of your board. ![Connection Guide Solder Pads](assets/connection-guide-buzzer-jumper.png) -## Daisy-Chaining Multiple Modulinos +### Daisy-Chaining Multiple Modulinos Regardless of whether you connect the first Modulino via QWIIC or through the solderable pins, you can still take advantage of the extra QWIIC connector to daisy-chain additional modules. @@ -146,23 +151,32 @@ Each Modulino includes two QWIIC connectors wired in parallel, allowing you to c This approach keeps your setup clean, modular, and expandable without adding extra wiring complexity. ![Modulino Wiring Options](assets/connection-guide-buzzer-qwiic-chain.png) + ***The number of modules you can connect will depend on what modules you are chaining together, as this system allows for multiple sensors from different manufacturers to be added. Also, the cables you use for these connections will play a significant role in the setup’s performance. Ensure your cables are properly connected and capable of handling the required data transfer. Each module should have a unique address on a chain if you plan to address them individually. Later in this article we teach how to [change the address](#how-to-change-i2c-address). Multiple modules with the same address will cause conflicts on the I²C bus and will not allow you to address them individually.*** -# How To Use Your Modulino -## Installing The Modulino Library +## How To Use Your Modulino + +### Installing The Modulino Library + You need the official Modulino library available [here](https://docs.arduino.cc/libraries/modulino/) to use the Modulino Buzzer. With the Arduino IDE you get some tools that make adding a library easier. To learn how to install the IDE please visit our [page](https://docs.arduino.cc/software/ide-v2/tutorials/getting-started/ide-v2-downloading-and-installing/). + After opening the IDE, a tab should be visible on the left. Press the book icon for "library" as highlighted in the image. + ![IDE Library Tab](assets/IDE-Left-Tab.png) + The process should look like this: + ![Library Install](assets/library-install.gif) + A message will appear after the installation is successful. -## Play A Simple Tune +### Play A Simple Tune Getting sound feedback from the buzzer is fairly simple using the ```Modulino``` library. For the **Modulino Buzzer** there is one important function: + - ```tone(frequency, duration)```: Generates a tone with the specified frequency (in Hz) and duration (in milliseconds). - ```Modulino.begin();```: By default the Modulino library uses ```Wire1``` if your connection is in a different Wire you will have to edit it, check [here](https://docs.arduino.cc/language-reference/en/functions/communication/wire/) (by default the Modulino library uses ```Wire1``` if your board model has a different pinout for the dedicated I²C pins you might have to edit it. More information on **Wire** can be found [here](https://docs.arduino.cc/language-reference/en/functions/communication/wire/)) for the library's hardware compatibility. More information on **Wire** can be found [here](https://docs.arduino.cc/language-reference/en/functions/communication/wire/). @@ -192,51 +206,62 @@ void loop(){ The code example provided shows how to initialize the buzzer and generate tones. The buzzer alternates between playing a 440 Hz tone for one second and staying silent for one second. It can be easily adapted to play different melodies or to provide sound feedback for your projects based on specific conditions or events. -## How To Change I2C Address +### How To Change I2C Address An example sketch, AddressChanger, is also included with the library inside the `Utilities` folder and available [here](https://github.com/arduino-libraries/Modulino/blob/main/examples/Utilities/AddressChanger/AddressChanger.ino). This sketch changes the I²C address at a software level on the Module's microcontroller. + ![Example location on the IDE](assets/addressChangeIDE.png) - Connect the module to your board, remove any other modules that might be in the chain. Connection must be via I²C. - Upload the sketch. - Open the Serial Monitor. - Text should now appear. Make sure the correct bauld-rate is selected if the displayed characters seem corrupted. + ![Expected console output](assets/adressChanger.png) + - Select the address and confirm. Valid I²C addresses range from 0x08 to 0x77 (7-bit values in hexadecimal format, e.g., 0x42). - Your address should now have changed. Make sure to take note of the selected address. To keep track of the address in use the module has a white rectangle on the back. Feel free to use this to write the address that was chosen. When using a custom address in your sketch, you'll need to specify this address when creating the module object. For example: + ```arduino ModulinoBuzzer buzzer(0x3E); // Replace 0x3E with your specific address ``` -# Troubleshooting +## Troubleshooting + +### Buzzer Not Sounding -## Buzzer Not Sounding If your Modulino's power LED isn't on or the buzzer isn't responsive, first check that the board is properly connected: + - Ensure both the board and the Modulino are connected to your computer, and that the power LEDs on both are lit. - If the issue persists, make sure the Qwiic cable is properly clicked into place. -## Library Not Installed Properly +### Library Not Installed Properly + If you encounter an issue with the `#include "modulino.h"` command, verify that the Modulino library is correctly installed: + - Check your IDE to ensure the library is installed and up-to-date. - Re-install the library through the Library Manager. -## Distorted Sound +### Distorted Sound + If the buzzer sound is distorted or not playing as expected, make sure: + - The correct frequency values are being used (typically between 20 Hz and 20 kHz for audible sounds). - All exposed electronics are not touching any conductive surfaces, as this could interfere with the sound output. -# Conclusion +## Conclusion The **Modulino Buzzer** is a digital sound output device that communicates over I²C and follows the Modulino form factor. It includes standard Qwiic connectors for quick, solderless connections and easy daisy-chaining with other modules. Paired with the Modulino library, it makes generating sound feedback straightforward, allowing you to focus on experimenting or building your system logic. It's a small, reliable module suited for both interactive feedback and audio alert systems. -# What Is Next? +## What Is Next? Now that you've learned how to use your Modulino Buzzer, you're all set to integrate it into your projects! + - Experiment with different frequencies to create various tones and melodies. - Try creating a simple alarm system that triggers the buzzer when certain conditions are met. - Use the buzzer to provide feedback in your interactive projects when a button is pressed or a threshold is reached. diff --git a/content/hardware/11.accessories/modulino-nodes/modulino-buzzer/tutorials/how-buzzer-mp/content.md b/content/hardware/11.accessories/modulino-nodes/modulino-buzzer/tutorials/how-buzzer-mp/content.md index 656167ddb3..e6eddd42a7 100644 --- a/content/hardware/11.accessories/modulino-nodes/modulino-buzzer/tutorials/how-buzzer-mp/content.md +++ b/content/hardware/11.accessories/modulino-nodes/modulino-buzzer/tutorials/how-buzzer-mp/content.md @@ -12,6 +12,7 @@ software: - ide-v2 - web-editor --- + The Modulino Buzzer is a modular sensor that generates audio output, making it perfect to add sound feedback to your projects! The Modulino form factor is shaped with two QWIIC connectors and the I²C protocol integration, allowing the connection and programming of multiple modulinos in a very simple way. In addition to the QWIIC's connectors, the Modulinos also expose solderable pins that can be used in multiple ways and make them compatible with boards that are not QWIIC compatible. @@ -25,7 +26,7 @@ The Modulino Buzzer based on the buzzer (PKLCS1212E4001-R1) is capable of genera | Frequency | - | - | 4,000 | - | Hz | | Sound Pressure Level | - | 75 | 85 | - | dB | -## Sensor Details +### Sensor Details The **Modulino Buzzer** module uses the **PKLCS1212E4001-R1** buzzer, which does not have native I²C capabilities. Instead, the buzzer is controlled by the Modulino's onboard microcontroller (STM32C011F4U6T). This microcontroller provides I²C communication, allowing for flexible control of the buzzer. @@ -39,6 +40,7 @@ The default I²C address for the **Modulino Buzzer** module is: When scanning for I²C address on the bus, you might find the modulino using the **Hardware I²C Address**. However, you should always use the **Modulino I²C Address** when using the official Modulino library. + Later in this article we teach how to [change the address](#how-to-change-i2c-address). @@ -71,6 +73,7 @@ The PKLCS1212E4001-R1 buzzer is the core component of this module. This audio ou ### 1x4 Header (I2C) + The pinout for the Modulino Buzzer is shown below. While the recommended connection method is via the QWIIC connectors, this solderable header provides a connection option when using the modulino with a non-QWIIC compatible board. | Pin | Function | @@ -91,7 +94,9 @@ The board is typically powered by +3.3 VDC when using the QWIIC interface as per | Current Consumption | - | ~6.4 | mA | The module additionally includes a power LED that draws 1 mA and turns on as soon as it is powered. + J1 (Qwiic connector), J2 (Qwiic connector), and the headers all share the same power branch. The power distribution of the module is therefore as follows: + ![Power Tree Modulino Buzzer](assets/Modulino_Buzzer_Power_Tree.png) ## Schematic @@ -108,7 +113,7 @@ There's also a small power LED indicator that lights up when the board is on. You can grab the full schematic and PCB files from the [Modulino Buzzer](https://docs.arduino.cc/hardware/modulinos/modulino-buzzer) product page. -# How To Connect Your Modulino +## How To Connect Your Modulino The easiest and most reliable way to connect your Modulino is through the QWIIC Connect System. It’s plug-and-play, uses standard I²C, and makes it easy to join multiple modules. If your board supports QWIIC, this is the recommended way to go. Note that the dedicated I²C pins will differ from board to board meaning it is always a good idea to check your specific model. @@ -116,11 +121,12 @@ If your board doesn’t have a QWIIC connector, you can still access the same I ![Modulino Wiring Options QWIIC(A - recommended) and Header(B)](assets/connection-guide-buzzer.png) -## QWIIC Connector +### QWIIC Connector Whenever available, the **QWIIC Connect System** is the preferred method. Connecting to the Modulino is extremely simple, just use a standard QWIIC cable to connect your board to either of the QWIIC connectors on the Modulino. Because the cable and connectors are polarized, there is no need to worry about accidentally swapping connections. QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connectors: + - GND - 3.3V - SDA (Data) @@ -130,12 +136,13 @@ QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connec The Modulino features two QWIIC connectors, which are internally connected in parallel. This means you can daisy-chain multiple modules easily by connecting additional QWIIC cables between them. -## Solderable Header +### Solderable Header + When QWIIC is not available, you can use the exposed solderable pins on the module. You can solder pins to the unpopulated pads; just remember the pinout provided in this guide to connect to the right pins of your board. ![Connection Guide Solder Pads](assets/connection-guide-buzzer-jumper.png) -## Daisy-Chaining Multiple Modulinos +### Daisy-Chaining Multiple Modulinos Regardless of whether you connect the first Modulino via QWIIC or through the solderable pins, you can still take advantage of the extra QWIIC connector to daisy-chain additional modules. @@ -144,36 +151,45 @@ Each Modulino includes two QWIIC connectors wired in parallel, allowing you to c This approach keeps your setup clean, modular, and expandable without adding extra wiring complexity. ![Modulino Wiring Options](assets/connection-guide-buzzer-qwiic-chain.png) + ***The number of modules you can connect will depend on what modules you are chaining together, as this system allows for multiple sensors from different manufacturers to be added. Also, the cables you use for these connections will play a significant role in the setup’s performance. Ensure your cables are properly connected and capable of handling the required data transfer. Each module should have a unique address on a chain if you plan to address them individually. Later in this article we teach how to [change the address](#how-to-change-i2c-address). Multiple modules with the same address will cause conflicts on the I²C bus and will not allow you to address them individually.*** -# How To Use Your Modulino +## How To Program Your Modulino + +### Installing The Modulino Library + To program your Modulino it is recommended you use the official ```Modulino``` micropython library available [here](https://github.com/arduino/arduino-modulino-mpy). The library is fully compatible with the no **Arduino Lab for MicroPython**. + For information on installing the **Arduino Lab for MicroPython** please visit our [page](https://docs.arduino.cc/micropython/first-steps/install-guide/). -## Installing The Modulino Library The ```Modulino``` library is not available by default on MicroPython devices hence installation is needed. + To simplify the process the [MicroPython Package Installer](https://github.com/arduino/lab-micropython-package-installer/releases) is recommended as it will provide a graphical interface to guide installation. + After installation, you should now be able to: 1. Open the tool. 2. Plug in your board to the computer. -![USB Connection](assets/mp-usb-connection.png) -If the board does not appear in the Detected Boards section, click Reload. If the board is still undetected, ensure no other programs (e.g., a code editor) are using the board's COM port. + ![USB Connection](assets/mp-usb-connection.png) + + If the board does not appear in the Detected Boards section, click Reload. If the board is still undetected, ensure no other programs (e.g., a code editor) are using the board's COM port. -4. Search for the ```Modulino``` package by filling in the text box on the search feature. -5. Click Install and wait for the installation confirmation. -6. Disconnect the board from the tool before returning to your code editor to avoid conflicts due to a busy COM port. +3. Search for the ```Modulino``` package by filling in the text box on the search feature. +4. Click Install and wait for the installation confirmation. +5. Disconnect the board from the tool before returning to your code editor to avoid conflicts due to a busy COM port. ![Package Installer Overview](assets/package-installer-overview.png) The module should now be includable in your program using: + ```from modulino import ModulinoBuzzer``` -## Play a Simple Tune with MicroPython +### Play a Simple Tune with MicroPython Playing a sound from the **Modulino Buzzer** module is easy using the `Modulino` library. The crucial function to generate a tone is: + - `tone(frequency, duration, blocking)` - Generates a tone with the specified frequency (in Hz) and duration (in milliseconds). - By default the Modulino library uses ```Wire1``` if your board model has a different pinout for the dedicated I²C pins you might have to edit it as instructed [here](https://github.com/arduino/arduino-modulino-mpy/tree/main/docs#%E2%84%B9%EF%B8%8F-using-3rd-party-boards). More information on **Wire** can be found [here](https://docs.arduino.cc/language-reference/en/functions/communication/wire/). @@ -197,7 +213,7 @@ buzzer.tone(0, duration, blocking=True) sleep(1) # Wait for 1 second ``` -## How To Change Address +### How To Change Address A sketch is also available included with the library named `AddressChanger` and also available [here](https://github.com/arduino/arduino-modulino-mpy/blob/main/examples/change_address.py). This sketch changes the I2C address at a software level on the Module's microcontroller. @@ -209,35 +225,43 @@ A sketch is also available included with the library named `AddressChanger` and To keep track of the address in use, the module has a white rectangle on the back. Feel free to use this to write the address that was chosen. When using a custom address in your MicroPython sketch, you'll need to specify this address when creating the module object. For example: + ```python buzzer_module = ModulinoBuzzer(address=0x45) # Replace 0x45 with your specific address ``` -# Troubleshooting +## Troubleshooting + +### Buzzer Not Sounding -## Buzzer Not Sounding If your Modulino's power LED isn't on or the buzzer isn't responsive, first check that the board is properly connected: + - Ensure both the board and the Modulino are connected to your computer, and that the power LEDs on both are lit. - If the issue persists, make sure the Qwiic cable is properly clicked into place. -## Library Not Installed Properly +### Library Not Installed Properly + If you encounter an issue with the `from modulino import ModulinoBuzzer"` command, verify that the Modulino library is correctly installed: + - Check if the library is installed and up-to-date. - Re-install the library through the Library Manager. -## Distorted Sound +### Distorted Sound + If the buzzer sound is distorted or not playing as expected, make sure: + - The correct frequency values are being used (typically between 20 Hz and 20 kHz for audible sounds). - All exposed electronics are not touching any conductive surfaces, as this could interfere with the sound output. -# Conclusion +## Conclusion The **Modulino Buzzer** is a digital sound output device that communicates over I²C and follows the Modulino form factor. It includes standard Qwiic connectors for quick, solderless connections and easy daisy-chaining with other modules. Paired with the Modulino library, it makes generating sound feedback straightforward, allowing you to focus on experimenting or building your system logic. It's a small, reliable module suited for both interactive feedback and audio alert systems. -# What Is Next? +## What Is Next? Now that you've learned how to use your Modulino Buzzer, you're all set to integrate it into your projects! + - Experiment with different frequencies to create various tones and melodies. - Try creating a simple alarm system that triggers the buzzer when certain conditions are met. - Use the buzzer to provide feedback in your interactive projects when a button is pressed or a threshold is reached. diff --git a/content/hardware/11.accessories/modulino-nodes/modulino-distance/tutorials/how-distance-ardu/content.md b/content/hardware/11.accessories/modulino-nodes/modulino-distance/tutorials/how-distance-ardu/content.md index adab7eba6b..ac2163cd15 100644 --- a/content/hardware/11.accessories/modulino-nodes/modulino-distance/tutorials/how-distance-ardu/content.md +++ b/content/hardware/11.accessories/modulino-nodes/modulino-distance/tutorials/how-distance-ardu/content.md @@ -12,10 +12,12 @@ software: - ide-v2 - web-editor --- + The Modulino Distance is a modular sensor that measures distance using Time-of-Flight (ToF) technology, making it perfect to add precise distance sensing and depth mapping to your projects! + The Modulino form factor is shaped with two QWIIC connectors and the I²C protocol integration, allowing the connection and programming of multiple modulinos in a very simple way. In addition to the QWIIC's connectors, the Modulinos also expose solderable pins that can be used in multiple ways and make them compatible with boards that are not QWIIC compatible. -# General Characteristics +## General Characteristics The Modulino Distance is capable of measuring distances using Time-of-Flight technology. Take a look at the following table to know more about its measuring ranges: @@ -26,7 +28,7 @@ The Modulino Distance is capable of measuring distances using Time-of-Flight tec | Operating Temperature | - | -30 | - | 85 | °C | -## Sensor Details +### Sensor Details The VL53L4CDV0DH/1 sensor from STMicroelectronics is the core component of this module. This ToF sensor natively supports digital communication (I²C), meaning it connects directly to the I²C bus on the module without requiring additional conversion circuitry. @@ -64,6 +66,7 @@ The pinout for the Modulino Distance is shown below. Please note that the expose - **XSHUT: Xshutdown** – Shutdown control pin for the sensor. ### 1x4 Header (I2C) + The pinout for the Modulino Buzzer is shown below. While the recommended connection method is via the QWIIC connectors, this solderable header provides a connection option when using the modulino with a non-QWIIC compatible board. | Pin | Function | @@ -106,16 +109,18 @@ You can grab the full schematic and PCB files from the [Modulino Distance](https ## How To Connect Your Modulino The easiest and most reliable way to connect your Modulino is through the QWIIC Connect System. It’s plug-and-play, uses standard I²C, and makes it easy to join multiple modules. If your board supports QWIIC, this is the recommended way to go. + Note that the dedicated I²C pins will differ from board to board meaning it is always a good idea to check your specific model. ![Modulino Wiring Options QWIIC(A - recommended) and Header(B)](assets/connection-guide-distance.png) -## QWIIC Connector +### QWIIC Connector Whenever available, the **QWIIC Connect System** is the preferred method. Connecting to the Modulino is extremely simple, just use a standard QWIIC cable to connect your board to either of the QWIIC connectors on the Modulino. Because the cable and connectors are polarized, there is no need to worry about accidentally swapping connections. QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connectors: + - GND - 3.3 V - SDA (Data) @@ -125,37 +130,43 @@ QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connec The Modulino features two QWIIC connectors, which are internally connected in parallel. This means you can daisy-chain multiple modules easily by connecting additional QWIIC cables between them. -## Solderable Header +### Solderable Header When QWIIC is not available, you can use the exposed solderable pins on the module. You can solder pins to the unpopulated pads; just remember the pinout provided in this guide to connect to the right pins of your board. ![Connection Guide Solder Pads](assets/connection-guide-distance-jumper.png) -## Daisy-Chaining Multiple Modulinos +### Daisy-Chaining Multiple Modulinos Regardless of whether you connect the first Modulino via QWIIC or through the solderable pins, you can still take advantage of the extra QWIIC connector to daisy-chain additional modules. Each Modulino includes two QWIIC connectors wired in parallel, allowing you to connect one module to the next in a chain. As long as each module is configured with a unique I²C address, they can all communicate on the same bus. This approach keeps your setup clean, modular, and expandable without adding extra wiring complexity. ![Modulino Wiring Options](assets/connection-guide-distance-qwiic-chain.png) ***The number of modules you can connect will depend on what modules you are chaining together, as this system allows for multiple sensors from different manufacturers to be added. Also, the cables you use for these connections will play a significant role in the setup's performance. Ensure your cables are correctly connected and capable of handling the required data transfer. - Each module should have a unique address on a chain if you plan to address them individually. Multiple modules with the same address will cause conflicts on the I²C bus.*** -# How To Use Your Modulino +## How To Use Your Modulino + +### Installing The Modulino Library -## Installing The Modulino Library You need the official Modulino library available [here](https://docs.arduino.cc/libraries/modulino/) to use the Modulino Thermo. With the Arduino IDE you get some tools that make adding a library easier. To learn how to install the IDE please visit our [page](https://docs.arduino.cc/software/ide-v2/tutorials/getting-started/ide-v2-downloading-and-installing/). + After opening the IDE, a tab should be visible on the left. Press the book icon for "library" as highlighted in the image. + ![IDE Library Tab](assets/IDE-Left-Tab.png) + The process should look like this: + ![Library Install](assets/library-install.gif) + A message will appear after the installation is successful. -## Getting Distance Data +### Getting Distance Data Getting data from the sensor is fairly simple using the ```Modulino``` library. For the **Modulino Distance** there are two important functions: + - ```available()```: Checks if new distance data is available. - ```get()```: Retrieves the measured distance from the sensor (default in cm). - ```Modulino.begin();```: By default the Modulino library uses ```Wire1``` if your connection is in a different Wire you will have to edit it, check [here](https://docs.arduino.cc/language-reference/en/functions/communication/wire/) (by default the Modulino library uses ```Wire1``` if your board model has a different pinout for the dedicated I²C pins you might have to edit it. More information on **Wire** can be found [here](https://docs.arduino.cc/language-reference/en/functions/communication/wire/)) for the library's hardware compatibility. More information on **Wire** can be found [here](https://docs.arduino.cc/language-reference/en/functions/communication/wire/). @@ -188,28 +199,35 @@ void loop() { ## Troubleshooting ### Sensor Not Reachable + If your Modulino's power LED isn't on or the sensor isn't responsive, first check that the board is properly connected: + - Ensure both the board and the Modulino are connected to your computer, and that the power LEDs on both are lit. - If the issue persists, make sure the Qwiic cable is properly clicked into place. ### Library Not Installed Properly + If you encounter an issue with the `#include "modulino.h"` command, verify that the Modulino library is correctly installed: + - Check your IDE to ensure the library is installed and up-to-date. - Re-install the library through the Library Manager. ### Inaccurate Values + If the sensor values are not accurate, make sure: + - The sensor lens is clean and free from dust or obstructions. - All exposed electronics are not touching any conductive surfaces, as this could interfere with readings. - The object being measured is within the sensor's detection range. -# What Is Next? +## Conclusion + +The **Modulino Distance** is a digital Time-of-Flight distance sensor that communicates over I²C and follows the Modulino form factor. It includes standard Qwiic connectors for quick, solderless connections and easy daisy-chaining with other modules. Paired with the Modulino library, it makes accessing distance data straightforward, allowing you to focus on experimenting or building your system logic. It's a small, reliable module suited for both quick tests and longer-term setups. + +## What Is Next? Now that you've learned how to use your Modulino Distance, you're all set to integrate it into your projects! + - Create a parking assistance system that provides audio feedback as objects get closer, similar to car parking sensors. - Build a theremin-like musical instrument that changes pitch or volume based on hand movements in front of the sensor. -- Design an automatic dispenser that activates when hands are detected beneath it (for soap, sanitizer, etc.). - -# Conclusion - -The **Modulino Distance** is a digital Time-of-Flight distance sensor that communicates over I²C and follows the Modulino form factor. It includes standard Qwiic connectors for quick, solderless connections and easy daisy-chaining with other modules. Paired with the Modulino library, it makes accessing distance data straightforward, allowing you to focus on experimenting or building your system logic. It's a small, reliable module suited for both quick tests and longer-term setups. \ No newline at end of file +- Design an automatic dispenser that activates when hands are detected beneath it (for soap, sanitizer, etc.). \ No newline at end of file diff --git a/content/hardware/11.accessories/modulino-nodes/modulino-distance/tutorials/how-distance-mp/content.md b/content/hardware/11.accessories/modulino-nodes/modulino-distance/tutorials/how-distance-mp/content.md index bb3340b029..4165f7478d 100644 --- a/content/hardware/11.accessories/modulino-nodes/modulino-distance/tutorials/how-distance-mp/content.md +++ b/content/hardware/11.accessories/modulino-nodes/modulino-distance/tutorials/how-distance-mp/content.md @@ -12,10 +12,11 @@ software: - ide-v2 - web-editor --- + The Modulino Distance is a modular sensor that measures distance using Time-of-Flight (ToF) technology, making it perfect to add precise distance sensing and depth mapping to your projects! The Modulino form factor is shaped with two QWIIC connectors and the I²C protocol integration, allowing the connection and programming of multiple modulinos in a very simple way. In addition to the QWIIC's connectors, the Modulinos also expose solderable pins that can be used in multiple ways and make them compatible with boards that are not QWIIC compatible. -# General Characteristics +## General Characteristics The Modulino Distance is capable of measuring distances using Time-of-Flight technology. Take a look at the following table to know more about its measuring ranges: @@ -26,7 +27,7 @@ The Modulino Distance is capable of measuring distances using Time-of-Flight tec | Operating Temperature | - | -30 | - | 85 | °C | -## Sensor Details +### Sensor Details The VL53L4CDV0DH/1 sensor from STMicroelectronics is the core component of this module. This ToF sensor natively supports digital communication (I²C), meaning it connects directly to the I²C bus on the module without requiring additional conversion circuitry. @@ -65,6 +66,7 @@ The pinout for the Modulino Distance is shown below. Please note that the expose ### 1x4 Header (I2C) + The pinout for the Modulino Buzzer is shown below. While the recommended connection method is via the QWIIC connectors, this solderable header provides a connection option when using the modulino with a non-QWIIC compatible board. | Pin | Function | @@ -107,15 +109,17 @@ You can grab the full schematic and PCB files from the [Modulino Distance](https ## How To Connect Your Modulino The easiest and most reliable way to connect your Modulino is through the QWIIC Connect System. It’s plug-and-play, uses standard I²C, and makes it easy to join multiple modules. If your board supports QWIIC, this is the recommended way to go. + Note that the dedicated I²C pins will differ from board to board meaning it is always a good idea to check your specific model. ![Modulino Wiring Options QWIIC(A - recommended) and Header(B)](assets/connection-guide-distance.png) -## QWIIC Connector +### QWIIC Connector Whenever available, the **QWIIC Connect System** is the preferred method. Connecting to the Modulino is extremely simple, just use a standard QWIIC cable to connect your board to either of the QWIIC connectors on the Modulino. Because the cable and connectors are polarized, there is no need to worry about accidentally swapping connections. QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connectors: + - GND - 3.3V - SDA (Data) @@ -125,52 +129,60 @@ QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connec The Modulino features two QWIIC connectors, which are internally connected in parallel. This means you can daisy-chain multiple modules easily by connecting additional QWIIC cables between them. -## Solderable Header +### Solderable Header When QWIIC is not available, you can use the exposed solderable pins on the module. You can solder pins to the unpopulated pads; just remember the pinout provided in this guide to connect to the right pins of your board. ![Connection Guide Solder Pads](assets/connection-guide-distance-jumper.png) -## Daisy-Chaining Multiple Modulinos +### Daisy-Chaining Multiple Modulinos Regardless of whether you connect the first Modulino via QWIIC or through the solderable pins, you can still take advantage of the extra QWIIC connector to daisy-chain additional modules. Each Modulino includes two QWIIC connectors wired in parallel, allowing you to connect one module to the next in a chain. As long as each module is configured with a unique I²C address, they can all communicate on the same bus. This approach keeps your setup clean, modular, and expandable without adding extra wiring complexity. ![Modulino Wiring Options](assets/connection-guide-distance-qwiic-chain.png) ***The number of modules you can connect will depend on what modules you are chaining together, as this system allows for multiple sensors from different manufacturers to be added. Also, the cables you use for these connections will play a significant role in the setup's performance. Ensure your cables are correctly connected and capable of handling the required data transfer. - Each module should have a unique address on a chain if you plan to address them individually. Multiple modules with the same address will cause conflicts on the I²C bus.*** -# How To Program Your Modulino -## Installing The Modulino Library +## How To Program Your Modulino + +### Installing The Modulino Library + To program your Modulino it is recommended you use the official ```Modulino``` micropython library available [here](https://github.com/arduino/arduino-modulino-mpy). The library is fully compatible with the no **Arduino Lab for MicroPython**. + For information on installing the **Arduino Lab for MicroPython** please visit our [page](https://docs.arduino.cc/micropython/first-steps/install-guide/). The ```Modulino``` library is not available by default on MicroPython devices hence installation is needed. + To simplify the process the [MicroPython Package Installer](https://github.com/arduino/lab-micropython-package-installer/releases) is recommended as it will provide a graphical interface to guide installation. + After installation, you should now be able to: 1. Open the tool. 2. Plug in your board to the computer. -![USB Connection](assets/mp-usb-connection.png) -If the board does not appear in the Detected Boards section, click Reload. If the board is still undetected, ensure no other programs (e.g., a code editor) are using the board's COM port. + ![USB Connection](assets/mp-usb-connection.png) + + If the board does not appear in the Detected Boards section, click Reload. If the board is still undetected, ensure no other programs (e.g., a code editor) are using the board's COM port. -4. Search for the ```Modulino``` package by filling in the text box on the search feature. -5. Click Install and wait for the installation confirmation. -6. Disconnect the board from the tool before returning to your code editor to avoid conflicts due to a busy COM port. +3. Search for the ```Modulino``` package by filling in the text box on the search feature. +4. Click Install and wait for the installation confirmation. +5. Disconnect the board from the tool before returning to your code editor to avoid conflicts due to a busy COM port. ![Package Installer Overview](assets/package-installer-overview.png) The module should now be includable in your program using: + ```from modulino import ModulinoDistance``` -# Getting Distance Data +### Getting Distance Data Getting data from the sensor is straightforward using the ```Modulino``` library. For the **Modulino Distance**, there is one crucial function: + - ```.distance``` - Provides the distance measurement from the sensor. (Default in cm) - By default the Modulino library uses ```Wire1``` if your board model has a different pinout for the dedicated I²C pins you might have to edit it as instructed [here](https://github.com/arduino/arduino-modulino-mpy/tree/main/docs#%E2%84%B9%EF%B8%8F-using-3rd-party-boards). More information on **Wire** can be found [here](https://docs.arduino.cc/language-reference/en/functions/communication/wire/). + Here is an example of how to implement this function to acquire data: ```python @@ -189,28 +201,36 @@ This simple code creates an instance of the ModulinoDistance class and continuou ## Troubleshooting ### Sensor Not Reachable + If your Modulino's power LED isn't on or the sensor isn't responsive, first check that the board is properly connected: + - Ensure both the board and the Modulino are connected to your computer, and that the power LEDs on both are lit. - If the issue persists, make sure the Qwiic cable is properly clicked into place. ### Library Not Installed Properly + If you encounter an issue with the `import ModulinoDistance` command, verify that the Modulino library is correctly installed: + - Check the package installer to ensure the library is installed and up-to-date. - Re-install the library through the Library Manager. ### Inaccurate Values + If the sensor values are not accurate, make sure: + - The sensor lens is clean and free from dust or obstructions. - All exposed electronics are not touching any conductive surfaces, as this could interfere with readings. - The object being measured is within the sensor's detection range. -# What Is Next? +## Conclusion + +The **Modulino Distance** is a digital Time-of-Flight distance sensor that communicates over I²C and follows the Modulino form factor. It includes standard Qwiic connectors for quick, solderless connections and easy daisy-chaining with other modules. Paired with the Modulino library, it makes accessing distance data straightforward, allowing you to focus on experimenting or building your system logic. It's a small, reliable module suited for both quick tests and longer-term setups. + +## What Is Next? Now that you've learned how to use your Modulino Distance, you're all set to integrate it into your projects! + - Create a parking assistance system that provides audio feedback as objects get closer, similar to car parking sensors. - Build a theremin-like musical instrument that changes pitch or volume based on hand movements in front of the sensor. - Design an automatic dispenser that activates when hands are detected beneath it (for soap, sanitizer, etc.). -# Conclusion - -The **Modulino Distance** is a digital Time-of-Flight distance sensor that communicates over I²C and follows the Modulino form factor. It includes standard Qwiic connectors for quick, solderless connections and easy daisy-chaining with other modules. Paired with the Modulino library, it makes accessing distance data straightforward, allowing you to focus on experimenting or building your system logic. It's a small, reliable module suited for both quick tests and longer-term setups. \ No newline at end of file diff --git a/content/hardware/11.accessories/modulino-nodes/modulino-knob/tutorials/how-knob-ardu/content.md b/content/hardware/11.accessories/modulino-nodes/modulino-knob/tutorials/how-knob-ardu/content.md index f0fa1915d7..3a68f4075a 100644 --- a/content/hardware/11.accessories/modulino-nodes/modulino-knob/tutorials/how-knob-ardu/content.md +++ b/content/hardware/11.accessories/modulino-nodes/modulino-knob/tutorials/how-knob-ardu/content.md @@ -12,7 +12,9 @@ software: - ide-v2 - web-editor --- + The Modulino Knob is a modular sensor based on a quadrature rotary encoder that translates angular motion (rotation) into a digital signal. The sensor value will increase or decrease according to the rotation direction. Also, it includes an SPST switch that is activated when the knob is pressed. + It uses the Modulino form factor, streamlining integration through the I2C protocol. It provides QWIIC connectors and exposed solderable pins (for boards without a QWIIC interface). ## General Characteristics @@ -26,9 +28,10 @@ The Modulino Knob has the following measurement specifications: | Steps | - | - | 30 | - | - | | Resolution | - | - | 12 | - | bit | -## Sensor Details +### Sensor Details The PEC11J-9215F-S0015 rotary encoder is the core component of this module. This sensor output is processed by an STM32C011F4 microcontroller for digital communication (I2C), meaning that the encoder is communicated through the I2C pins using the mentioned microcontroller as an intermediary. + The default address for the Module is: | **Modulino I2C Address** | **Hardware I2C Address** | @@ -36,6 +39,7 @@ The default address for the Module is: | 0x76 | 0x3A | When scanning for I²C address on the bus, you might find the modulino using the **Hardware I²C Address**. However, you should always use the **Modulino I²C Address** when using the official Modulino library. + Later in this article we teach how to [change the address](#how-to-change-i2c-address). @@ -94,6 +98,7 @@ The board must be powered **only** by +3.3 VDC when using the solderable pins or | Average Current | 3.4 | mA | The module additionally includes a power LED that draws 1 mA and turns on as soon as it is powered. J1 (Qwiic connector), J2 (Qwiic connector), and the headers all share the same power branch. The power distribution of the module is therefore as follows: + ![Power Tree Modulino Knob](assets/Modulino_Knob_Power_Tree.png) ## Schematic @@ -103,7 +108,9 @@ The Modulino Knob uses a simple circuit, as shown in the schematic below: ![Full Schematic Modulino Knob](assets/schematic.png) The main components are the **rotary encoder with integrated pushbutton** (PECHL-9215E-S0015) and the **STM32C011F4U6TR** microcontroller (U1), which handles encoder position reading, button state detection, as well as I²C communication. + You can connect to the I²C pins (SDA and SCL) using either the **QWIIC connectors** (J1 and J2, this is the recommended method) or the **solderable pins** (J3). The board runs on **3.3V**, which comes from the QWIIC cable or the **3V3 pin** on J3. + There's also a small power LED indicator (green) that lights up when the board is on. You can grab the full schematic and PCB files from the [Modulino Knob](https://docs.arduino.cc/hardware/modulinos/modulino-knob) product page. @@ -119,6 +126,7 @@ The easiest and most reliable way to connect your Modulino is through the QWIIC Whenever available, the **QWIIC Connect System** is the preferred method. Connecting to the Modulino is extremely simple, just use a standard QWIIC cable to connect your board to either of the QWIIC connectors on the Modulino. Because the cable and connectors are polarized, there is no need to worry about accidentally swapping connections. QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connectors: + - GND - 3.3V - SDA (Data) @@ -141,23 +149,28 @@ Regardless of whether you connect the first Modulino via QWIIC or through the so ![Modulino Wiring Options](assets/connection-guide-knob-qwiic-chain.png) ***The number of modules you can connect will depend on what modules you are chaining together, as this system allows for multiple sensors from different manufacturers to be added. Also, the cables you use for these connections will play a significant role in the setup's performance. Ensure your cables are properly connected and capable of handling the required data transfer. - Each module should have a unique address on a chain if you plan to address them individually. Later in this article we teach how to [change the address](#how-to-change-i2c-address). Multiple modules with the same address will cause conflicts on the I²C bus and will not allow you to address them individually.*** -## How To Program Your Modulino +## How To Use Your Modulino ### Installing The Modulino Library You need the official Modulino library available [here](https://github.com/arduino-libraries/Modulino) to use the Modulino Knob. + With the Arduino IDE, you get some tools that make adding a library easier. To learn how to install the IDE, please visit our [page](https://docs.arduino.cc/micropython/first-steps/install-guide/). + After opening the IDE, a tab should be visible on the left. Press the book icon for "library" as highlighted in the image. + ![IDE Library Tab](assets/library-menu.png) You can now search for the library `Modulino` by filling in the `Filter your search` text box. A prompt might appear saying that additional dependencies are required. This is not a problem, as they will be automatically added when you confirm the prompt. + ![Add Dependencies Prompt](assets/library-dependencies.png) The libraries should now start to install. A message will appear after the installation is successful. + The process should be like this: + ![Library Install](assets/library-install.gif) ### Getting Knob Data @@ -203,19 +216,23 @@ void loop(){ ### How To Change I2C Address An example sketch, AddressChanger, is also included with the library inside the `Utilities` folder and available [here](https://github.com/arduino-libraries/Modulino/blob/main/examples/Utilities/AddressChanger/AddressChanger.ino). This sketch changes the I²C address at a software level on the Module's microcontroller. + ![Example location on the IDE](assets/AdressChangeIDE.png) - Connect the module to your board, remove any other modules that might be in the chain. Connection must be via I²C. - Upload the sketch. - Open the Serial Monitor. - Text should now appear. Make sure the correct bauld-rate is selected if the displayed characters seem corrupted. + ![Expected console output](assets/adressChanger.png) + - Select the address and confirm. Valid I²C addresses range from 0x08 to 0x77 (7-bit values in hexadecimal format, e.g., 0x42). - Your address should now have changed. Make sure to take note of the selected address. To keep track of the address in use the module has a white rectangle on the back. Feel free to use this to write the address that was chosen. When using a custom address in your sketch, you'll need to specify this address when creating the module object. For example: + ```arduino ModulinoKnob knob(0x3E); // Replace 0x3E with your specific address ``` @@ -227,9 +244,10 @@ The **Modulino Knob** provides a simple solution for UI interface, volume contro By leveraging the **Modulino library**, users can quickly access sensor data and implement functionalities such as **user interface control and angle measurement tool**. With just a few lines of code, you can start **controlling your projects**, making it easier than ever to bring intelligent sensing to your applications. -## What Next? +## What Is Next? After mastering the basics of the Modulino Knob, try these project ideas: + - Calculate what is the encoder rotation angle per step to convert the arbitrary output into a rotation angle output. - Control the Arduino onboard LED with the press of the knob button. - Use the Modulino Knob to control the navigation on a UI display on an LCD or OLED screen. \ No newline at end of file diff --git a/content/hardware/11.accessories/modulino-nodes/modulino-knob/tutorials/how-knob-mp/content.md b/content/hardware/11.accessories/modulino-nodes/modulino-knob/tutorials/how-knob-mp/content.md index 1097e91d48..37ed7d8940 100644 --- a/content/hardware/11.accessories/modulino-nodes/modulino-knob/tutorials/how-knob-mp/content.md +++ b/content/hardware/11.accessories/modulino-nodes/modulino-knob/tutorials/how-knob-mp/content.md @@ -12,7 +12,9 @@ software: - ide-v2 - web-editor --- + The Modulino Knob is a modular sensor based on a quadrature rotary encoder that translates angular motion (rotation) into a digital signal. The sensor value will increase or decrease according to the rotation direction. Also, it includes an SPST switch that is activated when the knob is pressed. + It uses the Modulino form factor, streamlining integration through the I2C protocol. It provides QWIIC connectors and exposed solderable pins (for boards without a QWIIC interface). ## General Characteristics @@ -26,9 +28,10 @@ The Modulino Knob has the following measurement specifications: | Steps | - | - | 30 | - | - | | Resolution | - | - | 12 | - | bit | -## Sensor Details +### Sensor Details The PEC11J-9215F-S0015 rotary encoder is the core component of this module. This sensor output is processed by an STM32C011F4 microcontroller for digital communication (I2C), meaning that the encoder is communicated through the I2C pins using the mentioned microcontroller as an intermediary. + The default address for the Module is: | **Modulino I2C Address** | **Hardware I2C Address** | @@ -36,6 +39,7 @@ The default address for the Module is: | 0x76 | 0x3A | When scanning for I²C address on the bus, you might find the modulino using the **Hardware I²C Address**. However, you should always use the **Modulino I²C Address** when using the official Modulino library. + Later in this article we teach how to [change the address](#how-to-change-i2c-address). @@ -94,6 +98,7 @@ The board must be powered **only** by +3.3 VDC when using the solderable pins or | Average Current | 3.4 | mA | The module additionally includes a power LED that draws 1 mA and turns on as soon as it is powered. J1 (Qwiic connector), J2 (Qwiic connector), and the headers all share the same power branch. The power distribution of the module is therefore as follows: + ![Power Tree Modulino Knob](assets/Modulino_Knob_Power_Tree.png) ## Schematic @@ -103,7 +108,9 @@ The Modulino Knob uses a simple circuit, as shown in the schematic below: ![Full Schematic Modulino Knob](assets/schematic.png) The main components are the **rotary encoder with integrated pushbutton** (PECHL-9215E-S0015) and the **STM32C011F4U6TR** microcontroller (U1), which handles encoder position reading, button state detection, as well as I²C communication. + You can connect to the I²C pins (SDA and SCL) using either the **QWIIC connectors** (J1 and J2, this is the recommended method) or the **solderable pins** (J3). The board runs on **3.3V**, which comes from the QWIIC cable or the **3V3 pin** on J3. + There's also a small power LED indicator (green) that lights up when the board is on. You can grab the full schematic and PCB files from the [Modulino Knob](https://docs.arduino.cc/hardware/modulinos/modulino-knob) product page. @@ -119,6 +126,7 @@ The easiest and most reliable way to connect your Modulino is through the QWIIC Whenever available, the **QWIIC Connect System** is the preferred method. Connecting to the Modulino is extremely simple, just use a standard QWIIC cable to connect your board to either of the QWIIC connectors on the Modulino. Because the cable and connectors are polarized, there is no need to worry about accidentally swapping connections. QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connectors: + - GND - 3.3V - SDA (Data) @@ -141,10 +149,9 @@ Regardless of whether you connect the first Modulino via QWIIC or through the so ![Modulino Wiring Options](assets/connection-guide-knob-qwiic-chain.png) ***The number of modules you can connect will depend on what modules you are chaining together, as this system allows for multiple sensors from different manufacturers to be added. Also, the cables you use for these connections will play a significant role in the setup's performance. Ensure your cables are properly connected and capable of handling the required data transfer. - Each module should have a unique address on a chain if you plan to address them individually. Later in this article we teach how to [change the address](#how-to-change-i2c-address). Multiple modules with the same address will cause conflicts on the I²C bus and will not allow you to address them individually.*** -## How To Use Your Modulino +## How To Program Your Modulino ### Installing The Modulino Library @@ -160,17 +167,19 @@ After installation, you should now be able to: 1. Open the tool. 2. Plug in your board to the computer. -![USB Connection](assets/mp-usb-connection.png) -If the board does not appear in the Detected Boards section, click Reload. If the board is still undetected, ensure no other programs (e.g., a code editor) are using the board's COM port. + ![USB Connection](assets/mp-usb-connection.png) + + If the board does not appear in the Detected Boards section, click Reload. If the board is still undetected, ensure no other programs (e.g., a code editor) are using the board's COM port. -1. Search for the `Modulino` package by filling in the text box on the search feature. -2. Click Install and wait for the installation confirmation. -3. Disconnect the board from the tool before returning to your code editor to avoid conflicts due to a busy COM port. +3. Search for the `Modulino` package by filling in the text box on the search feature. +4. Click Install and wait for the installation confirmation. +5. Disconnect the board from the tool before returning to your code editor to avoid conflicts due to a busy COM port. ![Package Installer Overview](assets/package-installer-overview.png) The module should now be includable in your program using: + ```python from modulino import ModulinoThermo ``` @@ -234,6 +243,7 @@ A sketch is also available included with the library named `AddressChanger` and To keep track of the address in use, the module has a white rectangle on the back. Feel free to use this to write the address that was chosen. When using a custom address in your MicroPython sketch, you'll need to specify this address when creating the module object. For example: + ```python knob_module = ModulinoKnob(address=0x45) # Replace 0x45 with your specific address ``` @@ -244,9 +254,10 @@ The **Modulino Knob** provides a simple solution for UI interface, volume contro By leveraging the **Modulino package**, users can quickly access sensor data and implement functionalities such as **user interface control and angle measurement tool**. With just a few lines of code, you can start **controlling your projects**, making it easier than ever to bring intelligent sensing to your applications. -## What Next? +## What Is Next? After mastering the basics of the Modulino Knob, try these project ideas: + - Calculate what is the encoder rotation angle per step to convert the arbitrary output into a rotation angle output. - Control the Arduino onboard LED with the press of the knob button. - Use the Modulino Knob to control the navigation on a UI display on an LCD or OLED screen. \ No newline at end of file diff --git a/content/hardware/11.accessories/modulino-nodes/modulino-movement/tutorials/how-movement-ardu/content.md b/content/hardware/11.accessories/modulino-nodes/modulino-movement/tutorials/how-movement-ardu/content.md index 65b735ce5f..28445ee87d 100644 --- a/content/hardware/11.accessories/modulino-nodes/modulino-movement/tutorials/how-movement-ardu/content.md +++ b/content/hardware/11.accessories/modulino-nodes/modulino-movement/tutorials/how-movement-ardu/content.md @@ -13,7 +13,9 @@ software: - web-editor --- -The Modulino Movement is a modular sensor that measures acceleration and angular velocity, making it perfect to add motion sensing to your projects! The Modulino form factor is shaped with two QWIIC connectors and the I²C protocol integration, allowing the connection and programming of multiple modulinos in a very simple way. In addition to the QWIIC's connectors, the Modulinos also expose solderable pins that can be used in multiple ways and make them compatible with boards that are not QWIIC compatible. +The Modulino Movement is a modular sensor that measures acceleration and angular velocity, making it perfect to add motion sensing to your projects! + +The Modulino form factor is shaped with two QWIIC connectors and the I²C protocol integration, allowing the connection and programming of multiple modulinos in a very simple way. In addition to the QWIIC's connectors, the Modulinos also expose solderable pins that can be used in multiple ways and make them compatible with boards that are not QWIIC compatible. ## General Characteristics @@ -31,7 +33,7 @@ The Modulino Movement is capable of measuring acceleration and angular velocity. | **FIFO Buffer** | - | - | 9 | - | KB | | **Sampling Rate** | Output Data Rate | 1.6 | - | 6664 | Hz | -## Sensor Details +### Sensor Details The LSM6DSOXTR sensor from STMicroelectronics is the core component of this module. This 6-axis IMU (accelerometer and gyroscope) natively supports digital communication (I²C and SPI), meaning it connects directly to the I²C bus on the module without requiring additional conversion circuitry. The default address for the Module is: @@ -78,6 +80,7 @@ Depending on the board connected to the modulino, the I²C pin names to program - **OCSAUX: Auxiliary Output** – Auxiliary output control signal pin. ### 1x4 Header (I2C) + | Pin | Function | |-------|--------------| | GND | Ground | @@ -117,16 +120,18 @@ There's also a small power indicator LED that lights up when the board is on. Some options for customizing the module's features via onboard solder jumpers are available: ### **VDDIO Independence:** + - By default, **VDDIO is connected to +3V3**. - To make **VDDIO independent**, cut the corresponding solder jumper. ### SPI Mode Selection: + - The LSM6DSOXTR supports both **3-wire and 4-wire SPI**. - You can configure SPI communication and connect additional sensors by cutting or soldering the appropriate jumpers. Please take a look at the IMU's datasheet for more information. You can grab the full schematic and PCB files from the [Modulino Movement](https://docs.arduino.cc/hardware/modulinos/modulino-movement) product page. -# How To Connect Your Modulino +## How To Connect Your Modulino The easiest and most reliable way to connect your Modulino is through the QWIIC Connect System. It's plug-and-play, uses standard I²C, and makes it easy to join multiple modules. If your board supports QWIIC, this is the recommended way to go. Note that the dedicated I²C pins will differ from board to board meaning it is always a good idea to check your specific model. @@ -134,11 +139,12 @@ If your board doesn't have a QWIIC connector, you can still access the same I²C ![Modulino Wiring Options QWIIC(A - recommended) and Header(B)](assets/connection-guide-movement.png) -## QWIIC Connector +### QWIIC Connector Whenever available, the **QWIIC Connect System** is the preferred method. Connecting to the Modulino is extremely simple, just use a standard QWIIC cable to connect your board to either of the QWIIC connectors on the Modulino. Because the cable and connectors are polarized, there is no need to worry about accidentally swapping connections. QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connectors: + - GND - 3.3V - SDA (Data) @@ -150,23 +156,22 @@ The Modulino features two QWIIC connectors, which are internally connected in pa When connecting multiple I²C devices, address conflicts may occur if two or more devices share the same default I²C address. The Modulino addresses this potential issue by allowing you to select a different address through a simple hardware modification. We cover this process in detail in the [**Changing I²C Address**](#changing-i2c-address) section, enabling you to integrate multiple identical modules or different devices that share the same default address in your project. -## Solderable Header +### Solderable Header When QWIIC is not available, you can use the exposed solderable pins on the module. You can solder pins to the unpopulated pads; just remember the pinout provided in this guide to connect to the right pins of your board. ![Connection Guide Solder Pads](assets/connection-guide-movement-jumper.png) -## Daisy-Chaining Multiple Modulinos +### Daisy-Chaining Multiple Modulinos Regardless of whether you connect the first Modulino via QWIIC or through the solderable pins, you can still take advantage of the extra QWIIC connector to daisy-chain additional modules. Each Modulino includes two QWIIC connectors wired in parallel, allowing you to connect one module to the next in a chain. As long as each module is configured with a unique I²C address, they can all communicate on the same bus as long as you select the correct I²C pins depending on your board. This approach keeps your setup clean, modular, and expandable without adding extra wiring complexity. ![Modulino Wiring Options](assets/connection-guide-movement-qwiic-chain.png) ***The number of modules you can connect will depend on what modules you are chaining together, as this system allows for multiple sensors from different manufacturers to be added. Also, the cables you use for these connections will play a significant role in the setup's performance. Ensure your cables are correctly connected and capable of handling the required data transfer. - Each module should have a unique address on a chain if you plan to address them individually. Later in this article we teach how to [change the address](#how-to-change-i2c-address). Multiple modules with the same address will cause conflicts on the I²C bus and will not allow you to address them individually.*** -## Changing I2C Address +### Changing I2C Address The Modulino Movement can be configured to use an alternative I2C address (0x6B) instead of the default address (0x6A). To change the address, follow these steps carefully: @@ -188,9 +193,9 @@ ModulinoMovement movement(0x7E); -# How To Use Your Modulino +## How To Use Your Modulino -## Installing The Modulino Library +### Installing The Modulino Library You need the official Modulino library available [here](https://docs.arduino.cc/libraries/modulino/) to use the Modulino Movement. With the Arduino IDE you get some tools that make adding a library easier. To learn how to install the IDE please visit our [page](https://www.support.arduino.cc/hc/en-us/articles/360019833020-Download-and-install-Arduino-IDE). @@ -199,6 +204,7 @@ After opening the IDE, a tab should be visible on the left. Press the book icon ![IDE Library Tab](assets/IDE-Left-Tab.png) You can now look for the library ```Modulino``` by filling in the ```Filter your search``` textbox. + A prompt might appear saying that additional dependencies are required. This is not a problem, as they will be automatically added when you confirm the prompt. ![Add Dependencies Prompt](assets/library-dependencies.png) @@ -209,9 +215,10 @@ The process should look like this: A message will appear after the installation is successful. -## Getting Acceleration Data +### Getting Acceleration Data Getting data from the sensor is fairly simple using the ```Modulino``` library. For the **Modulino Movement** there are four important functions: + - ```update()```: Updates the sensor readings. - ```getX()```: Retrieves the acceleration value on the **X-axis** in **g**. - ```getY()```: Retrieves the acceleration value on the **Y-axis** in **g**. @@ -277,34 +284,42 @@ void loop() { ``` The code example provided shows how to initialize the sensor, read the acceleration data, and display it on the serial monitor. The data is continuously updated, showing the current acceleration values in real time. + It can be easily adapted to trigger actions at certain movement thresholds or to detect specific motion patterns in your projects. -### Troubleshooting +## Troubleshooting + +### Sensor Not Reachable -#### Sensor Not Reachable If your Modulino's power LED isn't on or the sensor isn't responsive, first check that the board is properly connected: + - Ensure both the board and the Modulino are connected to your computer, and that the power LEDs on both are lit. - If the issue persists, make sure the Qwiic cable is properly clicked into place. -#### Library Not Installed Properly +### Library Not Installed Properly + If you encounter an issue with the `#include "modulino.h"` command, verify that the Modulino library is correctly installed: + - Check your IDE to ensure the library is installed and up-to-date. - Re-install the library through the Library Manager. -#### Inaccurate Values +### Inaccurate Values + If the sensor values are not accurate, make sure: + - The sensor is not placed on an unstable surface that might cause unwanted vibrations. - All exposed electronics are not touching any conductive surfaces, as this could interfere with readings. - The board is mounted securely when measuring precise movements. -# What Is Next? +## Conclusion + +The **Modulino Movement** is a digital 6-axis IMU sensor that communicates over I²C and follows the Modulino form factor. It includes standard Qwiic connectors for quick, solderless connections and easy daisy-chaining with other modules. Paired with the Modulino library, it makes accessing motion data straightforward, allowing you to focus on experimenting or building your system logic. It's a small, reliable module suited for both quick tests and longer-term setups. + +## What Is Next? Now that you've learned how to use your Modulino Movement, you're all set to integrate it into your projects! + - Use the movement data to detect different patterns and use these as inputs for your projects. - Create a motion-activated alarm that triggers when unexpected movement is detected. - Build a balance game that challenges players to keep the sensor level within certain parameters. -- Make a pedometer that counts steps based on the characteristic motion patterns of walking. - -# Conclusion - -The **Modulino Movement** is a digital 6-axis IMU sensor that communicates over I²C and follows the Modulino form factor. It includes standard Qwiic connectors for quick, solderless connections and easy daisy-chaining with other modules. Paired with the Modulino library, it makes accessing motion data straightforward, allowing you to focus on experimenting or building your system logic. It's a small, reliable module suited for both quick tests and longer-term setups. \ No newline at end of file +- Make a pedometer that counts steps based on the characteristic motion patterns of walking. \ No newline at end of file diff --git a/content/hardware/11.accessories/modulino-nodes/modulino-movement/tutorials/how-movement-mp/content.md b/content/hardware/11.accessories/modulino-nodes/modulino-movement/tutorials/how-movement-mp/content.md index 0cf4339ef6..d8946647dd 100644 --- a/content/hardware/11.accessories/modulino-nodes/modulino-movement/tutorials/how-movement-mp/content.md +++ b/content/hardware/11.accessories/modulino-nodes/modulino-movement/tutorials/how-movement-mp/content.md @@ -12,6 +12,7 @@ software: - ide-v2 - web-editor --- + The Modulino Movement is a modular sensor that measures acceleration and angular velocity, making it perfect to add motion sensing to your projects! The Modulino form factor is shaped with two QWIIC connectors and the I²C protocol integration, allowing the connection and programming of multiple modulinos in a very simple way. In addition to the QWIIC's connectors, the Modulinos also expose solderable pins that can be used in multiple ways and make them compatible with boards that are not QWIIC compatible. ## General Characteristics @@ -30,9 +31,10 @@ The Modulino Movement is capable of measuring acceleration and angular velocity. | **FIFO Buffer** | - | - | 9 | - | KB | | **Sampling Rate** | Output Data Rate | 1.6 | - | 6664 | Hz | -## Sensor Details +### Sensor Details The LSM6DSOXTR sensor from STMicroelectronics is the core component of this module. This 6-axis IMU (accelerometer and gyroscope) natively supports digital communication (I²C and SPI), meaning it connects directly to the I²C bus on the module without requiring additional conversion circuitry. + The default address for the Module is: | Modulino I²C Address | Hardware I²C Address | @@ -40,6 +42,7 @@ The default address for the Module is: | 0x6A or 0x7E | 0x6A or 0x7E | When scanning for I²C address on the bus, you might find the modulino using the **Hardware I²C Address**. However, you should always use the **Modulino I²C Address** when using the official Modulino library. + Later in this article we teach how to [change the address](#how-to-change-i2c-address). ## Pinout @@ -77,6 +80,7 @@ Depending on the board connected to the modulino, the I²C pin names to program - **OCSAUX: Auxiliary Output** – Auxiliary output control signal pin. ### 1x4 Header (I2C) + | Pin | Function | |-------|--------------| | GND | Ground | @@ -116,16 +120,18 @@ There's also a small power indicator LED that lights up when the board is on. Some options for customizing the module's features via onboard solder jumpers are available: ### **VDDIO Independence:** + - By default, **VDDIO is connected to +3V3**. - To make **VDDIO independent**, cut the corresponding solder jumper. ### SPI Mode Selection: + - The LSM6DSOXTR supports both **3-wire and 4-wire SPI**. - You can configure SPI communication and connect additional sensors by cutting or soldering the appropriate jumpers. Please take a look at the IMU's datasheet for more information. You can grab the full schematic and PCB files from the [Modulino Movement](https://docs.arduino.cc/hardware/modulinos/modulino-movement) product page. -# How To Connect Your Modulino +## How To Connect Your Modulino The easiest and most reliable way to connect your Modulino is through the QWIIC Connect System. It's plug-and-play, uses standard I²C, and makes it easy to join multiple modules. If your board supports QWIIC, this is the recommended way to go. Note that the dedicated I²C pins will differ from board to board meaning it is always a good idea to check your specific model. @@ -133,7 +139,7 @@ If your board doesn't have a QWIIC connector, you can still access the same I²C ![Modulino Wiring Options QWIIC(A - recommended) and Header(B)](assets/connection-guide-movement.png) -## QWIIC Connector +### QWIIC Connector Whenever available, the **QWIIC Connect System** is the preferred method. Connecting to the Modulino is extremely simple, just use a standard QWIIC cable to connect your board to either of the QWIIC connectors on the Modulino. Because the cable and connectors are polarized, there is no need to worry about accidentally swapping connections. @@ -149,23 +155,22 @@ The Modulino features two QWIIC connectors, which are internally connected in pa When connecting multiple I²C devices, address conflicts may occur if two or more devices share the same default I²C address. The Modulino addresses this potential issue by allowing you to select a different address through a simple hardware modification. We cover this process in detail in the [**Changing I²C Address**](#changing-i2c-address) section, enabling you to integrate multiple identical modules or different devices that share the same default address in your project. -## Solderable Header +### Solderable Header When QWIIC is not available, you can use the exposed solderable pins on the module. You can solder pins to the unpopulated pads; just remember the pinout provided in this guide to connect to the right pins of your board. ![Connection Guide Solder Pads](assets/connection-guide-movement-jumper.png) -## Daisy-Chaining Multiple Modulinos +### Daisy-Chaining Multiple Modulinos Regardless of whether you connect the first Modulino via QWIIC or through the solderable pins, you can still take advantage of the extra QWIIC connector to daisy-chain additional modules. Each Modulino includes two QWIIC connectors wired in parallel, allowing you to connect one module to the next in a chain. As long as each module is configured with a unique I²C address, they can all communicate on the same bus as long as you select the correct I²C pins depending on your board. This approach keeps your setup clean, modular, and expandable without adding extra wiring complexity. ![Modulino Wiring Options](assets/connection-guide-movement-qwiic-chain.png) ***The number of modules you can connect will depend on what modules you are chaining together, as this system allows for multiple sensors from different manufacturers to be added. Also, the cables you use for these connections will play a significant role in the setup's performance. Ensure your cables are correctly connected and capable of handling the required data transfer. - Each module should have a unique address on a chain if you plan to address them individually. Later in this article we teach how to [change the address](#how-to-change-i2c-address). Multiple modules with the same address will cause conflicts on the I²C bus and will not allow you to address them individually.*** -## Changing I2C Address +### Changing I2C Address The Modulino Movement can be configured to use an alternative I2C address (0x6B) instead of the default address (0x6A). To change the address, follow these steps carefully: @@ -186,31 +191,37 @@ movement_module = ModulinoMovement(address=0x7E) ``` -### How To Program Your Modulino +## How To Program Your Modulino + +### Installing The Modulino Library + To program your Modulino it is recommended you use the official ```Modulino``` micropython library available [here](https://github.com/arduino/arduino-modulino-mpy). The library is fully compatible with the no **Arduino Lab for MicroPython**. + For information on installing the **Arduino Lab for MicroPython** please visit our [page](https://docs.arduino.cc/micropython/first-steps/install-guide/). -### Installing The Modulino Library The ```Modulino``` library is not available by default on MicroPython devices hence installation is needed. + To simplify the process the [MicroPython Package Installer](https://github.com/arduino/lab-micropython-package-installer/releases) is recommended as it will provide a graphical interface to guide installation. After installation, you should now be able to: 1. Open the tool. 2. Plug in your board to the computer. -![USB Connection](assets/mp-usb-connection.png) -If the board does not appear in the Detected Boards section, click Reload. If the board is still undetected, ensure no other programs (e.g., a code editor) are using the board's COM port. + ![USB Connection](assets/mp-usb-connection.png) + + If the board does not appear in the Detected Boards section, click Reload. If the board is still undetected, ensure no other programs (e.g., a code editor) are using the board's COM port. -4. Search for the ```Modulino``` package by filling in the text box on the search feature. -5. Click Install and wait for the installation confirmation. -6. Disconnect the board from the tool before returning to your code editor to avoid conflicts due to a busy COM port. +3. Search for the ```Modulino``` package by filling in the text box on the search feature. +4. Click Install and wait for the installation confirmation. +5. Disconnect the board from the tool before returning to your code editor to avoid conflicts due to a busy COM port. ![Package Installer Overview](assets/package-installer-overview.png) The module should now be includable in your program using: + ```from modulino import ModulinoThermo``` -## Get Acceleration and Gyroscope Data +### Get Acceleration and Gyroscope Data Getting motion data from the **Modulino Movement** module is simple using the `Modulino` library. The module provides two crucial functions for motion sensing: @@ -236,36 +247,45 @@ while True: print("") sleep_ms(100) ``` + The code example provided shows how to initialize the sensor, read the acceleration data, and display it on the console. + The data is continuously updated, showing the current acceleration values in real time. It can be easily adapted to trigger actions at certain movement thresholds or to detect specific motion patterns in your projects. -### Troubleshooting +## Troubleshooting + +### Sensor Not Reachable -#### Sensor Not Reachable If your Modulino's power LED isn't on or the sensor isn't responsive, first check that the board is properly connected: + - Ensure both the board and the Modulino are connected to your computer, and that the power LEDs on both are lit. - If the issue persists, make sure the Qwiic cable is properly clicked into place. -#### Library Not Installed Properly +### Library Not Installed Properly + If you encounter an issue with the `import ModulinoMovement` command, verify that the Modulino library is correctly installed: + - Check your Library installer to ensure the library is installed and up-to-date. - Re-install the library through the Library Manager. -#### Inaccurate Values +### Inaccurate Values + If the sensor values are not accurate, make sure: + - The sensor is not placed on an unstable surface that might cause unwanted vibrations. - All exposed electronics are not touching any conductive surfaces, as this could interfere with readings. - The board is mounted securely when measuring precise movements. -# What Is Next? +## Conclusion + +The **Modulino Movement** is a digital 6-axis IMU sensor that communicates over I²C and follows the Modulino form factor. It includes standard Qwiic connectors for quick, solderless connections and easy daisy-chaining with other modules. Paired with the Modulino library, it makes accessing motion data straightforward, allowing you to focus on experimenting or building your system logic. It's a small, reliable module suited for both quick tests and longer-term setups. + +## What Is Next? Now that you've learned how to use your Modulino Movement, you're all set to integrate it into your projects! + - Use the movement data to detect different patterns and use these as inputs for your projects. - Create a motion-activated alarm that triggers when unexpected movement is detected. - Build a balance game that challenges players to keep the sensor level within certain parameters. -- Make a pedometer that counts steps based on the characteristic motion patterns of walking. - -# Conclusion - -The **Modulino Movement** is a digital 6-axis IMU sensor that communicates over I²C and follows the Modulino form factor. It includes standard Qwiic connectors for quick, solderless connections and easy daisy-chaining with other modules. Paired with the Modulino library, it makes accessing motion data straightforward, allowing you to focus on experimenting or building your system logic. It's a small, reliable module suited for both quick tests and longer-term setups. \ No newline at end of file +- Make a pedometer that counts steps based on the characteristic motion patterns of walking. \ No newline at end of file diff --git a/content/hardware/11.accessories/modulino-nodes/modulino-pixels/tutorials/how-pixels-ardu/content.md b/content/hardware/11.accessories/modulino-nodes/modulino-pixels/tutorials/how-pixels-ardu/content.md index b1af9f2f31..493c4105f4 100644 --- a/content/hardware/11.accessories/modulino-nodes/modulino-pixels/tutorials/how-pixels-ardu/content.md +++ b/content/hardware/11.accessories/modulino-nodes/modulino-pixels/tutorials/how-pixels-ardu/content.md @@ -12,7 +12,9 @@ software: - ide-v2 - web-editor --- + The Modulino Pixels is a modular sensor that generates RGB light effects, making it perfect to add colorful visual feedback to your projects! + The Modulino form factor is shaped with two QWIIC connectors and the I²C protocol integration, allowing the connection and programming of multiple modulinos in a very simple way. In addition to the QWIIC's connectors, the Modulinos also expose solderable pins that can be used in multiple ways and make them compatible with boards that are not QWIIC compatible. ## Hardware Specifications @@ -28,6 +30,7 @@ The Modulino Pixels based on 8 LC8822-2020 addressable LEDs is capable of genera ## Pinout The LC8822-2020 addressable LEDs are the core components of this module. These RGB light output devices are controlled by an onboard STM32C011F4U6TR microcontroller, which supports digital communication (I²C), meaning it connects directly to the I²C bus on the module without requiring additional conversion circuitry. + ![Modulino Pixels Pinout](assets/PixelsPinouts.png) ### 1x10 Header (LC8822-2020 and Microcontroller Signals) @@ -54,6 +57,7 @@ The LC8822-2020 addressable LEDs are the core components of this module. These R - **C0: Pixels Clock Out**: Provides clock signal synchronization for addressable LED strips, ensuring proper timing for pixel data. ### 1x4 Header (I2C) + The pinout for the Modulino Pixels is shown below. While the recommended connection method is via the QWIIC connectors, this solderable header provides a connection option when using the modulino with a non-QWIIC compatible board. | Pin | Function | @@ -66,6 +70,7 @@ The pinout for the Modulino Pixels is shown below. While the recommended connect ## I2C Address The **Modulino Pixels** module uses **LC8822-2020** addressable LEDs, which do not have native I²C capabilities. Instead, the LED array is controlled by the Modulino's onboard microcontroller (STM32C011F4U6TR). This microcontroller provides I²C communication, allowing for flexible control of the LEDs. + One unique feature of this setup is the ability to change the I²C address via software. This means the address can be modified based on your application needs, making it adaptable to different system configurations. The default I²C address for the **Modulino Pixels** module is: | Modulino I²C Address | Hardware I²C Address | Editable Addresses (HEX) | @@ -73,6 +78,7 @@ One unique feature of this setup is the ability to change the I²C address via s | 0x6C | 0x36 | Any custom address (via software) | When scanning for I²C address on the bus, you might find the modulino using the **Hardware I²C Address**. However, you should always use the **Modulino I²C Address** when using the official Modulino library. + Later in this article we teach how to [change the address](#how-to-change-i2c-address). ## Power Specifications @@ -88,7 +94,9 @@ The board is typically powered by +3.3 VDC when using the QWIIC interface as per The module additionally includes a power LED that draws 1 mA and turns on as soon as it is powered. + J1 (Qwiic connector), J2 (Qwiic connector), and the headers all share the same power branch. The power distribution of the module is therefore as follows: + ![Power Tree Modulino Pixels](assets/Modulino_Pixels_Power_Tree.png) ## Schematic @@ -98,11 +106,13 @@ The Modulino Pixels uses a simple circuit, as shown in the schematic below: ![Full Schematic Modulino Pixels](assets/schematic.png) The main components are the **8 LC8822-2020 addressable LEDs** and the **STM32C011F4U6TR** microcontroller (U1), which handles LED control as well as I²C communication. + You can connect to the I²C pins (SDA and SCL) using either the **QWIIC connectors** (J1 and J2, this is the recommended method) or the **solderable pins** (J4). The board runs on **3.3V**, which comes from the QWIIC cable or the **3V3 pin** on J4. The **LC8822-2020** LEDs are connected in a daisy chain, with the first LED receiving clock and data signals from the microcontroller. The **CO (Clock Out)** and **DO (Data Out)** of the last LED in the chain are accessible via the **1x10 header**, allowing for expansion. ![LED Expantion](assets/expansion-guide-pixels.png) These can also be found in small pads near the STM32 microcontroller alongside a few user defines pads that can be used by editing the firmware: + ![Exposed user-defined and LED expansion pads](assets/pixel-expantion-mc.png) There's also a small power LED indicator that lights up when the board is on. @@ -117,10 +127,12 @@ Note that the dedicated I²C pins will differ from board to board meaning it is ![Modulino Wiring Options QWIIC(A - recommended) and Header(B)](assets/connection-guide-pixels.png) -## QWIIC Connector +### QWIIC Connector + Whenever available, the **QWIIC Connect System** is the preferred method. Connecting to the Modulino is extremely simple, just use a standard QWIIC cable to connect your board to either of the QWIIC connectors on the Modulino. Because the cable and connectors are polarized, there is no need to worry about accidentally swapping connections. QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connectors: + - GND - 3.3V - SDA (Data) @@ -130,12 +142,13 @@ QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connec The Modulino features two QWIIC connectors, which are internally connected in parallel. This means you can daisy-chain multiple modules easily by connecting additional QWIIC cables between them. -## Solderable Header +### Solderable Header + When QWIIC is not available, you can use the exposed solderable pins on the module. You can solder pins to the unpopulated pads; just remember the pinout provided in this guide to connect to the right pins of your board. ![Connection Guide Solder Pads](assets/connection-guide-pixels-jumper.png) -## Daisy-Chaining Multiple Modulinos +### Daisy-Chaining Multiple Modulinos Regardless of whether you connect the first Modulino via QWIIC or through the solderable pins, you can still take advantage of the extra QWIIC connector to daisy-chain additional modules. @@ -144,27 +157,34 @@ Each Modulino includes two QWIIC connectors wired in parallel, allowing you to c This approach keeps your setup clean, modular, and expandable without adding extra wiring complexity. ![Modulino Wiring Options](assets/connection-guide-pixels-qwiic-chain.png) + ***The number of modules you can connect will depend on what modules you are chaining together, as this system allows for multiple sensors from different manufacturers to be added. Also, the cables you use for these connections will play a significant role in the setup’s performance. Ensure your cables are properly connected and capable of handling the required data transfer. Each module should have a unique address on a chain if you plan to address them individually. Later in this article we teach how to [change the address](#how-to-change-i2c-address). Multiple modules with the same address will cause conflicts on the I²C bus and will not allow you to address them individually.*** -## How To Program Your Modulino -To program the Modulino the official library available [here](https://docs.arduino.cc/libraries/modulino/) is recommended, it is fully compatible with the Arduino IDE. -For information on how to install the IDE please visit our [page](https://docs.arduino.cc/software/ide-v2/tutorials/getting-started/ide-v2-downloading-and-installing/). +## How To Use Your Modulino ### Installing The Modulino Library + You need the official Modulino library available [here](https://github.com/arduino-libraries/Modulino) to use the Modulino Thermo. With the Arduino IDE you get some tools that make adding a library easier. To learn how to install the IDE please visit our [page](https://docs.arduino.cc/software/ide-v2/tutorials/getting-started/ide-v2-downloading-and-installing/). + After opening the IDE, a tab should be visible on the left. Press the book icon for "library" as highlighted in the image. + ![IDE Library Tab](assets/IDE-Left-Tab.png) + The process should look like this: + ![Library Install](assets/library-install.gif) + A message will appear after the installation is successful. ### Set LED Colors Controlling RGB LEDs using the **Modulino Pixels** module is straightforward with the `Modulino` library. + For the **Pixels**, there are two important functions: + - `set(index, color, brightness)`: Sets a specific LED to a chosen color and brightness level. (`RED`,`BLUE`,`GREEN`,`VIOLET`,`WHITE`) - `show()`: Applies the changes to the LEDs. - ```Modulino.begin();```: By default the Modulino library uses ```Wire1``` if your connection is in a different Wire you will have to edit it, check [here](https://docs.arduino.cc/language-reference/en/functions/communication/wire/) (by default the Modulino library uses ```Wire1``` if your board model has a different pinout for the dedicated I²C pins you might have to edit it. More information on **Wire** can be found [here](https://docs.arduino.cc/language-reference/en/functions/communication/wire/)) for the library's hardware compatibility. More information on **Wire** can be found [here](https://docs.arduino.cc/language-reference/en/functions/communication/wire/). @@ -191,24 +211,29 @@ void loop(){ } } ``` + The code example provided demonstrates how to initialize the LED module and set all 8 LEDs to blue with a brightness level of 25%. The for-loop cycles through each LED (indexed 0-7), sets its color and brightness, and then uses the show() function to apply the change. This creates a simple blue light display that can be easily modified to create more complex lighting patterns or visual indicators for your projects. ### How To Change I²C Address An example sketch, AddressChanger, is also included with the library inside the `Utilities` folder and available [here](https://github.com/arduino-libraries/Modulino/blob/main/examples/Utilities/AddressChanger/AddressChanger.ino). This sketch changes the I²C address at a software level on the Module's microcontroller. + ![Example location on the IDE](assets/addressChangeIDE.png) - Connect the module to your board, remove any other modules that might be in the chain. Connection must be via I²C. - Upload the sketch. - Open the Serial Monitor. - Text should now appear. Make sure the correct bauld-rate is selected if the displayed characters seem corrupted. + ![Expected console output](assets/adressChanger.png) + - Select the address and confirm. - Your address should now have changed. Make sure to take note of the selected address. To keep track of the address in use the module has a white rectangle on the back. Feel free to use this to write the address that was chosen. When using a custom address in your sketch, you'll need to specify this address when creating the module object. For example: + ```arduino ModulinoPixels pixels(0x3E); // Replace 0x3E with your specific address ``` @@ -216,28 +241,35 @@ ModulinoPixels pixels(0x3E); // Replace 0x3E with your specific address ## Troubleshooting ### LEDs Not Lighting + If your Modulino's power LED isn't on or the RGB LEDs aren't responsive, first check that the board is properly connected: + - Ensure both the board and the Modulino are connected to your computer, and that the power LEDs on both are lit. - If the issue persists, make sure the Qwiic cable is properly clicked into place. ### Library Not Installed Properly + If you encounter an issue with the `#include "modulino.h"` command, verify that the Modulino library is correctly installed: + - Check your IDE to ensure the library is installed and up-to-date. - Re-install the library through the Library Manager. ### Incorrect Colors or Flickering + If the LED colors are incorrect or the LEDs are flickering unexpectedly, make sure: + - The brightness values are within the appropriate range (typically 0-255). - All exposed electronics are not touching any conductive surfaces, as this could interfere with the LED output. - The power supply is stable and providing sufficient current for all LEDs at the desired brightness. -# Conclusion +## Conclusion The **Modulino Pixels** is a digital RGB LED control module that communicates over I²C and follows the Modulino form factor. It includes standard Qwiic connectors for quick, solderless connections and easy daisy-chaining with other modules. Paired with the Modulino library, it makes generating colorful light effects straightforward, allowing you to focus on experimenting or building your system logic. It's a small, reliable module suited for both visual feedback and creative lighting projects. -# What Is Next? +## What Is Next? Now that you've learned how to use your Modulino Pixels, you're all set to integrate it into your projects! + - Create an animated progress bar that visually displays status, or battery charge level using a gradient of colors. - Build a live sound level indicator that responds to ambient noise. - Design a pomodoro timer with color coded work and rest periods to boost your productivity. diff --git a/content/hardware/11.accessories/modulino-nodes/modulino-pixels/tutorials/how-pixels-mp/content.md b/content/hardware/11.accessories/modulino-nodes/modulino-pixels/tutorials/how-pixels-mp/content.md index f0c8119f5a..fb787dee6a 100644 --- a/content/hardware/11.accessories/modulino-nodes/modulino-pixels/tutorials/how-pixels-mp/content.md +++ b/content/hardware/11.accessories/modulino-nodes/modulino-pixels/tutorials/how-pixels-mp/content.md @@ -12,7 +12,9 @@ software: - ide-v2 - web-editor --- + The Modulino Pixels is a modular sensor that generates RGB light effects, making it perfect to add colorful visual feedback to your projects! + The Modulino form factor is shaped with two QWIIC connectors and the I²C protocol integration, allowing the connection and programming of multiple modulinos in a very simple way. In addition to the QWIIC's connectors, the Modulinos also expose solderable pins that can be used in multiple ways and make them compatible with boards that are not QWIIC compatible. ## Hardware Specifications @@ -28,6 +30,7 @@ The Modulino Pixels based on 8 LC8822-2020 addressable LEDs is capable of genera ## Pinout The LC8822-2020 addressable LEDs are the core components of this module. These RGB light output devices are controlled by an onboard STM32C011F4U6TR microcontroller, which supports digital communication (I²C), meaning it connects directly to the I²C bus on the module without requiring additional conversion circuitry. + ![Modulino Pixels Pinout](assets/PixelsPinouts.png) ### 1x10 Header (LC8822-2020 and Microcontroller Signals) @@ -54,6 +57,7 @@ The LC8822-2020 addressable LEDs are the core components of this module. These R - **C0: Pixels Clock Out**: Provides clock signal synchronization for addressable LED strips, ensuring proper timing for pixel data. ### 1x4 Header (I2C) + The pinout for the Modulino Pixels is shown below. While the recommended connection method is via the QWIIC connectors, this solderable header provides a connection option when using the modulino with a non-QWIIC compatible board. | Pin | Function | @@ -66,6 +70,7 @@ The pinout for the Modulino Pixels is shown below. While the recommended connect ## I2C Address The **Modulino Pixels** module uses **LC8822-2020** addressable LEDs, which do not have native I²C capabilities. Instead, the LED array is controlled by the Modulino's onboard microcontroller (STM32C011F4U6TR). This microcontroller provides I²C communication, allowing for flexible control of the LEDs. + One unique feature of this setup is the ability to change the I²C address via software. This means the address can be modified based on your application needs, making it adaptable to different system configurations. The default I²C address for the **Modulino Pixels** module is: | Modulino I²C Address | Hardware I²C Address | Editable Addresses (HEX) | @@ -73,6 +78,7 @@ One unique feature of this setup is the ability to change the I²C address via s | 0x6C | 0x36 | Any custom address (via software) | When scanning for I²C address on the bus, you might find the modulino using the **Hardware I²C Address**. However, you should always use the **Modulino I²C Address** when using the official Modulino library. + Later in this article we teach how to [change the address](#how-to-change-i2c-address). ## Power Specifications @@ -87,7 +93,9 @@ The board is typically powered by +3.3 VDC when using the QWIIC interface as per | Max LED Output Current | Per Channel | 18 | - | mA | The module additionally includes a power LED that draws 1 mA and turns on as soon as it is powered. + J1 (Qwiic connector), J2 (Qwiic connector), and the headers all share the same power branch. The power distribution of the module is therefore as follows: + ![Power Tree Modulino Pixels](assets/Modulino_Pixels_Power_Tree.png) ## Schematic @@ -97,12 +105,15 @@ The Modulino Pixels uses a simple circuit, as shown in the schematic below: ![Full Schematic Modulino Pixels](assets/schematic.png) The main components are the **8 LC8822-2020 addressable LEDs** and the **STM32C011F4U6TR** microcontroller (U1), which handles LED control as well as I²C communication. + You can connect to the I²C pins (SDA and SCL) using either the **QWIIC connectors** (J1 and J2, this is the recommended method) or the **solderable pins** (J4). The board runs on **3.3V**, which comes from the QWIIC cable or the **3V3 pin** on J4. The **LC8822-2020** LEDs are connected in a daisy chain, with the first LED receiving clock and data signals from the microcontroller. The **CO (Clock Out)** and **DO (Data Out)** of the last LED in the chain are accessible via the **1x10 header**, allowing for expansion. + ![LED Expantion](assets/expansion-guide-pixels.png) These can also be found in small pads near the STM32 microcontroller alongside a few user defines pads that can be used by editing the firmware: + ![Exposed user-defined and LED expansion pads](assets/pixel-expantion-mc.png) There's also a small power LED indicator that lights up when the board is on. @@ -112,15 +123,18 @@ You can grab the full schematic and PCB files from the [Modulino Pixels](https:/ ## How To Connect Your Modulino The easiest and most reliable way to connect your Modulino is through the QWIIC Connect System. It’s plug-and-play, uses standard I²C, and makes it easy to join multiple modules. If your board supports QWIIC, this is the recommended way to go. + Note that the dedicated I²C pins will differ from board to board meaning it is always a good idea to check your specific model. ![Modulino Wiring Options QWIIC(A - recommended) and Header(B)](assets/connection-guide-pixels.png) -## QWIIC Connector +### QWIIC Connector + Whenever available, the **QWIIC Connect System** is the preferred method. Connecting to the Modulino is extremely simple, just use a standard QWIIC cable to connect your board to either of the QWIIC connectors on the Modulino. Because the cable and connectors are polarized, there is no need to worry about accidentally swapping connections. QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connectors: + - GND - 3.3V - SDA (Data) @@ -130,12 +144,13 @@ QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connec The Modulino features two QWIIC connectors, which are internally connected in parallel. This means you can daisy-chain multiple modules easily by connecting additional QWIIC cables between them. -## Solderable Header +### Solderable Header + When QWIIC is not available, you can use the exposed solderable pins on the module. You can solder pins to the unpopulated pads; just remember the pinout provided in this guide to connect to the right pins of your board. ![Connection Guide Solder Pads](assets/connection-guide-pixels-jumper.png) -## Daisy-Chaining Multiple Modulinos +### Daisy-Chaining Multiple Modulinos Regardless of whether you connect the first Modulino via QWIIC or through the solderable pins, you can still take advantage of the extra QWIIC connector to daisy-chain additional modules. @@ -144,37 +159,49 @@ Each Modulino includes two QWIIC connectors wired in parallel, allowing you to c This approach keeps your setup clean, modular, and expandable without adding extra wiring complexity. ![Modulino Wiring Options](assets/connection-guide-pixels-qwiic-chain.png) + ***The number of modules you can connect will depend on what modules you are chaining together, as this system allows for multiple sensors from different manufacturers to be added. Also, the cables you use for these connections will play a significant role in the setup’s performance. Ensure your cables are properly connected and capable of handling the required data transfer. Each module should have a unique address on a chain if you plan to address them individually. Later in this article we teach how to [change the address](#how-to-change-i2c-address). Multiple modules with the same address will cause conflicts on the I²C bus and will not allow you to address them individually.*** + Later in this article we teach how to [change the address](#how-to-change-i2c-address). -### How To Program Your Modulino +## How To Program Your Modulino + +### Installing The Modulino Library + To program your Modulino it is recommended you use the official ```Modulino``` micropython library available [here](https://github.com/arduino/arduino-modulino-mpy). The library is fully compatible with the no **Arduino Lab for MicroPython**. + For information on installing the **Arduino Lab for MicroPython** please visit our [page](https://docs.arduino.cc/micropython/first-steps/install-guide/). -### Installing The Modulino Library + + The ```Modulino``` library is not available by default on MicroPython devices hence installation is needed. + To simplify the process the [MicroPython Package Installer](https://github.com/arduino/lab-micropython-package-installer/releases) is recommended as it will provide a graphical interface to guide installation. + After installation, you should now be able to: 1. Open the tool. 2. Plug in your board to the computer. -![USB Connection](assets/mp-usb-connection.png) -If the board does not appear in the Detected Boards section, click Reload. If the board is still undetected, ensure no other programs (e.g., a code editor) are using the board's COM port. + ![USB Connection](assets/mp-usb-connection.png) + + If the board does not appear in the Detected Boards section, click Reload. If the board is still undetected, ensure no other programs (e.g., a code editor) are using the board's COM port. -4. Search for the ```Modulino``` package by filling in the text box on the search feature. -5. Click Install and wait for the installation confirmation. -6. Disconnect the board from the tool before returning to your code editor to avoid conflicts due to a busy COM port. +3. Search for the ```Modulino``` package by filling in the text box on the search feature. +4. Click Install and wait for the installation confirmation. +5. Disconnect the board from the tool before returning to your code editor to avoid conflicts due to a busy COM port. ![Package Installer Overview](assets/package-installer-overview.png) The module should now be includable in your program using: + ```from modulino import ModulinoBuzzer``` ### Control RGB LEDs with MicroPython Getting LED data from the **Modulino Pixels** module is simple using the `Modulino` library. The crucial functions to control the LEDs are: + - `set_rgb(index, r, g, b, brightness)`: Sets a specific LED to an RGB color with the specified brightness. - `set_all_rgb(r, g, b, brightness)`: Sets all LEDs to an RGB color with the specified brightness. - `set_all_color(color, brightness)`: Sets all LEDs to a predefined color. (`RED`,`BLUE`,`GREEN`,`VIOLET`,`WHITE`) @@ -247,6 +274,7 @@ for j in range(3): # Turn off all LEDs pixels.clear_all().show() ``` + This example shows different ways to control the Pixels. It starts by creating a rainbow pattern using different colors for each LED. Next, it demonstrates setting all LEDs to the same color, using both RGB values and predefined color constants. The final section implements a Knight Rider animation by lighting one main LED at full brightness while slightly illuminating adjacent LEDs at reduced brightness. The `set_glowing_led()` function handles this effect by managing the primary LED and its neighbors, creating a back-and-forth scanning pattern that repeats three times before turning off all LEDs. ### How To Change Address @@ -261,6 +289,7 @@ A sketch is also available included with the library named `AddressChanger` and To keep track of the address in use, the module has a white rectangle on the back. Feel free to use this to write the address that was chosen. When using a custom address in your MicroPython sketch, you'll need to specify this address when creating the module object. For example: + ```python pixels_module = ModulinoPixels(address=0x45) # Replace 0x45 with your specific address ``` @@ -268,28 +297,35 @@ pixels_module = ModulinoPixels(address=0x45) # Replace 0x45 with your specific ## Troubleshooting ### LEDs Not Lighting + If your Modulino's power LED isn't on or the RGB LEDs aren't responsive, first check that the board is properly connected: + - Ensure both the board and the Modulino are connected to your computer, and that the power LEDs on both are lit. - If the issue persists, make sure the Qwiic cable is properly clicked into place. ### Library Not Installed Properly + If you encounter an issue with the `import ModulinoPixels"` command, verify that the Modulino library is correctly installed: + - Check your IDE to ensure the library is installed and up-to-date. - Re-install the library through the Library Manager. ### Incorrect Colors or Flickering + If the LED colors are incorrect or the LEDs are flickering unexpectedly, make sure: + - The brightness values are within the appropriate range (typically 0-255). - All exposed electronics are not touching any conductive surfaces, as this could interfere with the LED output. - The power supply is stable and providing sufficient current for all LEDs at the desired brightness. -# Conclusion +## Conclusion The **Modulino Pixels** is a digital RGB LED control module that communicates over I²C and follows the Modulino form factor. It includes standard Qwiic connectors for quick, solderless connections and easy daisy-chaining with other modules. Paired with the Modulino library, it makes generating colorful light effects straightforward, allowing you to focus on experimenting or building your system logic. It's a small, reliable module suited for both visual feedback and creative lighting projects. -# What Is Next? +## What Is Next? Now that you've learned how to use your Modulino Pixels, you're all set to integrate it into your projects! + - Create an animated progress bar that visually displays status, or battery charge level using a gradient of colors. - Build a live sound level indicator that responds to ambient noise. - Design a pomodoro timer with color coded work and rest periods to boost your productivity. diff --git a/content/hardware/11.accessories/modulino-nodes/modulino-thermo/tutorials/how-thermo-ardu/content.md b/content/hardware/11.accessories/modulino-nodes/modulino-thermo/tutorials/how-thermo-ardu/content.md index 54057dc31f..804380821a 100644 --- a/content/hardware/11.accessories/modulino-nodes/modulino-thermo/tutorials/how-thermo-ardu/content.md +++ b/content/hardware/11.accessories/modulino-nodes/modulino-thermo/tutorials/how-thermo-ardu/content.md @@ -12,10 +12,12 @@ software: - ide-v2 - web-editor --- + The Modulino Thermo is a modular sensor that measures temperature and humidity, making it perfect to add environmental monitoring to your projects! + The Modulino form factor is shaped with two QWIIC connectors and the I²C protocol integration, allowing the connection and programming of multiple modulinos in a very simple way. In addition to the QWIIC's connectors, the Modulinos also expose solderable pins that can be used in multiple ways and make them compatible with boards that are not QWIIC compatible. -# General Characteristics +## General Characteristics The Modulino Thermo is capable of measuring temperature and relative humidity. Take a look at the following table to know more about its measuring ranges: @@ -27,7 +29,7 @@ The Modulino Thermo is capable of measuring temperature and relative humidity. T | Accuracy | Temperature | \- | ±0,25 | \- | °C | | \- | Humidity | \- | ±2.8% | \- | φ | -## Sensor Details +### Sensor Details The HS3003 sensor from Renesas is the core component of this module. This temperature and humidity sensor natively supports digital communication (I²C), meaning it connects directly to the I²C bus on the module without requiring additional conversion circuitry. @@ -48,6 +50,7 @@ The pinout for the Modulino Thermo is shown below. Please note that the exposed Depending on the board connected to the modulino, the I²C pin names to program it may differ. Please check the [board tutorials](https://docs.arduino.cc/hardware/) on your modulino's compatible board or the [Modulino library](https://github.com/arduino-libraries/Modulino/tree/main/docs) to learn more. ### 1x4 Header (I2C) + The pinout for the Modulino Buzzer is shown below. While the recommended connection method is via the QWIIC connectors, this solderable header provides a connection option when using the modulino with a non-QWIIC compatible board. | Pin | Function | @@ -67,19 +70,25 @@ The board is typically powered by +3.3 VDC when using the QWIIC interface as per | Average Current | 1 humidity + temperature measurement/s 3.3 VDD - Max 5,5@ 3.3 VDD | \- | 1024.4 | 24.4 | µA | The module additionally includes a power LED that draws 1 mA and turns on as soon as it is powered. + J1 (Qwiic connector), J2 (Qwiic connector), and the headers all share the same power branch. The power distribution of the module is therefore as follows: + ![Power Tree Modulino Thermo](assets/Modulino_Thermo_Power_Tree.png) ## Schematic The Modulino Thermo uses a simple circuit, as shown in the schematic below: + ![Full Schematic Modulino Thermo](assets/schematic.png) + The main component is the **HS3003** sensor (U1), which handles both temperature and humidity measurements, as well as I²C communication. + You can connect to the I²C pins (SDA and SCL) using either the **QWIIC connectors** (J1 and J2, this is the recommended method) or the **solderable pins** (J4). The board runs on **3.3V**, which comes from the QWIIC cable or the **3V3 pin** on J4. + There's also a small power indicator LED that lights up when the board is on. You can grab the full schematic and PCB files from the [Modulino Thermo](https://docs.arduino.cc/hardware/modulinos/modulino-thermo) product page. -# How To Connect Your Modulino +## How To Connect Your Modulino The easiest and most reliable way to connect your Modulino is through the QWIIC Connect System. It’s plug-and-play, uses standard I²C, and makes it easy to join multiple modules. If your board supports QWIIC, this is the recommended way to go. Note that the dedicated I²C pins will differ from board to board meaning it is always a good idea to check your specific model. @@ -87,11 +96,12 @@ If your board doesn’t have a QWIIC connector, you can still access the same I ![Modulino Wiring Options QWIIC(A - recommended) and Header(B)](assets/connection-guide-thermo.png) -## QWIIC Connector +### QWIIC Connector Whenever available, the **QWIIC Connect System** is the preferred method. Connecting to the Modulino is extremely simple, just use a standard QWIIC cable to connect your board to either of the QWIIC connectors on the Modulino. Because the cable and connectors are polarized, there is no need to worry about accidentally swapping connections. QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connectors: + - GND - 3.3V - SDA (Data) @@ -101,12 +111,13 @@ QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connec The Modulino features two QWIIC connectors, which are internally connected in parallel. This means you can daisy-chain multiple modules easily by connecting additional QWIIC cables between them. -## Solderable Header +### Solderable Header + When QWIIC is not available, you can use the exposed solderable pins on the module. You can solder pins to the unpopulated pads; just remember the pinout provided in this guide to connect to the right pins of your board. ![Connection Guide Solder Pads](assets/connection-guide-thermo-jumper.png) -## Daisy-Chaining Multiple Modulinos +### Daisy-Chaining Multiple Modulinos Regardless of whether you connect the first Modulino via QWIIC or through the solderable pins, you can still take advantage of the extra QWIIC connector to daisy-chain additional modules. @@ -115,25 +126,33 @@ Each Modulino includes two QWIIC connectors wired in parallel, allowing you to c This approach keeps your setup clean, modular, and expandable without adding extra wiring complexity. ![Modulino Wiring Options](assets/connection-guide-thermo-qwiic-chain.png) + ***The number of modules you can connect will depend on what modules you are chaining together, as this system allows for multiple sensors from different manufacturers to be added. Also, the cables you use for these connections will play a significant role in the setup’s performance. Ensure your cables are correctly connected and capable of handling the required data transfer. Each module should have a unique address on a chain if you plan to address them individually. Multiple modules with the same address will cause conflicts on the I²C bus.*** -# How To Use Your Modulino +## How To Use Your Modulino + +### Installing The Modulino Library -## Installing The Modulino Library You need the official Modulino library available [here](https://docs.arduino.cc/libraries/modulino/) to use the Modulino Thermo. With the Arduino IDE you get some tools that make adding a library easier. To learn how to install the IDE please visit our [page](https://docs.arduino.cc/software/ide-v2/tutorials/getting-started/ide-v2-downloading-and-installing/). + After opening the IDE, a tab should be visible on the left. Press the book icon for "library" as highlighted in the image. + ![IDE Library Tab](assets/IDE-Left-Tab.png) + The process should look like this: + ![Library Install](assets/library-install.gif) + A message will appear after the installation is successful. -## Getting Temperature And Humidity Data +### Getting Temperature And Humidity Data Getting data from the sensor is fairly simple using the ```Modulino``` library. For the **Modulino Thermo** there are two important functions: + - ```getTemperature()```: Provides the temperature measurement from the sensor. (default in Celsius C) - ```getHumidity()```: Provides the relative humidity measurement from the sensor. (default in Relative Percentage %) - ```Modulino.begin();```: By default the Modulino library uses ```Wire1``` if your connection is in a different Wire you will have to edit it, check [here](https://docs.arduino.cc/language-reference/en/functions/communication/wire/) (by default the Modulino library uses ```Wire1``` if your board model has a different pinout for the dedicated I²C pins you might have to edit it. More information on **Wire** can be found [here](https://docs.arduino.cc/language-reference/en/functions/communication/wire/)) for the library's hardware compatibility. More information on **Wire** can be found [here](https://docs.arduino.cc/language-reference/en/functions/communication/wire/). @@ -173,38 +192,41 @@ void loop(){ ``` The code example provided shows how to initialize the sensor, read the data, and display it on the serial monitor. The data is updated every second, showing the current temperature and humidity values in real time. + It can be easily adapted to trigger actions at certain temperature/humidity thresholds or to log data for analysis. ## Troubleshooting - ### Sensor Not Reachable +### Sensor Not Reachable - If your Modulino's power LED isn't on or the sensor isn't responsive, first check that the board is properly connected: +If your Modulino's power LED isn't on or the sensor isn't responsive, first check that the board is properly connected: - - Ensure both the board and the Modulino are connected to your computer, and that the power LEDs on both are lit. - - If the issue persists, make sure the Qwiic cable is properly clicked into place. +- Ensure both the board and the Modulino are connected to your computer, and that the power LEDs on both are lit. +- If the issue persists, make sure the Qwiic cable is properly clicked into place. - ### Library Not Installed Properly +### Library Not Installed Properly - If you encounter an issue with the `#include "modulino.h"` command, verify that the Modulino library is correctly installed: - - Check your IDE to ensure the library is installed and up-to-date. - - Re-install the library through the Library Manager. +If you encounter an issue with the `#include "modulino.h"` command, verify that the Modulino library is correctly installed: - ### Inaccurate Values +- Check your IDE to ensure the library is installed and up-to-date. +- Re-install the library through the Library Manager. + +### Inaccurate Values If the sensor values are not accurate, make sure: + - The sensor is not placed near any components that might generate heat (like motors or power supplies). - All exposed electronics are not touching any conductive surfaces, as this could interfere with readings. -# What Is Next? +## Conclusion + +The **Modulino Thermo** is a digital temperature and humidity sensor that communicates over I²C and follows the Modulino form factor. It includes standard Qwiic connectors for quick, solderless connections and easy daisy-chaining with other modules. Paired with the Modulino library, it makes accessing sensor data straightforward, allowing you to focus on experimenting or building your system logic. It’s a small, reliable module suited for both quick tests and longer-term setups. + +## What Is Next? Now that you've learned how to use your Modulino Thermo, you're all set to integrate it into your projects! - Experiment with temperature and humidity. What happens if you place your Modulino in the refrigerator? - Try breathing near the sensor. Does the humidity change? - Place your Modulino on the outside of your mug and fill it with a hot beverage. Can you create an automatic system to know when your tea has cooled down? -- How does the temperature change throughout the day at home? Let your Modulino run for an entire day and check out the data! - -# Conclusion - -The **Modulino Thermo** is a digital temperature and humidity sensor that communicates over I²C and follows the Modulino form factor. It includes standard Qwiic connectors for quick, solderless connections and easy daisy-chaining with other modules. Paired with the Modulino library, it makes accessing sensor data straightforward, allowing you to focus on experimenting or building your system logic. It’s a small, reliable module suited for both quick tests and longer-term setups. \ No newline at end of file +- How does the temperature change throughout the day at home? Let your Modulino run for an entire day and check out the data! \ No newline at end of file diff --git a/content/hardware/11.accessories/modulino-nodes/modulino-thermo/tutorials/how-thermo-mp/content.md b/content/hardware/11.accessories/modulino-nodes/modulino-thermo/tutorials/how-thermo-mp/content.md index 0a825a599d..1ceb8f5622 100644 --- a/content/hardware/11.accessories/modulino-nodes/modulino-thermo/tutorials/how-thermo-mp/content.md +++ b/content/hardware/11.accessories/modulino-nodes/modulino-thermo/tutorials/how-thermo-mp/content.md @@ -12,10 +12,12 @@ software: - ide-v2 - web-editor --- + The Modulino Thermo is a modular sensor that measures temperature and humidity, making it perfect to add environmental monitoring to your projects! + The Modulino form factor is shaped with two QWIIC connectors and the I²C protocol integration, allowing the connection and programming of multiple modulinos in a very simple way. In addition to the QWIIC's connectors, the Modulinos also expose solderable pins that can be used in multiple ways and make them compatible with boards that are not QWIIC compatible. -# General Characteristics +## General Characteristics The Modulino Thermo is capable of measuring temperature and relative humidity. Take a look at the following table to know more about its measuring ranges: @@ -27,7 +29,7 @@ The Modulino Thermo is capable of measuring temperature and relative humidity. T | Accuracy | Temperature | \- | ±0,25 | \- | °C | | \- | Humidity | \- | ±2.8% | \- | φ | -## Sensor Details +### Sensor Details The HS3003 sensor from Renesas is the core component of this module. This temperature and humidity sensor natively supports digital communication (I²C), meaning it connects directly to the I²C bus on the module without requiring additional conversion circuitry. @@ -46,6 +48,7 @@ The pinout for the Modulino Thermo is shown below. Please note that the exposed ![Arduino Thermo Pinout](assets/ThermoPinouts.jpg) ### 1x4 Header (I2C) + The pinout for the Modulino Buzzer is shown below. While the recommended connection method is via the QWIIC connectors, this solderable header provides a connection option when using the modulino with a non-QWIIC compatible board. | Pin | Function | @@ -67,19 +70,26 @@ The board is typically powered by +3.3 VDC when using the QWIIC interface as per | Average Current | 1 humidity + temperature measurement/s 3.3 VDD - Max 5,5@ 3.3 VDD | \- | 1024.4 | 24.4 | µA | The module additionally includes a power LED that draws 1 mA and turns on as soon as it is powered. + J1 (Qwiic connector), J2 (Qwiic connector), and the headers all share the same power branch. The power distribution of the module is therefore as follows: + ![Power Tree Modulino Thermo](assets/Modulino_Thermo_Power_Tree.png) ## Schematic The Modulino Thermo uses a simple circuit, as shown in the schematic below: + ![Full Schematic Modulino Thermo](assets/schematic.png) + The main component is the **HS3003** sensor (U1), which handles both temperature and humidity measurements, as well as I²C communication. + You can connect to the I²C pins (SDA and SCL) using either the **QWIIC connectors** (J1 and J2, this is the recommended method) or the **solderable pins** (J4). The board runs on **3.3V**, which comes from the QWIIC cable or the **3V3 pin** on J4. + There's also a small power indicator LED that lights up when the board is on. + You can grab the full schematic and PCB files from the [Modulino Thermo](https://docs.arduino.cc/hardware/modulinos/modulino-thermo) product page. -# How To Connect Your Modulino +## How To Connect Your Modulino The easiest and most reliable way to connect your Modulino is through the QWIIC Connect System. It’s plug-and-play, uses standard I²C, and makes it easy to join multiple modules. If your board supports QWIIC, this is the recommended way to go. Note that the dedicated I²C pins will differ from board to board meaning it is always a good idea to check your specific model. @@ -87,11 +97,12 @@ If your board doesn’t have a QWIIC connector, you can still access the same I ![Modulino Wiring Options QWIIC(A - recommended) and Header(B)](assets/connection-guide-thermo.png) -## QWIIC Connector +### QWIIC Connector Whenever available, the **QWIIC Connect System** is the preferred method. Connecting to the Modulino is extremely simple, just use a standard QWIIC cable to connect your board to either of the QWIIC connectors on the Modulino. Because the cable and connectors are polarized, there is no need to worry about accidentally swapping connections. QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connectors: + - GND - 3.3V - SDA (Data) @@ -101,12 +112,13 @@ QWIIC is a plug-and-play I²C Connect System that uses standardized 4-pin connec The Modulino features two QWIIC connectors, which are internally connected in parallel. This means you can daisy-chain multiple modules easily by connecting additional QWIIC cables between them. -## Solderable Header +### Solderable Header + When QWIIC is not available, you can use the exposed solderable pins on the module. You can solder pins to the unpopulated pads; just remember the pinout provided in this guide to connect to the right pins of your board. ![Connection Guide Solder Pads](assets/connection-guide-thermo-jumper.png) -## Daisy-Chaining Multiple Modulinos +### Daisy-Chaining Multiple Modulinos Regardless of whether you connect the first Modulino via QWIIC or through the solderable pins, you can still take advantage of the extra QWIIC connector to daisy-chain additional modules. @@ -115,40 +127,50 @@ Each Modulino includes two QWIIC connectors wired in parallel, allowing you to c This approach keeps your setup clean, modular, and expandable without adding extra wiring complexity. ![Modulino Wiring Options](assets/connection-guide-thermo-qwiic-chain.png) + ***The number of modules you can connect will depend on what modules you are chaining together, as this system allows for multiple sensors from different manufacturers to be added. Also, the cables you use for these connections will play a significant role in the setup’s performance. Ensure your cables are correctly connected and capable of handling the required data transfer. Each module should have a unique address on a chain if you plan to address them individually. Multiple modules with the same address will cause conflicts on the I²C bus.*** -# How To Program Your Modulino +## How To Program Your Modulino + +### Installing The Modulino Library -## Installing The Modulino Library To program your Modulino it is recommended you use the official ```Modulino``` micropython library available [here](https://github.com/arduino/arduino-modulino-mpy). The library is fully compatible with the no **Arduino Lab for MicroPython**. + For information on installing the **Arduino Lab for MicroPython** please visit our [page](https://docs.arduino.cc/micropython/first-steps/install-guide/). The ```Modulino``` library is not available by default on MicroPython devices hence installation is needed. + To simplify the process the [MicroPython Package Installer](https://github.com/arduino/lab-micropython-package-installer/releases) is recommended as it will provide a graphical interface to guide installation. + After installation, you should now be able to: 1. Open the tool. 2. Plug in your board to the computer. -![USB Connection](assets/mp-usb-connection.png) -If the board does not appear in the Detected Boards section, click Reload. If the board is still undetected, ensure no other programs (e.g., a code editor) are using the board's COM port. + ![USB Connection](assets/mp-usb-connection.png) + + If the board does not appear in the Detected Boards section, click Reload. If the board is still undetected, ensure no other programs (e.g., a code editor) are using the board's COM port. -4. Search for the ```Modulino``` package by filling in the text box on the search feature. -5. Click Install and wait for the installation confirmation. -6. Disconnect the board from the tool before returning to your code editor to avoid conflicts due to a busy COM port. +3. Search for the ```Modulino``` package by filling in the text box on the search feature. +4. Click Install and wait for the installation confirmation. +5. Disconnect the board from the tool before returning to your code editor to avoid conflicts due to a busy COM port. ![Package Installer Overview](assets/package-installer-overview.png) The module should now be includable in your program using: + ```from modulino import ModulinoThermo``` -## Get Temperature And Humidity Data +### Get Temperature And Humidity Data Getting data from the sensor is fairly simple using the ```Modulino``` library. + For the **Thermo** there are two crucial functions: + - ```.temperature``` - Provides the temperature measurement from the sensor. (Default in °C) - ```.relative_humidity``` - Provides the relative humidity from the sensor. (Default in %) + By default the Modulino library uses ```Wire1``` if your board model has a different pinout for the dedicated I²C pins you might have to edit it as instructed [here](https://github.com/arduino/arduino-modulino-mpy/tree/main/docs#%E2%84%B9%EF%B8%8F-using-3rd-party-boards). More information on **Wire** can be found [here](https://docs.arduino.cc/language-reference/en/functions/communication/wire/). Here is an example of how to implement these functions to acquire data: @@ -174,36 +196,38 @@ while True:     The code example provided shows how to initialize the sensor, read the data, and display it on the serial monitor. The data is updated every second, showing the current temperature and humidity values in real time. It can be easily adapted to trigger actions at certain temperature/humidity thresholds or to log data for analysis. -### Troubleshooting +## Troubleshooting - #### Sensor Not Reachable +### Sensor Not Reachable - If your Modulino's power LED isn't on or the sensor isn't responsive, first check that the board is properly connected: +If your Modulino's power LED isn't on or the sensor isn't responsive, first check that the board is properly connected: - - Ensure both the board and the Modulino are connected to your computer, and that the power LEDs on both are lit. - - If the issue persists, make sure the Qwiic cable is properly clicked into place. +- Ensure both the board and the Modulino are connected to your computer, and that the power LEDs on both are lit. +- If the issue persists, make sure the Qwiic cable is properly clicked into place. - #### Library Not Installed Properly +### Library Not Installed Properly - If you encounter an issue with the `#include "modulino.h"` command, verify that the Modulino library is correctly installed: - - Check your IDE to ensure the library is installed and up-to-date. - - Re-install the library through the Library Manager. +If you encounter an issue with the `#include "modulino.h"` command, verify that the Modulino library is correctly installed: + +- Check your IDE to ensure the library is installed and up-to-date. +- Re-install the library through the Library Manager. - #### Inaccurate Values +### Inaccurate Values If the sensor values are not accurate, make sure: + - The sensor is not placed near any components that might generate heat (like motors or power supplies). - All exposed electronics are not touching any conductive surfaces, as this could interfere with readings. -# What Is Next? +## Conclusion + +The **Modulino Thermo** is a digital temperature and humidity sensor that communicates over I²C and follows the Modulino form factor. It includes standard Qwiic connectors for quick, solderless connections and easy daisy-chaining with other modules. Paired with the Modulino library, it makes accessing sensor data straightforward, allowing you to focus on experimenting or building your system logic. It’s a small, reliable module suited for both quick tests and longer-term setups. + +## What Is Next? Now that you've learned how to use your Modulino Thermo, you're all set to integrate it into your projects! - Experiment with temperature and humidity. What happens if you place your Modulino in the refrigerator? - Try breathing near the sensor. Does the humidity change? - Place your Modulino on the outside of your mug and fill it with a hot beverage. Can you create an automatic system to know when your tea has cooled down? -- How does the temperature change throughout the day at home? Let your Modulino run for an entire day and check out the data! - -# Conclusion - -The **Modulino Thermo** is a digital temperature and humidity sensor that communicates over I²C and follows the Modulino form factor. It includes standard Qwiic connectors for quick, solderless connections and easy daisy-chaining with other modules. Paired with the Modulino library, it makes accessing sensor data straightforward, allowing you to focus on experimenting or building your system logic. It’s a small, reliable module suited for both quick tests and longer-term setups. \ No newline at end of file +- How does the temperature change throughout the day at home? Let your Modulino run for an entire day and check out the data! \ No newline at end of file