Build on Motion Intelligence — Faster, Cleaner, In Control

QSense is a professional IMU motion platform designed for developers, researchers and product teams who need reliable, real-time human motion data in real-world conditions.

Go from idea to instrumented test in minutes. Stream, visualize and record high-fidelity motion data without fighting toolchains, infrastructure or closed ecosystems. Prototype faster. Validate earlier. Build with confidence.

Whether you are developing XR applications, rehabilitation tools, sports analytics, industrial pilots or new wearable products — QSense gives you the motion layer you can trust.

Watch: QSense Motion Platform Introduction

WHITE PAPER

From Sensor to Dashboard: Building Motion-Driven Products with QSense Motion

A practical pipeline guide for researchers, entrepreneurs and app developers. Learn how to move from first measurement to a validated dashboard product — including the four development stages, three algorithm engagement levels, four dashboard build options, and reference architectures for sports, rehabilitation, defense, industry and XR.

The four-stage development pipeline: measurement → algorithm → validation → dashboard
How to scope algorithm work: client-led, joint, or QSense-owned
Four ways to build the dashboard layer — from in-house to fully delivered
Multi-sensor combinations: motion + ECG, EMG, force plates, instrumented objects

Download the white paper (PDF)

Why Developers Choose QSense

Rapid Real-World Prototyping

Deploy a single sensor or a full-body setup in minutes. Live streaming, 3D visualization and recording are available out of the box, so you can focus on validating concepts instead of building plumbing.

From 1 to 10+ sensors
Ready in ~5 minutes
No camera setup, no lab infrastructure

Flexible Data Outputs — Your Pipeline, Your Choice

Configure sensor outputs to match your architecture:

Raw sensor data (accelerometer, gyroscope, magnetometer)
Fused kinematics
6DOF / 9DOF quaternions
Mixed modes
Free acceleration

Sampling rates from 1 to 800 Hz depending on configuration.

No black boxes. No locked dashboards. Full control over your data.

Real-Time Performance for Interactive Applications

QSense is designed for closed-loop use cases where latency and timing matter:

~25 ms end-to-end latency
Deterministic timing for multi-sensor setups
Suitable for gaming, training, rehab, robotics and control systems

Unity-ready examples and clear APIs make integration straightforward.

Ultra-Precise Time Synchronization

Frame-accurate alignment across sensors with:

~60 µs typical sync accuracy
<150 µs worst-case

Extend synchronization to external systems such as EMG, ECG, force plates or triggers for true multi-modal capture.

This is what enables reliable biomechanics, phase detection and event-based feedback.

Open APIs. Transparent Architecture.

QSense is built as an open motion platform.

We provide ready-to-use C#/.NET APIs for:

Windows
Android
iOS (beta)
Unity

These APIs allow you to:

Access sensor data and device memory
Control multiple sensors via a single serial channel (dongle)
Stream synchronized motion data in real time or for logging

You are free to build:

analytics pipelines
custom applications
embedded products
XR environments
research tools

Without being locked into our software.

Integrate QSense Sensors into Your Custom Applications

The QSense Developer’s Guide provides developers with everything they need to integrate QSense IMU motion sensors and the wireless BLE dongle into custom applications. This includes an overview of interfaces, APIs, and system-level considerations to ensure reliable motion tracking and time-synchronized data collection.

QSense provides ready-to-use C#/.NET APIs for Windows, Android, iOS (beta), and Unity. These libraries allow developers to:

Access sensor data and device memory through the Core Interface.
Control multiple sensors via a single serial channel using the dongle’s Serial Interface.
Stream synchronized motion data for real-time or logged applications.

To jump-start development, QSense offers:

Code examples on GitHub for sensor and dongle integration.
Sample implementations demonstrating BLE communication, data logging, and time synchronization.

For multi-sensor setups, the guide covers performance tuning, BLE bandwidth optimization, and IMU calibration procedures to achieve optimal accuracy in real-world scenarios.

Supported Interfaces

QSense supports multiple communication paths:

Direct BLE 5.2 communication with sensors
High-performance QSense Wireless BLE Dongle for stable multi-sensor streaming
Serial Interface for controlling multiple sensors through one channel

This allows you to choose the architecture that best fits your product or research setup.

APIs

The following APIs are currently available for C#-based solutions:

QSenseDotNet Dynamic Link Library (DLL): Implements the interface for communicating with and controlling QSense sensors. This DLL does not handle BLE communication. Integration with BLE requires custom implementation or a third-party library.
QSenseDotNet.Dongle DLL: Extends the QSenseDotNet DLL by implementing the interface for the QSense wireless BLE dongle. This library is applicable only when using the QSense wireless BLE dongle and manages serial communication in this context.

Both DLLs target .Net Standard 2.1 framework. Due to this, they support applications targeting, among others:

Windows 10+, Android 8+, iOS 16+
.Net 5+
Unity 2021.2

See full version support at the official Microsoft website.

Interfaces

Direct wireless communication over BLE5.2 with the QSense motion sensor via the sensor interface. The Core Interface of the QSense sensor enables direct access to device memory for essential configuration and data retrieval.

The Serial Interface of the QSense dongle facilitates control of the dongle and provides access to the Core Interface of multiple sensors through a single serial communication channel. Interface documentation is available upon request.

The QSense interface uses BLE 5.2 with support for Data Length Extension (DLE). The API protocol makes use of the Nordic UART Service (NUS) and is defined on top of this UART interface.
The advertisement packet send by the sensor has the possibility to include a customizable name in the manufacturer specific data. The memory map uses 2 memory locations: control memory and stream memory.

Besides stream data the developer has a number of controls available:

Identification & versioning
Set device name (visible in the advertisement package)
Battery level percentage
Motion level: to identify is the sensor is tapped or moving
Parameters related to magnetic field mapping
Quality parameters
Gyroscope and accelerometer sensitivity
Set data mode: mixed, raw or quaternion
Sample rate, data buffer, connection interval
Set animation & color of the LEDs on the sensor

WHITE PAPER

From Sensor to Dashboard: Building Motion-Driven Products with QSense Motion

The four-stage development pipeline: measurement → algorithm → validation → dashboard
How to scope algorithm work: client-led, joint, or QSense-owned
Four ways to build the dashboard layer — from in-house to fully delivered
Multi-sensor combinations: motion + ECG, EMG, force plates, instrumented objects

Download the white paper (PDF)

Example Projects & Code

We provide a public GitHub repository with examples for:

sensor interfaces
dongle communication
streaming & logging
Python integration
C# examples

→ View QSense Examples on GitHub

Designed for Product Teams, Not Just Demos

QSense is not a toy SDK. It is a platform designed to scale from:

proof-of-concept
to pilot
to product
to volume production

We support:

OEM embedding
custom enclosures and PCB variants
algorithm development
validation & certification pathways
EVT / DVT / PVT support

You stay in control of your roadmap. We support you technically.

Performance & System Scaling Guidelines

When integrating QSense into multi-sensor or high-performance applications, understanding system behaviour at scale is essential. QSense is designed to scale from single-sensor prototypes to complex, time-synchronised multi-sensor systems. This section provides practical guidance on performance, throughput, and configuration to help you design reliable, high-quality solutions.

We believe developers should understand how the system behaves under different loads – not discover it through trial and error.

Multi-Sensor Performance

QSense supports flexible multi-sensor configurations. Performance depends on:

number of connected sensors
selected sample rate
data mode (raw, quaternion, mixed)
whether TimeSync mode is enabled
BLE connection interval and host platform capabilities

As a general guideline:

1–2 sensors: up to 400 Hz
3–6 sensors: up to 200 Hz
7–12 sensors: up to 100 Hz

This enables high-resolution motion capture while maintaining stable wireless performance.

Tip: for optimal throughput, the BLE connection interval is typically set to number of sensors × 7.5 ms.

Time Synchronization vs. Latency Trade-Off

QSense supports two operating modes:

TimeSync Mode – maximum precision

All sensors share a common clock
Continuous wireless re-synchronisation
Typical inter-sensor accuracy: < 60 µs (max < 150 µs)
Minimum connection interval: 15 ms
Ideal for:
- biomechanics
- gait analysis
- multi-modal fusion (EMG, force plates, video)
- research-grade analysis

Low Latency Mode – fastest response

Each sensor timestamps locally
No runtime re-synchronisation
Drift ≤ 2 ms per minute
Minimum latency: 7.5 ms
Ideal for:
- XR interaction
- real-time feedback
- gaming & exergaming
- closed-loop control

This gives you explicit control over the precision ↔ responsiveness trade-off.

BLE Throughput & Platform Considerations

Wireless BLE performance is influenced by:

operating system constraints (Windows, Android, iOS)
BLE stack implementation
number of simultaneous connections
minimum supported connection interval

QSense is tested and validated on:

Windows 10/11
Android 8+
iOS 16+
Linux & macOS (via dongle interface)

For maximum stability and throughput in multi-sensor setups, we recommend using the QSense Wireless BLE Dongle, which is optimised for high-rate, multi-device communication.

IMU Calibration & Environment Effects

For best accuracy:

Magnetometer calibration should be repeated when:
- environment changes
- metal objects or electronics are nearby
Gyroscope bias compensation is typically needed only:
- after full device reset
- after large temperature changes

This ensures consistent orientation quality and minimal drift.

Designing for Reliability at Scale

When designing larger systems, consider:

sensor placement and mechanical coupling
battery life vs. sample rate trade-offs
data volume and storage strategy
real-time vs. offline processing requirements

QSense is designed to support:

research pipelines
embedded products
long-term monitoring
field-based capture
OEM deployments

without changing platform or architecture.

We Help You Tune It

System scaling is not guesswork. We actively support teams with:

configuration advice
performance tuning
throughput optimisation
architecture review
validation and testing

So you can focus on building your application – not fighting the underlying system.

When You Need More Than an SDK

We also provide hands-on integration support:

system architecture review
performance tuning
multi-sensor synchronization design
BLE optimization
custom firmware or features
OEM development support

Our team has deep experience in wireless systems, embedded platforms and wearable products — and we bring that into your project.

Ready to Build?

Whether you are:

prototyping a new idea
integrating motion into your product
or building a commercial solution

QSense gives you the motion intelligence layer to build on.

Contact our team to discuss your project

Build on Motion Intelligence — Faster, Cleaner, In Control

From Sensor to Dashboard: Building Motion-Driven Products with QSense Motion