Inkplate Sensor Hub

Building a multi-sensor project used to mean dealing with messy wiring, address conflicts, power concerns, and hours of debugging before any useful data appeared on screen. That is exactly the kind of friction the Qwiic ecosystem is designed to remove.

The Inkplate Sensor Hub shows just how powerful that approach can be. Using the Inkplate 10 as a central dashboard, this project gathers data from multiple Qwiic-compatible breakout boards and presents it on a large, crisp e-paper display that is easy to read, power efficient, and ideal for always-on monitoring.

Instead of building a separate interface for every sensor, Inkplate Sensor Hub creates one clean display where environmental and system data can be viewed at a glance. The result is a modular sensor dashboard that is easy to expand, simple to maintain, and perfect for demonstrating the real value of plug-and-play hardware design.

In this article, you will:

• see why the Qwiic ecosystem makes multi-sensor projects dramatically easier to build
• learn how Inkplate 10 can act as a flexible low-power dashboard
• understand how multiple breakout boards can share the same bus with minimal wiring
• explore how sensor data can be organized and displayed on e-paper
• get a strong foundation for building your own expandable sensor hub

Whether you are building a smart desk monitor, an environmental station, a workshop dashboard, or an IoT prototype, Inkplate Sensor Hub is a practical example of how the Qwiic ecosystem turns complex hardware integration into a clean and scalable experience.

What Is Inkplate Sensor Hub

Inkplate Sensor Hub is a modular dashboard project built around the Inkplate 10. Its purpose is simple: collect readings from multiple Qwiic-compatible sensors and display them together on a large e-paper screen.

Rather than focusing on a single sensor or a single measurement, this project highlights what happens when several breakout boards work together as one system. Temperature, humidity, air quality, light level, motion, pressure, or any other supported sensor value can be combined into a unified interface.

That makes Inkplate Sensor Hub more than just a sensor demo. It is a clear demonstration of how the Qwiic ecosystem enables rapid prototyping, easier upgrades, and cleaner hardware design.

Why the Qwiic Ecosystem Matters

The biggest strength of the Qwiic ecosystem is that it removes unnecessary complexity from electronics projects. Qwiic uses a standardized 4-pin connector for I2C communication, allowing multiple boards to connect quickly and reliably without soldering.

That means you can:

• connect sensors without breadboards or loose jumper wires
• chain multiple breakout boards on the same bus
• prototype faster and troubleshoot less
• expand a project without redesigning the wiring

In projects like Inkplate Sensor Hub, that simplicity becomes especially valuable. Instead of spending time on hardware integration, you can focus on sensor selection, data presentation, and the overall user experience.

This is the real power of Qwiic: not just making one connection easier, but making an entire system easier to build.

Why Inkplate 10 Is Perfect for This Project

The Inkplate 10 is a natural fit for a multi-sensor dashboard. Its large e-paper display offers excellent readability, low power consumption, and a polished look that works well in home, office, lab, or workshop environments.

Unlike traditional displays, e-paper keeps the image visible even when the screen is not actively refreshing. That makes it ideal for dashboards that update periodically and remain readable all day without wasting energy.

Inkplate 10 also gives this project a strong visual identity. Instead of hiding raw numbers in the serial monitor, the data becomes part of a real interface that feels like a complete product rather than just a development test.

Hardware Overview

Inkplate Sensor Hub is intentionally flexible, so the exact list of breakout boards can vary depending on the type of data you want to display. The core idea is to use the Inkplate 10 as the display and controller, while one or more Qwiic-compatible sensors provide measurements over I2C.

A typical setup may include:

• Inkplate 10 as the main dashboard and controller
• Qwiic environmental sensor for temperature, humidity, and pressure
• Qwiic light sensor for ambient light monitoring
• Qwiic air quality or gas sensor for indoor environment tracking
• Qwiic motion, proximity, or gesture sensor for interaction or occupancy detection
• Qwiic cables for plug-and-play chaining between boards

Because all boards use the same communication standard, adding more sensors does not require rebuilding the project from scratch. You simply connect another breakout board and update the dashboard layout in software.

Wiring and Setup

One of the best things about this project is how little wiring it actually needs. Traditional multi-sensor builds can quickly become cluttered, but with Qwiic, the setup stays clean and readable.

At the hardware level, the process is straightforward:

• connect the first Qwiic breakout board to the Inkplate 10
• chain additional breakout boards using Qwiic cables
• power the Inkplate and upload the firmware

That is enough to create a working sensor network. From there, the software simply initializes each board, reads the available values, and prints them onto the e-paper dashboard.

INA219 ina;
BME280 bme280;
Soldered_LSM6DSO lsm6dso;

bool initSensors()
{
    bool anySensorStarted = false;

    // Initialize BME280 environmental sensor
    bme280.begin();
    anySensorStarted = true;

    // Initialize INA219 power monitor
    ina.begin();
    ina.configure(
        INA219_RANGE_32V,
        INA219_GAIN_320MV,
        INA219_BUS_RES_12BIT,
        INA219_SHUNT_RES_12BIT_1S
    );
    ina.calibrate(0.1, 2.0);
    anySensorStarted = true;

    // Initialize LSM6DSO IMU
    lsm6dso.begin();

    if (lsm6dso.getVariant() == LSM6DSO_VARIANT_LSM6DSO32)
        lsm6dso.setAcceleratorFullScale(32);
    else
        lsm6dso.setAcceleratorFullScale(16);

    lsm6dso.enableAccelerator();
    lsm6dso.enableGyro();
    anySensorStarted = true;

    return anySensorStarted;
}

How the Dashboard Works

The software running on Inkplate 10 periodically reads values from each connected breakout board and organizes them into a clean dashboard layout. Instead of presenting sensor data as an unstructured list, the display can be divided into sections, cards, labels, icons, and status fields.

This makes the project much more useful in practice. You are not just collecting data, you are visualizing it in a way that makes trends and conditions immediately understandable.

Depending on the chosen sensors, the Inkplate Sensor Hub can show:

• temperature and humidity
• air pressure and weather-related data
• ambient light levels
• air quality values
• motion or proximity status
• battery or system status information

Because the Inkplate 10 has a large display area, it can comfortably show several readings at once without becoming cluttered.

void readAllSensors(SensorData &data)
{
    data.bmeOk = false;
    data.inaOk = false;
    data.imuOk = false;
    data.potOk = false;
    data.hallOk = false;
    data.soilOk = false;
    data.pirOk = false;

    // Read BME280 environmental data
    float temperature, humidity, pressure;
    bme280.readSensorData(temperature, humidity, pressure);

    if (!isnan(temperature) && !isnan(humidity) && !isnan(pressure))
    {
        data.temperatureC = temperature;
        data.humidityPct = humidity;
        data.pressurehPa = pressure;
        data.bmeOk = true;
    }

    // Read INA219 power data
    data.busVoltageV = ina.readBusVoltage();
    data.powermW = ina.readBusPower() * 1000.0f;
    data.currentmA = ina.readShuntCurrent() * 1000.0f;

    if (!isnan(data.busVoltageV))
        data.inaOk = true;

    // Read IMU data
    int32_t accel[3];
    int32_t gyro[3];

    lsm6dso.getAcceleratorAxes(accel);
    lsm6dso.getGyroAxes(gyro);

    data.ax = accel[0] / 1000.0f;
    data.ay = accel[1] / 1000.0f;
    data.az = accel[2] / 1000.0f;

    data.gx = gyro[0] / 1000.0f;
    data.gy = gyro[1] / 1000.0f;
    data.gz = gyro[2] / 1000.0f;

    data.pitchDeg = atan2f(-data.ax, sqrtf(data.ay * data.ay + data.az * data.az)) * 180.0f / PI;
    data.rollDeg  = atan2f(data.ay, data.az) * 180.0f / PI;
    data.imuOk = true;
}

Designing the UI for E-Paper

A major part of this project is not just reading sensors, but presenting the data in a way that fits the strengths of e-paper. E-paper displays excel at static or slowly changing interfaces, making them ideal for dashboards, room monitors, and information panels.

With Inkplate Sensor Hub, the screen can be organized into clearly separated modules. Each module can represent a sensor or category of data, allowing the display to remain readable even when several breakout boards are connected.

Possible UI elements include:

• large numeric values for key measurements
• titles for each connected sensor
• small icons for quick recognition
• status labels such as normal, warning, or offline
• simple separators, boxes, or sections for clarity

This makes the final result feel much closer to a finished product than a development prototype.

void guiDrawStaticFrame()
{
    display.clearDisplay();

    // Outer frame
    display.drawRect(0, 0, SCREEN_W, SCREEN_H, BLACK);

    // Top bar
    display.drawRect(MARGIN, MARGIN, SCREEN_W - 2 * MARGIN, TOP_H, BLACK);

    int mainY = MARGIN + TOP_H + GAP;

    // Panels
    display.drawRect(MARGIN, mainY, LEFT_W, MID_H, BLACK);
    display.drawRect(MARGIN + LEFT_W + GAP, mainY, CENTER_W, MID_H, BLACK);
    display.drawRect(MARGIN + LEFT_W + GAP + CENTER_W + GAP, mainY, RIGHT_W, MID_H, BLACK);

    // Bottom panel
    display.drawRect(MARGIN, SCREEN_H - MARGIN - BOTTOM_H, SCREEN_W - 2 * MARGIN, BOTTOM_H, BLACK);

    // Titles
    display.setTextSize(3);
    display.setCursor(MARGIN + 16, MARGIN + 18);
    display.print("Inkplate Sensor Hub");

    display.setTextSize(2);
    display.setCursor(MARGIN + 18, mainY + 16);
    display.print("ENVIRONMENT");

    display.setCursor(MARGIN + LEFT_W + GAP + 18, mainY + 16);
    display.print("TILT / IMU");

    display.setCursor(MARGIN + LEFT_W + GAP + CENTER_W + GAP + 18, mainY + 16);
    display.print("POWER / LIGHT / STATE");

    display.setCursor(MARGIN + 18, SCREEN_H - MARGIN - BOTTOM_H + 16);
    display.print("POTENTIOMETER");
}

Why This Project Demonstrates the Power of Qwiic

Inkplate Sensor Hub is a strong showcase for the Qwiic ecosystem because it turns what could have been a complicated hardware build into a neat and approachable project.

Without Qwiic, connecting several sensors usually means manually routing power, ground, SDA, and SCL for every module, while also dealing with physical layout and cable management. With Qwiic, those barriers are greatly reduced. The hardware becomes modular in a very practical way.

That modularity changes how projects are developed. You can start with one sensor, verify the dashboard logic, and then keep expanding. Each new breakout board adds capability without adding much complexity.

This is exactly why Qwiic is so useful for prototyping, education, product exploration, and proof-of-concept development. Inkplate Sensor Hub takes that value and makes it visible on the screen.

Expanding the Project

One of the best things about Inkplate Sensor Hub is that it does not need to stop at a single use case. The same structure can be adapted into many kinds of monitoring systems.

For example, you could evolve the project into:

• a smart office comfort dashboard
• a workshop environmental monitor
• a classroom STEM demonstration
• a weather and indoor air tracker
• a device status panel for other electronics projects

Because the Qwiic ecosystem includes such a wide range of breakout boards, the project can grow with your needs instead of being locked into one fixed configuration.

Example Arduino Structure

The software architecture of Inkplate Sensor Hub is simple and scalable. In a typical implementation, the program:

1. initializes the Inkplate display
2. starts I2C communication
3. initializes all connected Qwiic sensors
4. reads sensor values at defined intervals
5. formats the data for display
6. refreshes the e-paper dashboard

A project like this benefits from keeping sensor reading and UI drawing separated into dedicated functions, especially as the number of connected breakout boards increases.

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

    Wire.begin();

    display.begin();
    display.setRotation(0);

    guiInit();
    guiDrawStaticFrame();
    display.display();

    bool sensorInitOk = initSensors();

    Serial.println("Inkplate Sensor Hub started.");
    Serial.print("Sensors initialized: ");
    Serial.println(sensorInitOk ? "YES" : "NO");
}

void loop()
{
    uint32_t now = millis();

    if (now - lastSensorReadMs >= SENSOR_READ_INTERVAL_MS)
    {
        lastSensorReadMs = now;
        readAllSensors(sensorData);
    }

    if (now - lastGuiRefreshMs >= GUI_REFRESH_INTERVAL_MS)
    {
        lastGuiRefreshMs = now;

        bool doFullRefresh = false;
        partialRefreshCounter++;

        if (partialRefreshCounter >= FULL_REFRESH_EVERY_N_UPDATES)
        {
            partialRefreshCounter = 0;
            doFullRefresh = true;
        }

        guiDrawData(sensorData, updateCounter, doFullRefresh);

        if (doFullRefresh)
            display.display();
        else
            display.partialUpdate();

        updateCounter++;
    }
}

The Result

When everything is connected and running, Inkplate Sensor Hub becomes a clean, low-power information center for all of your Qwiic-compatible breakout boards. Instead of seeing the Qwiic ecosystem as a collection of separate modules, you see it as one coordinated system.

That is what makes this project so effective as a demo. It does not just show that one sensor works. It shows how several sensors can work together, how easy they are to connect, and how polished the final result can look when paired with an Inkplate display.

The final dashboard is practical, readable, and highly expandable, which makes it an excellent showcase project for makers, educators, and anyone exploring modular embedded systems.

Conclusion

The Inkplate Sensor Hub is a clear demonstration of the real strength of the Qwiic ecosystem. It takes multi-sensor integration, which can often be tedious and error-prone, and turns it into a fast, scalable, and visually clean workflow.

By combining Inkplate 10 with multiple Qwiic-compatible breakout boards, this project creates a dashboard that is not only useful, but also a strong example of modern plug-and-play hardware design.

If you want to show what Qwiic can do, this is the kind of project that makes the point immediately. Less wiring, faster prototyping, easier expansion, and a polished final result all come together in a single build.

And that is exactly why Inkplate Sensor Hub works so well as a showcase: it turns the power of the Qwiic ecosystem into something you can see at a glance.