SensWear is an open-source, research-grade wearable development platform for collecting raw physiological, motion, interaction, and environmental data.

Most commercial wearables provide only processed metrics through closed hardware and restricted APIs. SensWear takes the opposite approach: developers receive access to the hardware design files, configurable firmware, communication interfaces, raw sensor streams, mobile applications, and software SDKs.

Its modular and form-factor-agnostic architecture can be adapted to smart rings, wristbands, patches, research instruments, and other custom wearable devices without redesigning the complete technology stack.

SensWear is intended for:

• Wearable computing and digital-health research
• Physiological and multimodal data collection
• Activity and gesture recognition
• Human–computer interaction
• Sensor-fusion and edge-AI development
• Rapid prototyping of new wearable products
• Teaching embedded systems, sensing, and machine learning

Main Hardware

The SensWear main board acts as the processing, connectivity, motion-sensing, storage, and power-management hub.

Its primary components include:

• Nordic Semiconductor nRF54L15: low-power processing and Bluetooth Low Energy connectivity
• Bosch BHI360: six-axis smart IMU for acceleration, angular velocity, orientation, gesture, and activity sensing
• BQ25180: battery charging and power-path management
• BQ27427: battery fuel gauging
• TPSM83102: regulated power supply for the daughter-board interface
• LP5562: programmable RGB LED control
• M95P: nonvolatile storage for local data and configuration

Modular Daughter Boards

Sensors and actuators can be added through interchangeable daughter boards:

The modular interface also allows developers to design their own daughter boards for new sensors, actuators, or experimental applications.

Complete Open-Source Stack

SensWear provides more than a hardware design. The complete stack includes:

• Flexible main and daughter-board PCB designs
• Schematics, layouts, BOMs, Gerbers, drill files, and assembly outputs
• Zephyr-based embedded firmware
• Bluetooth Low Energy services for configuration and data streaming
• Mobile application for device discovery, configuration, visualization, and recording
• Python SDK for research, automation, signal processing, and machine-learning workflows
• TypeScript SDK for web, desktop, Node.js, and mobile integrations

This provides an inspectable path from physical sensing to embedded processing, wireless communication, visualization, and AI/ML analysis.

Building the Hardware

There are two ways to build SensWear:

1. Use preassembled SensWear boards and configure them for your application.
2. Manufacture the boards from the published open-source design files.

Manufacturing from the Design Files

1. Download or clone the hardware repository:

git clone https://github.com/Sens-Wear/hardware.git
cd hardware

2. Open the top-level SensWear_V1R1.DsnWrk workspace in Altium Designer.

3. Open the relevant .PrjPcb project for the board you want to manufacture. Separate projects are provided for the main, debug, PPG, temperature, touch, haptic, and sensor-panel boards.

4. Locate the manufacturing outputs inside the relevant board directory. Depending on the board, these include:

• Bill of materials
• Pick-and-place files
• Gerber files
• NC drill files
• Assembly drawings
• Schematic and manufacturing PDFs

5. Before ordering, compile the Altium project and run the electrical-rule and design-rule checks.

6. Verify the PCB stack-up, thickness, copper weight, finish, impedance requirements, panelization, component availability, and assembly constraints with the selected manufacturer.

7. Inspect all Gerber and drill files in an independent viewer before releasing them for production.

Because SensWear uses dense flexible-PCB designs and small components, professional PCB fabrication and automated assembly are strongly recommended.

Hardware Assembly

1. Disconnect the battery and all external power before connecting or removing boards.

2. Visually inspect the main board and daughter boards for damaged connectors, solder bridges, missing components, or incorrect assembly orientation.

3. Connect the required daughter board to the standardized expansion interface. Follow the connector orientation and assembly drawings in the hardware repository.

4. Connect a suitable rechargeable battery while carefully checking polarity.

5. If the device will be worn on the body, place the electronics inside an electrically insulating enclosure.

6. Position skin-facing sensors correctly:

• The PPG sensor requires stable skin contact and optical isolation from external light.
• The temperature sensor requires suitable thermal contact with the skin.
• Capacitive-touch performance depends on electrode geometry and enclosure material.
• Haptic performance depends heavily on actuator mounting and mechanical coupling.

7. Use the dedicated pogo interface for charging.

Firmware Setup

The firmware is based on Zephyr and targets the SensWear nRF54L15 application core.

Clone the firmware repository:

git clone https://github.com/Sens-Wear/firmware.git
cd firmware
cp .env.example .env

Install the compatible Nordic nRF Connect SDK and Zephyr toolchain, then update .env with the paths for your local installation.

Build the base-board firmware:

cmake --preset senswear_nrf54l15_cpuapp
cmake --build --preset senswear_nrf54l15_cpuapp

Use the appropriate preset when a daughter board is installed:

cmake --preset senswear_nrf54l15_cpuapp_ppg
cmake --build --preset senswear_nrf54l15_cpuapp_ppg

Available application presets include:

• senswear_nrf54l15_cpuapp_ppg
• senswear_nrf54l15_cpuapp_temperature
• senswear_nrf54l15_cpuapp_touch
• senswear_nrf54l15_cpuapp_haptic

The firmware configuration must match the physically connected daughter board. The current build system also validates combinations that share the regulated daughter-board power rail.

Flash the generated firmware through the SensWear debug board using a compatible CMSIS-DAP or J-Link programmer.

Important: The nRF54L15 SWD interface operates at 1.8 V. Do not use a standard ST-Link/V2 unless that specific debugger explicitly supports 1.8 V target signaling.

Full setup and build documentation is available in the firmware repository.

Connecting with Python

Install the Python SDK on a Bluetooth-enabled computer running Python 3.10 or later:

python -m pip install senswear

The following example connects to SensWear and streams acceleration data:

import asyncio
from senswear import SenswearClient

async def main():
    async with SenswearClient() as device:
        battery = await device.battery.read()
        print(f"Battery: {battery.percent}%")

        await device.imu.set_physical_streams_enabled(True)

        await device.imu.subscribe_linear_acceleration(
            lambda sample: print(sample)
        )

        try:
            await asyncio.sleep(30)
        finally:
            await device.imu.unsubscribe_all()
            await device.imu.set_physical_streams_enabled(False)

asyncio.run(main())

The SDK also provides access to raw PPG channels, temperature measurements, touch events, orientation, gyroscope data, activity classification, battery state, RGB LEDs, and haptic patterns when the corresponding hardware and firmware services are available.

Initial Testing Checklist

After assembly and flashing:

1. Confirm that the device advertises over Bluetooth.
2. Connect using the mobile application or Python SDK.
3. Read the battery level and charging state.
4. Verify IMU orientation and acceleration streams.
5. Test the installed daughter board.
6. Check sensor timestamps and data continuity.
7. Confirm charging through the pogo interface.
8. Test the complete system inside its intended enclosure.
9. Recheck power consumption and wireless performance under the final configuration.

Important Technical Notes

• PPG values are raw optical ADC samples, not automatically calculated heart rate or SpO₂ results. Physiological estimates require appropriate filtering, artifact rejection, calibration, and validation.
• Sensor placement, enclosure pressure, ambient light, motion, skin contact, and temperature can significantly influence measurements.
• High-rate BLE streaming should use efficient callbacks, buffering, and bounded queues to avoid losing samples.
• The device configuration and firmware shield selection must correspond to the installed hardware.
• Always follow suitable lithium-battery handling, charging, insulation, and protection practices.
• SensWear is a research and prototyping platform. It is not a medically certified device and must not be used for clinical diagnosis or treatment without the required validation and regulatory approvals.

Open Source and Contributions

SensWear hardware, firmware, SDKs, and applications are released under the permissive MIT License. Contributions involving new sensors, hardware revisions, firmware drivers, SDK integrations, documentation, power optimization, embedded AI, and example applications are welcome.

• Website: https://sens-wear.com
• GitHub organization: https://github.com/Sens-Wear
• Hardware: https://github.com/Sens-Wear/hardware
• Firmware: https://github.com/Sens-Wear/firmware
• Mobile application: https://github.com/Sens-Wear/mobile-app
• Python SDK: https://github.com/Sens-Wear/python-sdk
• TypeScript SDK: https://github.com/Sens-Wear/typescript-sdk

Open hardware. Embedded intelligence. Modular by design.