### Complete Modulino Initialization Example

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/configuration.md

Demonstrates global instance declaration and full configuration of multiple Modulino modules within the setup function.

```cpp
#include <Arduino_Modulino.h>

// Global instances
ModulinoHub hub;
ModulinoButtons buttons;
ModulinoJoystick joystick;
ModulinoMotors motors(200);  // 200 steps/rev stepper
ModulinoLEDMatrix matrix;

void setup() {
  Serial.begin(115200);
  
  // Initialize main Modulino I2C interface
  Modulino.begin();  // or Modulino.begin(Wire1) for alternate bus
  
  // Initialize modules without hub
  buttons.begin();
  joystick.begin();
  motors.begin();
  matrix.begin();
  
  // Configure modules
  motors.setStepperModeEnabled(true);
  motors.setStepsPerRevolution(200);
  motors.setFrequency(20000);
  motors.setDecay(DecayMode::MIXED_60_FAST_40_SLOW);
  
  joystick.setDeadZone(20);
  
  matrix.setMode(DisplayMode::MonochromaticVertical);
  
  Serial.println("All modules initialized");
}

void loop() {
  // Module polling...
}
```

--------------------------------

### ModulinoThermo Usage Example

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-sensors.md

Demonstrates basic setup and periodic reading of humidity and temperature data.

```cpp
ModulinoThermo thermo;

void setup() {
  Modulino.begin();
  thermo.begin();
}

void loop() {
  Serial.print("Humidity: ");
  Serial.print(thermo.getHumidity());
  Serial.print("% Temperature: ");
  Serial.print(thermo.getTemperature());
  Serial.println("°C");
  delay(1000);
}
```

--------------------------------

### begin()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-sensors.md

Initializes the distance sensor and starts continuous ranging.

```APIDOC
## bool begin()

### Description
Initializes the time-of-flight distance sensor, auto-detects the sensor model, and starts continuous ranging.

### Return Value
- **bool** - Returns true if the sensor was initialized successfully.
```

--------------------------------

### Initialize ModulinoLEDMatrix

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/docs/readme.md

Setup the LED matrix module.

```cpp
#include <Modulino_LED_Matrix.h>
// ...
ModulinoLEDMatrix matrix;
matrix.begin();
// Further matrix manipulation ...
```

--------------------------------

### Complete Usage Example

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-buttons.md

Demonstrates a full implementation including initialization, polling, and LED feedback.

```cpp
#include <Arduino_Modulino.h>

ModulinoButtons buttons;

void setup() {
  Serial.begin(115200);
  Modulino.begin();
  
  if (!buttons.begin()) {
    Serial.println("Buttons not found!");
    while (1);
  }
}

void loop() {
  if (buttons.update()) {
    // Update LED to match button state
    buttons.setLeds(
      buttons.isPressed('A'),
      buttons.isPressed('B'),
      buttons.isPressed('C')
    );
    
    Serial.print("Buttons: ");
    if (buttons.isPressed('A')) Serial.print("A ");
    if (buttons.isPressed('B')) Serial.print("B ");
    if (buttons.isPressed('C')) Serial.print("C ");
    Serial.println();
  }
  
  delay(50);
}
```

--------------------------------

### ModulinoPressure Usage Example

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-sensors.md

Demonstrates basic setup and periodic reading of barometric pressure and temperature data.

```cpp
ModulinoPressure pressure;

void setup() {
  Modulino.begin();
  pressure.begin();
}

void loop() {
  Serial.print("Pressure: ");
  Serial.print(pressure.getPressure());
  Serial.print(" hPa, Temperature: ");
  Serial.print(pressure.getTemperature());
  Serial.println("°C");
  delay(1000);
}
```

--------------------------------

### Full ModulinoOptoRelay Implementation

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-relays.md

Complete example demonstrating initialization and a toggling loop for the relay.

```cpp
ModulinoOptoRelay relay;

void setup() {
  Serial.begin(115200);
  Modulino.begin();
  
  if (!relay.begin()) {
    Serial.println("Relay not found!");
    while (1);
  }
  
  relay.off();  // Start with relay open
}

void loop() {
  // Toggle relay every 5 seconds
  relay.on();
  Serial.println("Relay ON");
  delay(5000);
  
  relay.off();
  Serial.println("Relay OFF");
  delay(5000);
}
```

--------------------------------

### Basic Hub Setup

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-hub.md

Initializes multiple modules connected to specific ports on a ModulinoHub.

```cpp
#include <Arduino_Modulino.h>

ModulinoHub hub;
ModulinoButtons buttons0;
ModulinoButtons buttons1;
ModulinoJoystick joystick0;

void setup() {
  Serial.begin(115200);
  Modulino.begin();
  
  // Initialize hub
  // Hub is at I2C address 0x70
  
  // Port 0: buttons module
  ModulinoHubPort* port0 = hub.port(0);
  buttons0 = ModulinoButtons(port0);
  buttons0.begin();
  
  // Port 1: joystick module
  ModulinoHubPort* port1 = hub.port(1);
  joystick0 = ModulinoJoystick(port1);
  joystick0.begin();
}

void loop() {
  if (buttons0.update()) {
    Serial.println("Buttons on port 0");
  }
  
  if (joystick0.update()) {
    Serial.println("Joystick on port 1");
  }
  
  delay(50);
}
```

--------------------------------

### Complete Usage Example

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-joystick.md

A full implementation demonstrating initialization, dead zone configuration, and polling the joystick state in a loop.

```cpp
#include <Arduino_Modulino.h>

ModulinoJoystick joystick;

void setup() {
  Serial.begin(115200);
  Modulino.begin();
  
  if (!joystick.begin()) {
    Serial.println("Joystick not found!");
    while (1);
  }
  
  joystick.setDeadZone(15);  // Configure dead zone
}

void loop() {
  if (joystick.update()) {
    int8_t x = joystick.getX();
    int8_t y = joystick.getY();
    bool pressed = joystick.isPressed();
    
    Serial.print("X=");
    Serial.print(x);
    Serial.print(" Y=");
    Serial.print(y);
    Serial.print(" Button=");
    Serial.println(pressed ? "PRESSED" : "RELEASED");
  }
  
  delay(50);
}
```

--------------------------------

### Usage Example for begin()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-class.md

Demonstrates initializing the Modulino singleton using either the default Wire interface or a secondary Wire1 interface.

```cpp
void setup() {
  Modulino.begin();  // Use default Wire
  // or
  Modulino.begin(Wire1);  // Use Wire1
}
```

--------------------------------

### Initialize Generic Modulino Module

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/docs/readme.md

Basic setup pattern for any Modulino module.

```cpp
ModulinoType modulino_name;
modulino_name.begin();  // Initialize the ModulinoType module
```

--------------------------------

### Relay Control Example

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-relays.md

Demonstrates basic usage of the set and reset methods with a delay.

```cpp
latchRelay.set();   // Turn on and stay on
delay(10000);
latchRelay.reset(); // Turn off
```

--------------------------------

### ModulinoLight Usage Example

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-sensors.md

Demonstrates basic initialization and periodic reading of light sensor data.

```cpp
ModulinoLight light;

void setup() {
  Modulino.begin();
  light.begin();
}

void loop() {
  if (light.update()) {
    ModulinoColor color = light.getColor();
    Serial.print("Color: ");
    Serial.println(light.getColorApproximate());
    Serial.print("Lux: ");
    Serial.println(light.getLux());
  }
  delay(500);
}
```

--------------------------------

### Complete ModulinoPixels Usage Example

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-pixels.md

Demonstrates initializing the pixels, setting colors, and creating animation effects.

```cpp
#include <Arduino_Modulino.h>

ModulinoPixels pixels;

void setup() {
  Serial.begin(115200);
  Modulino.begin();
  
  if (!pixels.begin()) {
    Serial.println("Pixels not found!");
    while (1);
  }
  
  pixels.clear();
  pixels.show();
}

void loop() {
  // Rainbow effect
  pixels.set(0, RED, 50);
  pixels.set(1, 255, 165, 0, 50);  // Orange
  pixels.set(2, YELLOW, 50);
  pixels.set(3, GREEN, 50);
  pixels.set(4, BLUE, 50);
  pixels.set(5, 75, 0, 130, 50);   // Indigo
  pixels.set(6, 148, 0, 211, 50);  // Violet
  pixels.set(7, WHITE, 50);
  pixels.show();
  
  delay(1000);
  
  // Fade effect
  for (int brightness = 0; brightness <= 100; brightness += 10) {
    pixels.clear();
    pixels.set(0, RED, brightness);
    pixels.show();
    delay(100);
  }
  
  delay(500);
}
```

--------------------------------

### ModulinoMovement Usage Example

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-sensors.md

Demonstrates the standard workflow of initializing the sensor and reading data within the loop.

```cpp
ModulinoMovement movement;

void setup() {
  Modulino.begin();
  movement.begin();
}

void loop() {
  if (movement.available()) {
    movement.update();
    Serial.print("Accel X: ");
    Serial.print(movement.getX());
    Serial.print(" Y: ");
    Serial.print(movement.getY());
    Serial.print(" Z: ");
    Serial.println(movement.getZ());
  }
}
```

--------------------------------

### Relay Operation Example

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-relays.md

Basic usage of the on() and off() methods with a delay.

```cpp
relay.on();   // Closes switch
delay(5000);  // Keep closed for 5 seconds
relay.off();  // Opens switch
```

--------------------------------

### ModulinoColor Usage Example

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/types.md

Demonstrates initializing colors and applying them to pixels using objects, constants, or raw RGB values.

```cpp
ModulinoColor red(255, 0, 0);
ModulinoColor custom(100, 50, 200);

ModulinoPixels pixels;
pixels.set(0, red, 50);          // Using custom color
pixels.set(1, RED, 75);          // Using predefined constant
pixels.set(2, 200, 100, 50, 60); // Using RGB values directly
pixels.show();
```

--------------------------------

### get()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-knob.md

Reads the current position of the knob.

```APIDOC
## int16_t get()

### Description
Reads the current position of the knob. Returns the 16-bit position value or 0 if the read fails.
```

--------------------------------

### Complete ModulinoBuzzer Usage

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-buzzer.md

A full example demonstrating initialization, melody playback, and sound effects using the ModulinoBuzzer library.

```cpp
#include <Arduino_Modulino.h>

ModulinoBuzzer buzzer;

void setup() {
  Serial.begin(115200);
  Modulino.begin();
  
  if (!buzzer.begin()) {
    Serial.println("Buzzer not found!");
    while (1);
  }
}

void loop() {
  // Play a simple melody
  int notes[] = {262, 294, 330, 349, 392, 440, 494, 523};
  
  for (int note : notes) {
    buzzer.tone(note, 250);  // Play each note for 250 ms
    delay(300);              // 50 ms gap between notes
  }
  
  // Buzz effect
  for (int i = 0; i < 5; i++) {
    buzzer.tone(1000, 100);
    delay(150);
  }
  
  delay(2000);
}
```

--------------------------------

### Full Modulino Latch Relay Implementation

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-relays.md

Complete example showing initialization, state toggling, and status checking in an Arduino sketch.

```cpp
ModulinoLatchRelay latchRelay;

void setup() {
  Serial.begin(115200);
  Modulino.begin();
  
  if (!latchRelay.begin()) {
    Serial.println("Latch Relay not found!");
    while (1);
  }
}

void loop() {
  // This state is maintained even after power loss
  latchRelay.set();
  Serial.println("Latch Relay SET (on)");
  delay(5000);
  
  latchRelay.reset();
  Serial.println("Latch Relay RESET (off)");
  delay(5000);
  
  // Check status
  int status = latchRelay.getStatus();
  switch (status) {
    case 1:
      Serial.println("Relay is ON");
      break;
    case 0:
      Serial.println("Relay is OFF");
      break;
    case -1:
      Serial.println("Relay state unknown");
      break;
  }
}
```

--------------------------------

### ModulinoDistance Usage Example

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-sensors.md

Demonstrates a standard loop that checks for new distance data and prints it to the serial monitor.

```cpp
ModulinoDistance distance;

void setup() {
  Modulino.begin();
  distance.begin();
}

void loop() {
  if (distance.available()) {
    float dist = distance.get();
    if (!isnan(dist)) {
      Serial.print("Distance: ");
      Serial.print(dist);
      Serial.println(" mm");
    }
  }
  delay(100);
}
```

--------------------------------

### Initialize Modules with Hub Ports

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-hub.md

Example constructors for Modulino modules accepting an optional ModulinoHubPort parameter for automatic I2C bus management.

```cpp
ModulinoButtons(uint8_t address = 0xFF, ModulinoHubPort* hubPort = nullptr)
ModulinoJoystick(ModulinoHubPort* hubPort, uint8_t address = 0xFF)
// etc.
```

--------------------------------

### Retrieve Light Intensity

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-sensors.md

Methods to get ambient light, lux, and infrared readings.

```cpp
int getAL()
int getLux()
```

```cpp
int getIR()
```

--------------------------------

### Haptic Feedback Patterns

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-vibro.md

Examples of common haptic feedback sequences using blocking calls for sequential execution.

```cpp
// Confirmation feedback
vibro.on(100, true, MAXIMUM);
delay(100);
vibro.on(100, true, MAXIMUM);

// Warning pattern
for (int i = 0; i < 3; i++) {
  vibro.on(200, true, INTENSE);
  delay(150);
}

// Long notification
vibro.on(800, true, MODERATE);

// Pulse pattern
for (int i = 0; i < 5; i++) {
  vibro.on(50, true, POWERFUL);
  delay(100);
}
```

--------------------------------

### begin()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-sensors.md

Initializes the light sensor hardware.

```APIDOC
## bool begin()

### Description
Initializes the light sensor.

### Returns
- **bool** - true if initialized successfully.
```

--------------------------------

### Detect I2C Bus Jam

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/errors.md

Perform a quick I2C scan during setup to verify the bus is responsive before starting operations.

```cpp
void setup() {
  Modulino.begin();
  
  // Quick I2C scan to verify bus is alive
  bool busOK = false;
  for (uint8_t i = 0x08; i < 0x78; i++) {
    Wire.beginTransmission(i);
    if (Wire.endTransmission() == 0) {
      busOK = true;
      break;
    }
  }
  
  if (!busOK) {
    Serial.println("ERROR: I2C bus not responding");
    while (1);
  }
}
```

--------------------------------

### begin()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/module-base-class.md

Initializes the module and performs address discovery if necessary.

```APIDOC
## begin()

### Description
Initializes the module and discovers its address if necessary. Returns true if the module is successfully discovered or initialized, false otherwise.
```

--------------------------------

### get()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-sensors.md

Retrieves the latest distance measurement.

```APIDOC
## float get()

### Description
Returns the last measured distance in millimeters.

### Return Value
- **float** - The distance in mm, or NaN if the measurement failed or the sensor is not initialized.
```

--------------------------------

### begin()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-knob.md

Initializes the knob module and performs calibration.

```APIDOC
## bool begin()

### Description
Initializes the knob module and performs calibration. Returns true if successful, false otherwise.
```

--------------------------------

### begin()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-led-matrix.md

Initializes I2C communication with the LED matrix. Returns 1 on success, 0 on failure.

```APIDOC
## int begin()

### Description
Initializes I2C communication with the LED matrix. Returns 1 if initialization is successful, or 0 if it failed or was already initialized.

### Return Type
int

### Example
```cpp
ModulinoLEDMatrix matrix;
if (matrix.begin()) {
  Serial.println("Matrix initialized");
}
```
```

--------------------------------

### setStepsPerRevolution() / stepsPerRevolution()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-motors.md

Gets or sets the motor full-step resolution.

```APIDOC
## int16_t stepsPerRevolution() / bool setStepsPerRevolution(int16_t value)

### Description
Gets or sets the motor full-step resolution.

### Parameters
- **value** (int16_t) - Required (setter) - Steps per rotation (>= 1)

### Return Type
- **Getter**: int16_t
- **Setter**: bool (true if value valid >= 1, false otherwise)
```

--------------------------------

### Get Hub Address

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-hub.md

Returns the configured I2C address of the hub device.

```cpp
int address()
```

--------------------------------

### Initialize Modulino Library

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/docs/readme.md

Include the header and call begin() to set up I2C communication.

```cpp
#include <Arduino_Modulino.h>
Modulino.begin();  // Initialize the Modulino library
```

--------------------------------

### Get Relay Status

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-relays.md

Methods to retrieve or refresh the current relay state.

```cpp
bool getStatus()
```

```cpp
bool update()
```

--------------------------------

### Initializing the Modulino Library

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/configuration.md

Use the begin method to initialize the library with either the default Wire interface or an alternate Wire instance.

```cpp
void setup() {
  Modulino.begin();  // Use default Wire interface
  // or
  Modulino.begin(Wire1);  // Use alternate Wire1 interface
}
```

--------------------------------

### show()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-pixels.md

Updates the hardware module with the current LED state.

```APIDOC
## show()

### Description
Transmits all 8 LED color/brightness values via I2C to the module. This must be called for set() or clear() changes to take effect.
```

--------------------------------

### Initialize and animate the Modulino LED Matrix

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-led-matrix.md

Demonstrates basic library initialization and alternating frame display using the MonochromaticVertical mode.

```cpp
#include <Arduino_Modulino.h>
#include <Modulino_LED_Matrix.h>

ModulinoLEDMatrix matrix;

void setup() {
  Serial.begin(115200);
  Modulino.begin();
  
  if (!matrix.begin()) {
    Serial.println("Matrix not found!");
    while (1);
  }
  
  matrix.setMode(DisplayMode::MonochromaticVertical);
  matrix.clear();
}

void loop() {
  // Simple frame: left half on, right half off
  const uint8_t frame1[12] = {
    0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
    0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00
  };
  
  const uint8_t frame2[12] = {
    0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00,
    0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00
  };
  
  matrix.setFrame(frame1);
  delay(500);
  
  matrix.setFrame(frame2);
  delay(500);
}
```

--------------------------------

### Retrieve Color Data

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-sensors.md

Methods to get the detected RGB color or a human-readable color approximation.

```cpp
ModulinoColor getColor()
```

```cpp
String getColorApproximate()
```

--------------------------------

### Get Y-Axis Position

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-joystick.md

Retrieves the cached Y-axis position as a signed value between -127 and 127.

```cpp
int8_t getY()
```

```cpp
if (joystick.getY() > 50) {
  Serial.println("Push down!");
}
```

--------------------------------

### Get X-Axis Position

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-joystick.md

Retrieves the cached X-axis position as a signed value between -127 and 127.

```cpp
int8_t getX()
```

```cpp
if (joystick.getX() < -50) {
  Serial.println("Push left!");
}
```

--------------------------------

### Modulino.begin()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-class.md

Initializes the I2C interface and configures Modulino communication settings, including clock speed and platform-specific bus handling.

```APIDOC
## void begin(HardwareI2C& wire = Wire)

### Description
Initializes the I2C interface and configures Modulino communication. This method must be called before any module operations.

### Parameters
- **wire** (HardwareI2C&) - Optional - Reference to the I2C interface to use. Defaults to Wire (or Wire1 on specific boards like UNO R4 WiFi).

### Behavior
- Calls `begin()` on the provided Wire object.
- Sets I2C clock to 100 kHz.
- Increases I2C interrupt priority on UNO R4 WiFi.
- Performs bus unlock on UNO R4 WiFi by toggling SCL pin 20 times.

### Example
```cpp
void setup() {
  Modulino.begin();  // Use default Wire
}
```
```

--------------------------------

### Configure I2C Interface with begin()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-class.md

Initializes the I2C bus and configures communication parameters. Must be called before performing any module operations.

```cpp
void begin(HardwareI2C& wire = Wire)
// or Wire1 on UNO R4 WiFi, Nano R4, and UNO Q boards
```

--------------------------------

### Initialize and Discover Module

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/module-base-class.md

Initializes the module and performs auto-discovery if the address is not set. Returns true if the module is successfully ready for use.

```cpp
bool begin()
```

```cpp
ModulinoButtons buttons;
if (buttons.begin()) {
  // Module found and ready
}
```

--------------------------------

### Get Relay Status

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-relays.md

Returns the cached relay state. Returns 1 for ON, 0 for OFF, or -1 if the state is unknown.

```cpp
int getStatus()
```

--------------------------------

### Manage Steps Per Revolution

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-motors.md

Gets or sets the motor full-step resolution. The setter returns true if the value is valid.

```cpp
int16_t stepsPerRevolution() const
bool setStepsPerRevolution(int16_t value)
```

```cpp
motors.setStepsPerRevolution(200);
if (motors.stepsPerRevolution() > 0) {
  motors.moveStepperRpm(400, 30.0);
}
```

--------------------------------

### Initialize Module Instance

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/module-base-class.md

Constructor for creating a Module instance with an optional I2C address and hub port configuration.

```cpp
Module(uint8_t address = 0xFF, const char* name = "", ModulinoHubPort* hubPort = nullptr)
```

--------------------------------

### Initialize Module with Hub

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/README.md

Connects a module to a specific hub port and initializes the device.

```cpp
ModulinoHub hub;
ModulinoHubPort* port0 = hub.port(0);
ModulinoButtons buttons(port0);
buttons.begin();
```

--------------------------------

### Dynamic Hub Selection

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-hub.md

Demonstrates initializing and polling multiple modules across different hub ports using loops.

```cpp
ModulinoHub hub;

// Array of modules on different hub ports
ModulinoButtons buttons[4];
ModulinoJoystick joysticks[4];

void setup() {
  Modulino.begin();
  
  // Initialize 4 buttons modules on ports 0-3
  for (int i = 0; i < 4; i++) {
    ModulinoHubPort* port = hub.port(i);
    buttons[i] = ModulinoButtons(port);
    buttons[i].begin();
  }
  
  // Initialize 4 joystick modules on ports 4-7
  for (int i = 0; i < 4; i++) {
    ModulinoHubPort* port = hub.port(4 + i);
    joysticks[i] = ModulinoJoystick(port);
    joysticks[i].begin();
  }
}

void loop() {
  // Poll all buttons
  for (int i = 0; i < 4; i++) {
    if (buttons[i].update()) {
      Serial.print("Buttons ");
      Serial.print(i);
      Serial.println(" changed");
    }
  }
  
  // Poll all joysticks
  for (int i = 0; i < 4; i++) {
    if (joysticks[i].update()) {
      Serial.print("Joystick ");
      Serial.print(i);
      Serial.println(" moved");
    }
  }
  
  delay(50);
}
```

--------------------------------

### Initialize and use Modulino Knob

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-knob.md

Demonstrates the complete lifecycle of the Modulino Knob, including initialization, direction polling, and button press handling.

```cpp
#include <Arduino_Modulino.h>

ModulinoKnob knob;

void setup() {
  Serial.begin(115200);
  Modulino.begin();
  
  if (!knob.begin()) {
    Serial.println("Knob not found!");
    while (1);
  }
  
  knob.set(0);  // Reset to 0
}

void loop() {
  // Check for direction change with debouncing
  int8_t dir = knob.getDirection();
  if (dir != 0) {
    int16_t pos = knob.get();
    Serial.print("Position: ");
    Serial.print(pos);
    Serial.print(" Direction: ");
    Serial.println(dir == 1 ? "CW" : "CCW");
  }
  
  // Check button
  if (knob.isPressed()) {
    Serial.println("Button pressed!");
    knob.set(0);  // Reset position on button press
  }
  
  delay(50);
}
```

--------------------------------

### Initialize Modulino Modules Correctly

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/errors.md

Always call Modulino.begin() before initializing individual modules to ensure the I2C bus is ready.

```cpp
// Wrong:
ModulinoButtons buttons;
buttons.begin();  // Will fail: I2C not initialized

// Correct:
void setup() {
  Modulino.begin();  // Initialize I2C first
  buttons.begin();   // Now safe
}
```

--------------------------------

### Handle Module Initialization Failure

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/errors.md

Check the boolean result of the begin() method to verify if a module is accessible on the I2C bus.

```cpp
ModulinoButtons buttons;
if (!buttons.begin()) {
  Serial.println("ERROR: Buttons module not found!");
  // Module not accessible on I2C bus
}
```

--------------------------------

### Initialize ModulinoOptoRelay

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-relays.md

Constructors for the ModulinoOptoRelay class using I2C address or hub port.

```cpp
ModulinoOptoRelay(uint8_t address = 0xFF, ModulinoHubPort* hubPort = nullptr)
// or
ModulinoOptoRelay(ModulinoHubPort* hubPort, uint8_t address = 0xFF)
```

--------------------------------

### Initialize Module with Auto-Discovery

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/configuration.md

Use address 0xFF to trigger automatic I2C address discovery for compatible modules.

```cpp
ModulinoButtons buttons(0xFF);  // Auto-discover
if (buttons.begin()) {
  // Module found and initialized
}
```

--------------------------------

### Check Initialization Status

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/errors.md

Verify that all modules initialize successfully before proceeding with the main program loop.

```cpp
bool initializationOK = true;

if (!buttons.begin()) {
  Serial.println("Buttons not found");
  initializationOK = false;
}

if (!joystick.begin()) {
  Serial.println("Joystick not found");
  initializationOK = false;
}

if (!initializationOK) {
  while (1) {
    Serial.println("Fix hardware and restart");
    delay(1000);
  }
}
```

--------------------------------

### Display LED Matrix Animation

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/README.md

Initializes the LED matrix and plays a predefined animation sequence once.

```cpp
ModulinoLEDMatrix matrix;
matrix.begin();
matrix.setSequence(animationFrames);
matrix.play(false);  // Play once
```

--------------------------------

### Initialize Module with Manual Address

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/configuration.md

Specify a custom I2C address directly in the constructor if the module is not at the default discovery address.

```cpp
// Create module at specific I2C address (if not at auto-discovery address)
ModulinoButtons buttons(0x3E);  // Use address 0x3E directly
if (buttons.begin()) {
  // Module at custom address initialized
}
```

--------------------------------

### Initialize ModulinoKnob

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-knob.md

Initializes the knob module and performs calibration. Returns true on success.

```cpp
ModulinoKnob knob;
if (knob.begin()) {
  Serial.println("Knob initialized");
}
```

--------------------------------

### ModulinoThermo Methods

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-sensors.md

Methods for initializing the sensor and retrieving humidity and temperature readings.

```cpp
bool begin()
```

```cpp
float getHumidity()
```

```cpp
float getTemperature()
```

--------------------------------

### Module Constructor

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/module-base-class.md

Initializes a new Module instance for a Modulino device.

```APIDOC
## Constructor

### Signature
`Module(uint8_t address = 0xFF, const char* name = "", ModulinoHubPort* hubPort = nullptr)`

### Parameters
- **address** (uint8_t) - Optional - I2C address of the module (0xFF triggers auto-discovery)
- **name** (const char*) - Optional - Human-readable name for the module
- **hubPort** (ModulinoHubPort*) - Optional - Optional hub port selector for multiplexed configurations
```

--------------------------------

### Initialize the LED Matrix

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-led-matrix.md

Initializes I2C communication. Returns 1 on success, 0 on failure.

```cpp
ModulinoLEDMatrix matrix;
if (matrix.begin()) {
  Serial.println("Matrix initialized");
}
```

--------------------------------

### release()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-motors.md

Releases stepper coils with minimal delay.

```APIDOC
## bool release()

### Description
Releases holding torque after current move with a minimum 1 ms delay.

### Returns
- **bool** - true on successful write
```

--------------------------------

### Manage State with LatchRelay

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-relays.md

Demonstrates maintaining power states using a latching relay, including status checking and resetting to a safe default state.

```cpp
// Maintain power state with minimal current draw
ModulinoLatchRelay systemRelay;

void setup() {
  Modulino.begin();
  systemRelay.begin();
  
  int status = systemRelay.getStatus();
  if (status == -1) {
    systemRelay.reset();  // Safe default for unknown state
  }
}

void powerDown() {
  systemRelay.reset();  // Turns off, stays off without power
}

void powerUp() {
  systemRelay.set();   // Turns on, stays on without power
}
```

--------------------------------

### Initialize Modulino Modules

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/README.md

Standard pattern for initializing the I2C bus and individual modules, followed by a polling loop to handle device updates.

```cpp
#include <Arduino_Modulino.h>

void setup() {
  // 1. Initialize main I2C interface
  Modulino.begin();
  
  // 2. Create module instances
  ModulinoButtons buttons;
  ModulinoJoystick joystick;
  
  // 3. Initialize each module
  buttons.begin();
  joystick.begin();
}

void loop() {
  // 4. Poll modules for updates
  if (buttons.update()) {
    // Handle button changes
  }
  
  if (joystick.update()) {
    // Handle joystick movement
  }
  
  delay(50);
}
```

--------------------------------

### Initialize Modulino on Standard Arduino Boards

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/configuration.md

Uses the default Wire interface for standard boards like UNO, Nano, and Mega.

```cpp
void setup() {
  Modulino.begin();  // Uses Wire by default
  // Standard initialization:
  // 1. Initializes Wire interface
  // 2. Sets I2C clock to 100 kHz
}
```

--------------------------------

### discover()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/module-base-class.md

Scans the I2C bus to locate the module.

```APIDOC
## discover()

### Description
Scans I2C bus to locate the module at known addresses. Returns the I2C address found (address × 2) or 0xFF if not found.
```

--------------------------------

### Initialize ModulinoButtons

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-buttons.md

Constructs a new instance of the ModulinoButtons module, optionally specifying an I2C address or hub port.

```cpp
ModulinoButtons(uint8_t address = 0xFF, ModulinoHubPort* hubPort = nullptr)
// or
ModulinoButtons(ModulinoHubPort* hubPort, uint8_t address = 0xFF)
```

--------------------------------

### play()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-led-matrix.md

Plays the current sequence with optional looping behavior.

```APIDOC
## void play(bool looping = false)

### Description
Plays the current sequence. This is a blocking function that does not return until the sequence completes or looping is active.

### Parameters
- **looping** (bool) - Optional - If true, loops indefinitely; if false, plays once
```

--------------------------------

### ModulinoButtons Constructor

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-buttons.md

Initializes a new instance of the ModulinoButtons module.

```APIDOC
## ModulinoButtons(uint8_t address, ModulinoHubPort* hubPort)

### Description
Creates a new instance of the Buttons module. The address can be auto-discovered if set to 0xFF.

### Parameters
- **address** (uint8_t) - Optional - I2C address (default: 0xFF)
- **hubPort** (ModulinoHubPort*) - Optional - Hub port selector (default: nullptr)
```

--------------------------------

### set()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-pixels.md

Sets the color and brightness of a single LED.

```APIDOC
## set(int idx, ModulinoColor rgb, uint8_t brightness)

### Description
Sets the color and brightness of a single LED using a ModulinoColor object.

### Parameters
- **idx** (int) - Required - LED index (0-7)
- **rgb** (ModulinoColor) - Required - Color object
- **brightness** (uint8_t) - Optional - Brightness (0-100, default 25)

## set(int idx, uint8_t r, uint8_t g, uint8_t b, uint8_t brightness)

### Description
Sets the color of a single LED using individual RGB components.

### Parameters
- **idx** (int) - Required - LED index (0-7)
- **r** (uint8_t) - Required - Red component (0-255)
- **g** (uint8_t) - Required - Green component (0-255)
- **b** (uint8_t) - Required - Blue component (0-255)
- **brightness** (uint8_t) - Optional - Brightness (0-100, default 5)
```

--------------------------------

### Initialize ModulinoDistance

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-sensors.md

Constructs a new ModulinoDistance instance, optionally specifying a hub port.

```cpp
ModulinoDistance(ModulinoHubPort* hubPort = nullptr)
```

--------------------------------

### Initialize ModulinoVibro

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-vibro.md

Constructs a new instance of the Vibro module, optionally specifying an I2C address or hub port.

```cpp
ModulinoVibro(uint8_t address = 0xFF, ModulinoHubPort* hubPort = nullptr)
// or
ModulinoVibro(ModulinoHubPort* hubPort, uint8_t address = 0xFF)
```

--------------------------------

### Initialize ModulinoMovement Sensor

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-sensors.md

Initializes the IMU sensor hardware.

```cpp
bool begin()
```

--------------------------------

### ModulinoMovement Methods

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-sensors.md

Methods for initializing the sensor, updating data, and checking availability.

```APIDOC
## begin()

### Description
Initializes the IMU sensor.

### Return Type
- **bool** - true if sensor initialized successfully.

## update()

### Description
Reads acceleration and gyroscope data from the sensor and updates cached values.

### Return Type
- **int** - Non-zero if both acceleration and gyroscope reads succeed, 0 otherwise.

## available()

### Description
Checks if new acceleration and gyroscope data is available.

### Return Type
- **int** - Non-zero if data ready, 0 if not.
```

--------------------------------

### getAL(), getLux(), getIR()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-sensors.md

Retrieves ambient light and infrared measurements.

```APIDOC
## int getAL(), int getLux(), int getIR()

### Description
Returns ambient light and infrared light levels.

### Returns
- **int** - getAL() returns raw counts, getLux() returns illuminance in lux, getIR() returns IR counts.
```

--------------------------------

### ModulinoLight Constructor

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-sensors.md

Initializes the ModulinoLight instance, optionally specifying a hub port.

```cpp
ModulinoLight(ModulinoHubPort* hubPort = nullptr)
```

--------------------------------

### Handle Hub Port Initialization Failure

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/errors.md

Validate hub port numbers and check for hub responsiveness when initializing modules via a hub.

```cpp
ModulinoHubPort* port = hub.port(8);  // Invalid port > 7
ModulinoButtons buttons(port);
if (!buttons.begin()) {
  Serial.println("ERROR: Invalid hub port or hub not responding");
}
```

--------------------------------

### Handle ModulinoLEDMatrix initialization and sequence errors

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/errors.md

Verify matrix initialization and ensure a frame sequence is loaded before operation.

```cpp
if (!matrix.begin()) {
  Serial.println("ERROR: LED Matrix not found or not responding");
}
```

```cpp
if (matrix.getFrameCount() == 0) {
  Serial.println("WARNING: No frame sequence loaded");
}
```

--------------------------------

### Implement Graceful Degradation

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/errors.md

Use module update return values to handle hardware failures without crashing the entire application.

```cpp
void loop() {
  bool buttonsOK = buttons.update();
  bool joystickOK = joystick.update();
  
  if (buttonsOK) {
    handleButtons();
  } else {
    // Fall back to joystick or defaults
    Serial.println("Buttons not responding, using joystick");
  }
  
  if (joystickOK) {
    handleJoystick();
  }
}
```

--------------------------------

### ModulinoKnob Constructor

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-knob.md

Creates an instance of the ModulinoKnob module.

```APIDOC
## ModulinoKnob(uint8_t address, ModulinoHubPort* hubPort)

### Description
Creates a new ModulinoKnob instance. The address defaults to 0xFF for auto-discovery.

### Parameters
- **address** (uint8_t) - Optional - I2C address (auto-discover if 0xFF)
- **hubPort** (ModulinoHubPort*) - Optional - Optional hub port selector
```

--------------------------------

### ModulinoPressure Methods

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-sensors.md

Methods for initializing the barometric pressure sensor and retrieving pressure and temperature readings.

```cpp
bool begin()
```

```cpp
float getPressure()
```

```cpp
float getTemperature()
```

--------------------------------

### Complete Modulino Vibro Usage

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-vibro.md

Demonstrates full initialization and various vibration patterns including pulses, ramps, and non-blocking operation.

```cpp
#include <Arduino_Modulino.h>

ModulinoVibro vibro;

void setup() {
  Serial.begin(115200);
  Modulino.begin();
  
  if (!vibro.begin()) {
    Serial.println("Vibro not found!");
    while (1);
  }
}

void loop() {
  // Simple notification pattern
  vibro.on(50, true, MEDIUM);   // Short medium pulse
  delay(100);
  vibro.on(50, true, MEDIUM);   // Repeat once
  delay(500);
  
  // Ramp up intensity
  vibro.on(100, true, GENTLE);
  delay(50);
  vibro.on(100, true, MODERATE);
  delay(50);
  vibro.on(100, true, MAXIMUM);
  delay(1000);
  
  // Non-blocking pattern with custom power
  vibro.on(500, false, 35);
  Serial.println("Vibrating...");
  delay(600);
  
  delay(2000);
}
```

--------------------------------

### Implement menu navigation with knob

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-knob.md

Uses knob rotation to cycle through menu indices and the button press to trigger selection.

```cpp
void loop() {
  int8_t dir = knob.getDirection();
  if (dir != 0) {
    if (dir == 1) {
      menuIndex++;  // Next menu item
      if (menuIndex >= MENU_ITEMS) menuIndex = 0;
    } else {
      menuIndex--;  // Previous menu item
      if (menuIndex < 0) menuIndex = MENU_ITEMS - 1;
    }
    displayMenu();
  }
  
  if (knob.isPressed()) {
    selectMenuItem();
  }
}
```

--------------------------------

### Initialize ModulinoLEDMatrix

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-led-matrix.md

Constructs the LED matrix object using the I2C address, wire interface, and display mode.

```cpp
ModulinoLEDMatrix(uint8_t address = DEFAULT_ADDRESS, HardwareI2C& wire = DEFAULT_WIRE, DisplayMode mode = DisplayMode::Default)
// or
ModulinoLEDMatrix(HardwareI2C& wire, uint8_t address = DEFAULT_ADDRESS, DisplayMode mode = DisplayMode::Default)
```

--------------------------------

### write()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/module-base-class.md

Sends command data to the module via I2C.

```APIDOC
## write()

### Parameters
- **buf** (uint8_t*) - Required - Buffer containing command bytes
- **howmany** (int) - Required - Number of bytes to write

### Description
Sends command data to the module via I2C. Returns true if data successfully sent, false if module not initialized.
```

--------------------------------

### Assign Modules to Hub Ports

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/configuration.md

Modules can be initialized with a hub port reference using either parameter order.

```cpp
// Constructor with hub port
ModulinoButtons buttons(0xFF, hubPort);
ModulinoButtons buttons(hubPort, 0xFF);  // Alternative parameter order
```

--------------------------------

### Configure LED Matrix Frame Sequence

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/configuration.md

Sets an animation sequence and manages frame rendering and progression.

```cpp
const uint8_t animation[...] = { ... };
matrix.setSequence(animation, sizeof(animation));

matrix.renderFrame(0);   // Display frame 0
matrix.nextFrame();      // Advance to next frame
delay(matrix.getCurrentDuration());
```

--------------------------------

### on()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-vibro.md

Triggers vibration on the module with options for duration, blocking behavior, and power intensity.

```APIDOC
## void on(size_t len_ms, bool block, int power)

### Description
Activates the vibration motor. Can be used in blocking or non-blocking modes with specific power levels.

### Parameters
- **len_ms** (size_t) - Required - Duration of vibration in milliseconds.
- **block** (bool) - Required - If true, execution pauses for the duration; if false, returns immediately.
- **power** (int) - Optional - Vibration intensity from 0 to 50 (default: MAXIMUM/50).
```

--------------------------------

### Initialize Modulino on Arduino UNO R4 WiFi

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/configuration.md

Uses Wire1 by default and performs automatic bus recovery and clock configuration.

```cpp
// Special handling for Wire1 bus unlock
void setup() {
  Modulino.begin(Wire1);  // Uses Wire1 by default
  // Library automatically:
  // 1. Toggles SCL pin 20 times for bus recovery
  // 2. Sets I2C clock to 100 kHz
  // 3. Configures interrupt priorities
}
```

--------------------------------

### update()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-buttons.md

Synchronizes the local state with the physical module.

```APIDOC
## update()

### Description
Reads button states from the module and caches them for isPressed() queries.

### Return Type
- **bool** - Returns true if any button state changed since the last update.
```

--------------------------------

### setSequence()

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-led-matrix.md

Configures the frame sequence for the LED matrix using raw pointers or 2D arrays.

```APIDOC
## void setSequence(const uint8_t* frames, size_t bytes, bool is32Bit = false)

### Description
Sets a frame sequence from a raw pointer and byte count.

### Parameters
- **frames** (const uint8_t*) - Required - Pointer to frame data
- **bytes** (size_t) - Required - Total data size in bytes
- **is32Bit** (bool) - Optional - True if data is 32-bit format, false for 8-bit

## void setSequence(const uint32_t (&frames)[N][M])

### Description
Sets a sequence from a 2D array of 32-bit values.

### Parameters
- **frames** (const uint32_t (&)[N][M]) - Required - 2D array of frame data

## void setSequence(const uint8_t (&frames)[N][M], size_t usedBytes)

### Description
Sets a sequence from a 2D array of 8-bit values.

### Parameters
- **frames** (const uint8_t (&)[N][M]) - Required - 2D array of frame data
- **usedBytes** (size_t) - Optional - Actual data size if smaller than array
```

--------------------------------

### Configure Motor with RPM Control

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/README.md

Sets up a motor with a defined step count and executes a movement at a specific RPM.

```cpp
ModulinoMotors motors(200);  // 200 steps/rev
motors.begin();
motors.setStepperModeEnabled(true);
motors.moveStepperRpm(400, 30.0);  // 400 steps at 30 RPM
```

--------------------------------

### ModulinoPixels Methods

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-pixels.md

Methods for interacting with the ModulinoPixels hardware, including initialization, clearing the buffer, setting pixel values, and pushing updates to the hardware.

```APIDOC
## pixels.begin()

### Description
Initializes the ModulinoPixels hardware. Returns true if successful.

## pixels.clear()

### Description
Clears the current pixel buffer.

## pixels.show()

### Description
Updates the physical LEDs with the current buffer data.

## pixels.set(index, color, brightness)

### Description
Sets a specific pixel at the given index to a predefined ModulinoColor with a specified brightness.

## pixels.set(index, r, g, b, brightness)

### Description
Sets a specific pixel at the given index to an RGB color with a specified brightness.
```

--------------------------------

### ModulinoThermo Constructor

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-sensors.md

Initializes the ModulinoThermo object, optionally specifying a hub port.

```cpp
ModulinoThermo(ModulinoHubPort* hubPort = nullptr)
```

--------------------------------

### Initialize ModulinoJoystick

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-joystick.md

Constructors for creating a new joystick instance, supporting optional I2C address and hub port configuration.

```cpp
ModulinoJoystick(uint8_t address = 0xFF, ModulinoHubPort* hubPort = nullptr)
// or
ModulinoJoystick(ModulinoHubPort* hubPort, uint8_t address = 0xFF)
```

--------------------------------

### Initialize I2C Bus

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/README.md

Configures the I2C communication bus. Use the default Wire bus or specify an alternate bus like Wire1.

```cpp
Modulino.begin();              // Use default Wire
Modulino.begin(Wire1);         // Use alternate Wire1 bus
```

--------------------------------

### Initialize ModulinoLatchRelay

Source: https://github.com/arduino-libraries/arduino_modulino/blob/main/_autodocs/api-reference/modulino-relays.md

Constructors for the ModulinoLatchRelay class, supporting optional I2C address and hub port configuration.

```cpp
ModulinoLatchRelay(uint8_t address = 0xFF, ModulinoHubPort* hubPort = nullptr)
// or
ModulinoLatchRelay(ModulinoHubPort* hubPort, uint8_t address = 0xFF)
```