Wavelength

Your world changes. Your hearing adapts.

Inspiration

One of our teammates wears hearing aids. During our initial brainstorming session, he showed us the companion app he uses to configure them. It was filled with sliders, settings, and adjustments that he has to revisit whenever his surroundings change.

That conversation changed the direction of our project.

For most people, moving from a quiet room into a crowded restaurant or walking onto a busy street happens without a second thought. But for someone who depends on hearing assistance, those transitions can mean repeatedly reaching for their phone and readjusting how they hear the world.

Hearing technology is supposed to make everyday life easier. Yet our teammate described how managing his hearing settings could become another task demanding his attention.

We started asking a different question:

What if your hearing device could learn how you prefer to hear, instead of making you teach it the same preferences over and over again?

That question became Wavelength.

We wanted to build more than another audio-processing interface. We wanted to explore hearing assistance that learns from individual preferences and adapts as the surrounding acoustic environment changes.

More importantly, we wanted that intelligence to run on the device itself—not behind a cloud API or dependent on an always-connected smartphone.

What it does

Wavelength is a personalized, adaptive hearing-assistance prototype that combines real-time audio processing, embedded machine learning, and a companion application.

Its central idea is simple: the user shouldn't have to keep adapting to their hearing device. The device should learn to adapt to them.

The system captures audio through two microphones connected to an STM32 microcontroller and processes it using digital signal processing (DSP). Our noise-reduction pipeline uses adaptive filtering to suppress components of the captured noise, while a continuously adjustable strength control determines how much of the filtered signal reaches the output.

The companion app gives the listener direct control over their audio settings, including noise reduction, volume, spatial focus, speech amplification, and equalization.

But the most important feature is what happens after the user makes an adjustment.

When someone changes the noise-reduction setting and releases the control, Wavelength's app submits that completed adjustment as feedback to our lightweight learning model. The model associates the preferred setting with acoustic characteristics measured by the microphones.

When similar acoustic conditions return, Wavelength can predict the listener's preferred noise-reduction strength and adjust its processing automatically.

The intended interaction is:

Adjust once → Wavelength learns → your environment changes → Wavelength remembers.

Unlike conventional manually selected presets, the user does not need to assign names to environments or repeatedly select a profile. Wavelength uses measured acoustic similarity to retrieve previously learned preferences.

Our implemented learning loop currently personalizes noise-reduction strength. Other controls remain available for manual configuration; extending contextual learning to additional DSP parameters is future work.

The app also includes a Reset Learning action, allowing users to clear learned corrections and start fresh without restarting the device.

In controlled host integration tests, Wavelength learned two distinct preferences from a single correction each—80% and 30% noise-reduction strength—and recalled both exactly across ten repeated environment transitions without additional feedback.

These results validate the software learning loop, although they do not establish clinical hearing benefits or equivalent performance in every physical environment.

Wavelength is an experimental proof of concept, not a clinically validated hearing aid.

How we built it

Wavelength brings together embedded hardware, digital signal processing, lightweight machine learning, and companion software.

Embedded Hardware — STM32

At the center of Wavelength is an STM32F411RE microcontroller.

We chose an embedded microcontroller because we wanted to explore whether personalized adaptation could run with limited memory and computational resources rather than relying on a powerful external processor.

Our hardware uses two digital microphones to capture incoming audio, including a reference signal for adaptive noise processing.

The firmware processes audio at 16 kHz in blocks of 64 samples, corresponding to a 4-millisecond audio-processing interval. DMA-based acquisition helps maintain continuous audio capture while the processor performs DSP operations.

We implemented and tested live microphone capture and noise filtering on the STM32.

For the hackathon prototype, the working audio path streams processed PCM audio from the STM32 over a serial connection to a Windows computer, where a playback bridge delivers the sound to an output device.

This allowed us to focus on proving real-time embedded processing and personalized adaptation without making the entire prototype dependent on a completed standalone headphone-output circuit.

Importantly, the adaptive-learning logic is integrated into the embedded firmware, rather than requiring the PC to calculate personalized predictions.

Digital Signal Processing — C and CMSIS-DSP

Our audio-processing pipeline is implemented in C, using STM32 firmware components and CMSIS-DSP.

A central component is a normalized least mean squares (NLMS) adaptive filter that uses microphone signals to estimate and suppress correlated noise.

Rather than treating noise reduction as a simple on/off feature, we expose a continuous processing-strength parameter.

Conceptually, the output combines the original signal with the filtered signal:

[ y=(1-\alpha)x_{\text{original}}+\alpha x_{\text{filtered}} ]

where (\alpha) represents the selected noise-reduction strength.

This distinction matters because different listeners may prefer different tradeoffs between noise suppression and preservation of the original audio.

Our firmware also includes processing and control infrastructure for additional audio adjustments, with host regression tests covering equalization, compression, and spatial-processing components.

For personalized learning, the DSP pipeline provides acoustic measurements from the microphone signals. Rather than executing machine learning inside the time-critical audio callback, the firmware aggregates observations and runs learning-related logic in the foreground.

The model uses approximately 100-millisecond acoustic observation windows, while processing-strength updates pass through existing block-boundary control and smoothing mechanisms.

This separation helps protect continuous audio processing from the computational and synchronization costs of model inference.

Adaptive Intelligence — Online Contextual Preference Learning

Instead of deploying a neural network or relying on a pretrained model, we built a lightweight online, memory-based regression model.

Our reasoning was straightforward: hearing preferences are personal, and a user may only provide a handful of corrections. We needed a model that could learn from very little feedback, operate within strict embedded constraints, and produce continuous DSP settings rather than broad environment labels.

The learner stores examples connecting acoustic contexts to preferred processing values.

When a new context arrives, it compares that context with previously observed examples and uses distance-weighted interpolation to predict an appropriate adjustment.

Similar contexts receive greater influence from previous corrections. Unfamiliar contexts move the prediction back toward a conservative baseline.

Our learning system includes:

  • Three model input dimensions: normalized primary microphone RMS, normalized reference microphone RMS, and one reserved constant input.
  • Continuous outputs: an abstract two-parameter learner, with noise-reduction strength currently connected to the DSP pipeline.
  • Bounded contextual memory: storage for up to 16 feedback examples.
  • Partial-feedback learning: only controls explicitly corrected by the user are updated.
  • Baseline fallback: unfamiliar or insufficiently supported contexts do not force arbitrary settings.
  • Correction hold and stability checks: manual adjustments receive temporary priority, while acoustic changes are evaluated conservatively.

The standalone learner occupies approximately 432 bytes of model state in host measurements, making it suitable in principle for resource-constrained embedded deployment. Target-specific timing and memory measurements require separate hardware validation.

The model doesn't continuously train itself from its predictions. Learning happens when the user provides an actual correction; automatic inference happens as acoustic conditions change.

We implemented this algorithm in portable C and connected it to the existing DSP code through an opt-in firmware integration.

In our controlled two-context experiment, the system learned a preference of 80% for one acoustic context and 30% for another. After receiving one correction in each context, it reproduced both settings on return visits.

Across ten complete A/B transitions, the model retained exactly two training examples and recalled both preferences without sending additional correction commands.

These tests exercised the actual learner, embedded integration layer, and DSP implementation—not a separate mock prediction algorithm.

One important limitation is that our current features describe microphone signal levels rather than semantic scenes. Two environments with similar acoustic measurements may be difficult to distinguish, even if the listener prefers different settings.

That gives us a clear direction for improving Wavelength beyond the hackathon.

Companion Application — React Native, Expo, and TypeScript

We developed Wavelength's companion interface using React Native, Expo, and TypeScript, with a browser-accessible workflow for communicating with our prototype.

The application provides a place for users to adjust audio processing, inspect the device's reported settings, and manage learned preferences.

One of our main design goals was to avoid recreating the same frustrating interaction that originally inspired the project.

Instead of requiring users to manually save a preset or label each environment, the noise-reduction control automatically submits a learning correction when the user finishes adjusting it.

The software distinguishes between an ongoing slider interaction and a completed user correction. Intermediate slider movements can update audio processing, but they do not generate training examples.

The application sends commands through a local Node.js server and an existing Windows/C# serial bridge. Commands are queued and acknowledged by the STM32, while device telemetry flows back to the app.

We specifically designed this communication layer to avoid confusing automatic device adjustments with new user input. Device-reported values update the interface without triggering another manual control command or accidentally training the model.

We also implemented feedback states such as Adjusting, Learning, and Preference learned, together with a Reset Learning workflow for clearing preferences between demonstrations.

The result is an application that assists with personalization while keeping the core audio-processing and inference responsibilities in the embedded system.

Challenges we ran into

Real-Time Audio Processing on Constrained Hardware

Getting continuous microphone audio into the STM32 and back out as usable processed sound was one of our largest engineering challenges.

We had to coordinate dual-microphone capture, DMA buffers, adaptive filtering, serial audio streaming, and a reliable playback path.

Audio systems are unforgiving: incorrect timing, invalid reference capture, or a buffer synchronization error can produce audible artifacts or stop streaming entirely.

We addressed these problems by separating time-critical DSP work from foreground control and learning tasks, preserving existing processing deadlines, and building regression tests around the audio pipeline.

We also learned to protect working firmware configurations. Once real filtering was functional, new features had to be integrated without disrupting that baseline.

Making Machine Learning Useful with Very Little Feedback

Our original idea could easily have led us toward a complicated neural network or automatic environment classifier.

But neither approach directly solved our actual problem: learning an individual's preferred settings from a small number of corrections.

We decided that a compact contextual-memory model was a better starting point.

This meant carefully considering how acoustic features should be normalized, how similar environments should influence one another, and what should happen when the model encounters something unfamiliar.

We also had to distinguish learning from prediction. The model should respond automatically to changing environments, but it should not treat every automatic adjustment as another training example.

Our one-shot recall tests demonstrated that a relatively simple model could produce meaningful adaptive behavior without a large training dataset or cloud inference.

Connecting the App, Serial Bridge, and Firmware

Integrating the companion app with the embedded device introduced a different class of challenges.

A slider adjustment may seem like a single interaction to the user, but internally it involves UI state, asynchronous requests, serialized commands, firmware acknowledgments, and device telemetry.

We encountered issues involving command rejection, feedback visibility, command ordering, and stale status updates.

One particularly important problem was distinguishing ordinary control commands from deliberate learning corrections.

We designed the application to wait for the final manual setting acknowledgment before submitting a learning correction. We also ensured that reconnection, state restoration, and telemetry updates would not accidentally generate training events.

These challenges reinforced how much engineering is required to make a technically correct system feel intuitive.

Working Within Hackathon Constraints

Wavelength combines several difficult areas of engineering, and we quickly realized that implementing every feature we imagined would distract from proving the central concept.

We made deliberate tradeoffs.

We focused embedded personalization on one meaningful continuous DSP parameter rather than attempting to learn every control simultaneously. We used a Windows playback bridge rather than claiming a fully miniaturized, standalone hearing device.

We also built extensive host-side tests so that the learning algorithm, application protocol, and DSP integration could be validated independently while hardware development continued.

The most important decision was prioritizing one complete personalized feedback loop over many disconnected features.

Accomplishments that we're proud of

  • Built and tested real-time audio filtering on an STM32F411RE, using dual-microphone input and an NLMS processing pipeline.
  • Developed a compact online preference-learning model in portable C, designed to learn from sparse user corrections without a pretrained network or cloud service.
  • Demonstrated one-shot learning of two distinct preferences in controlled integration tests, with exact recall across ten repeated transitions and no additional corrections.
  • Connected embedded controls to a companion application, including serial communication, command acknowledgments, device telemetry, and automatic feedback from completed user adjustments.
  • Designed a complete prototype architecture connecting microphone measurements, adaptive predictions, DSP parameters, and user interaction, while maintaining regression coverage across the major components.

What we learned

Wavelength pushed us to work across disciplines that are often treated separately: embedded systems, digital signal processing, machine learning, and human-centered product design.

One of our most important insights is that personalization and adaptation are not the same thing.

A device can offer dozens of adjustable settings and still require the user to manage every one of them. Meaningful adaptation requires remembering previous interactions and applying that information appropriately.

We also learned that the most useful machine learning model isn't necessarily the largest or most sophisticated one.

Our preference learner doesn't try to understand every sound in the world. Instead, it solves a smaller problem: use a compact representation of the environment to recall settings the user has previously preferred.

That approach let us prioritize interpretability, bounded memory, fast updates, and on-device execution over model complexity.

Another major lesson was that the interface is part of the learning algorithm's success.

If the app accidentally treats restored settings or automatic telemetry as user feedback, the model learns from the wrong events. If a correction is stored but the UI doesn't acknowledge it clearly, the user cannot tell whether the system understood their preference.

Building Wavelength made us appreciate how deeply embedded timing, communication protocols, data quality, and interface design influence the actual behavior of an intelligent system.

Perhaps the most important lesson came before we wrote any code.

Our teammate didn't ask for more sliders, more presets, or more complicated settings.

He wanted to spend less time thinking about his hearing aids.

That became our guiding design principle.

What's next for Wavelength

Richer Acoustic Understanding: Our current learning features are intentionally lightweight. We want to explore frequency-domain characteristics, speech activity, and more expressive acoustic features to distinguish listening situations that have similar overall loudness.

Learning More Processing Parameters: Our initial feedback loop focuses on noise-reduction strength. Future versions could learn personalized equalization, speech emphasis, and other supported DSP controls.

Persistent On-Device Preferences: Our current learner keeps corrections in RAM. A future version would preserve learned preferences across power cycles, with safe storage, versioning, and user-controlled resets.

Greater Stability and Confidence Awareness: We want to refine how the system handles ambiguous environments, conflicting corrections, transitions, and uncertainty without making unwanted adjustments.

Standalone Hardware and Miniaturization: The current prototype uses a PC-based playback bridge. Future iterations would integrate reliable local audio output, a smaller form factor, and careful power optimization.

Real-World Usability and Acoustic Safety: We would like to work with hearing professionals and interested listeners to evaluate comfort, usability, and the limits of personalized processing. Any medical or clinical claims would require appropriate testing and evidence.

Our goal is not to replace established hearing aids overnight.

It's to explore a different relationship between people and hearing technology—one where the device gradually becomes more personal, without becoming more complicated to use.

Because the best hearing technology should help you experience the world, not make you constantly manage how you hear it.

Try it out

GitHub: https://github.com/ayushp06/hackathon-fa26

Technical Results: Our repository includes the portable preference learner, embedded firmware integration, DSP regression tests, companion app, and reproducible two-environment learning tests.

Prototype Status: Real-time microphone capture and noise filtering have been tested on hardware. The adaptive-learning and application-feedback implementations passed host integration tests; physical autonomous recall should be described according to the final hardware demonstration results.

Built With

Share this project:

Updates

Submission history