EE 599: Robotic Mobility, taught by Prof. Feifei Qian in Fall 2025, was the most hands-on course I took at USC — and the one that most changed how I think. Not just about robots. About what it means to know something: to have the math, the hardware, and the measurement all agree with each other, and to notice when they don’t.

This is the full retrospective: the labs, the project, the teaching, and what stuck.

The shape of it

Looking back, three ideas ran underneath the whole semester, and I only saw the pattern clearly when I wrote my study guide at the end: template-based control (parameterized clocks that generate gaits), geometric mechanics (shape-space geometry that predicts and optimizes motion), and dynamic locomotion (energy exchange and stability analysis). Everything I learned was one of those three wearing different clothes.

The rhythm that made it stick: watch the thing move, build the physical picture, write the math, then test it on hardware. Every unit followed that order. It’s the order I still use when I’m learning something hard.

Lab 1: learning to speak servo

The first lab put a Buehler clock in my hands — or rather, in my servos.

The setup: a small quadruped, four Dynamixel-class servos, and a controller that generates leg trajectories from a handful of parameters — stride period, duty cycle, phase offsets between legs. Lab 1 was about learning to command a servo properly: position mode, velocity mode, torque mode, and what the motor is actually doing under each.

I came out of it with plots I still keep: per-joint traces of commanded angle, measured velocity, and estimated torque across gait cycles. The unglamorous kind of data. But it was the first time I’d measured a gait instead of just watching one, and it taught me the habit the whole course kept reinforcing: the plot is the truth; the theory is the hypothesis.

The conceptual payload of Lab 1 was small but load-bearing: a gait is not a script of joint angles. It’s a parameterized clock. Change the phase offset between the rear pair and the front pair and you’ve changed the gait — same hardware, same code, different animal. That idea — behavior as a point in parameter space — is the seed everything else grew from.

Lab 2: the gait playground

Lab 2 was the playground: the same quadruped, but now the task was to explore the gait parameter space systematically. Phase relationships between leg pairs, duty cycle sweeps, the transition from walking to bounding.

Bounding was the revelation. Offset the rear pair by half a cycle from the front pair and the little quadruped stops walking and starts bounding — front legs and rear legs moving as pairs, the body pitching with each stride. It’s the gait cats use at speed, and it falls out of one parameter. I spent a long time just watching it, changing the number by a tenth and watching the behavior reorganize.

The lesson wasn’t “bounding exists.” The lesson was that coordination is a continuous space, not a menu of options. Walking, trotting, bounding — they’re neighborhoods in the same parameter space, and the boundaries between them are where the interesting physics lives.

Lab 3: geometric mechanics, or the week the math got beautiful

Lab 3 was the intellectual center of the course, and the hardest thing I’d done at USC to that point.

The robot: a three-link kinematic snake, two servos, moving on a surface. The question: given that you can only control the two joint angles, what joint trajectories produce the most forward motion — or the most rotation — per cycle?

The answer comes from geometric mechanics, and it’s one of the most beautiful ideas in robotics: your joints live in shape space (the space of α₁, α₂), your body lives in the world, and the map between joint velocity and body velocity is a connection. The net displacement from one gait cycle is the line integral of that connection around the loop your joints trace — and by Stokes’ theorem, that equals the surface integral of the curl of the connection over the area the loop encloses.

In plain language: to move forward, draw a loop in joint space that encloses as much positive curl as possible. The curl field is called the height function, and once you plot it, gait design becomes a visual, almost artistic act: find the bright regions, draw your loop around them.

I computed the connection fields for the 3-link snake (the denominator D = sin(α₁) − sin(α₂) + sin(α₁ − α₂), with singularities masked where it vanishes), plotted the height functions Hₓ and Hθ, and designed three gaits as circles in shape space:

• Forward, minimal rotation: center (−0.090, 0.045) rad, counterclockwise — sits in the strong positive Hₓ region while dodging high-Hθ zones
• Max counterclockwise rotation: center (0.765, 0.900) rad
• Max clockwise rotation: center (−0.900, −0.765) rad — the geometric mirror of the second

The Hx height function: bright regions are where a gait loop harvests the most forward motion per cycle. Gait design becomes drawing loops around the bright spots.

The Htheta landscape: mirror-symmetric about the origin — which is why the two rotation gaits are geometric mirrors of each other.

Then the lab asked the questions that turned computation into understanding. Is a circle optimal? (No — an ellipse aligned to the height-function ridge, or a contour-following path, encloses more curl per unit perimeter; circles are just the practical compromise.) Does the starting shape matter? (Net displacement per cycle: no — Stokes’ theorem doesn’t care where on the loop you start. World-frame trajectory: yes — like steering a car the same way from different initial headings.)

And then Task 4: take the gaits to hardware. Run the physical snake, measure actual displacement per cycle, and fill in the predicted-vs-measured comparison table. The course never let the math live alone. Every beautiful integral had to survive contact with a servo.

The Lab 3 snake running one of the designed gaits on the bench — the connection vector fields, made flesh (well, LEGO).

Learning to read papers

Somewhere in the middle of the semester I had to stand up and explain two research papers in ten minutes each, to people who’d read the same papers. That teaches you something no amount of reading does: you have to decide what the paper’s one idea is, and defend that choice out loud. It’s the conference-talk skill, compressed — and it’s changed how I read everything since.

Walking is a pendulum, running is a spring

The dynamics units gave me the vocabulary I still use. Walking is an inverted pendulum: the body’s center of mass vaults over a stiff leg, trading kinetic energy for gravitational potential energy and back. The rimless wheel model — a wheel with spokes but no rim, each spoke a step — captures it with shocking economy. Stability analysis via Poincaré maps and cobweb diagrams: does the gait converge back to itself after a perturbation, or fall over?

Running is a spring. The spring-loaded inverted pendulum (SLIP): the leg compresses on touchdown, stores energy, releases it at liftoff. Same center-of-mass curves as walking, reversed mechanism — gravity doing the work in one, the spring in the other.

What made it land wasn’t the equations alone — it was seeing them from someone who’d built the machines they described. The math stopped being abstract the moment it had a robot attached.

Terrain: where the course pointed at the project

The last lecture units — terrain adaptation on deformable and rough terrain — were the on-ramp to the final project. Granular media: how sand flows around an intruder, resistive force theory (RFT) for predicting forces on legs moving through grains, sidewinding on sand inclines, sand-swimming. The message: everything you learned about gaits assumed a rigid world. The real world deforms, and the physics changes.

My team took that message literally. Our project asked whether timed vibration — fluidizing the sand during leg swing, letting it compact during stance — could improve locomotion efficiency on granular media. Ten weeks, biweekly checkpoints, a bead testbed, current sensing, and a final report written like a conference paper.

The result was a null: cost of transport went from 50 to 77 once we honestly accounted for the vibration motors’ power draw. I’ve written the full story separately — the deep dive is here. What the semester gave me for that project wasn’t the idea — it was the habits: keep a predicted-vs-measured table, report the null instead of hiding it. Be wrong in public, carefully.

What stuck

A year later, here’s what I actually kept:

Motion is geometry before it’s force. Lab 3 rewired me. When I see a periodic system now — a gait, a switching converter, a control loop — I think in terms of loops in parameter space and what they enclose. That picture has leaked into everything.

Measure the thing you claim. Lab 1’s torque plots, Lab 3’s predicted-vs-measured tables, the project’s current sensor on the vibration rail — the course graded the comparison between theory and hardware, not the theory alone. My line about being “the person who notices when a metric lies about a signal” was born here, in the gap between a CoT of 49 and a CoT of 77.

Derive it yourself. The no-AI policy felt strict in week 2 and felt like a gift by week 10. The connection fields, the height functions, the gait centers — I can still reconstruct them because I built them by hand. Fluency isn’t having the answer; it’s having the path to the answer.

Research is a format, not a talent. Proposal, checkpoints, demo, conference-style report — the project taught the motions of research: hypothesis, experiment plan, preliminary data, honest discussion. You don’t need permission to do science; you need a lab notebook and a deadline.

Learn in the right order. Watch it move → build the physical picture → write the math → test it. I keep catching myself reversing that order on new topics — reaching for equations before I have a picture — and the picture-first version wins every time.

The quadruped from Labs 1–2 and the final project now lives on my projects page, with photos and video from the bead testbed. The full project writeup — hypothesis, firmware, and the honest null result — is here.

We built it. We measured it. It didn’t work. This is the honest version, with numbers.

Full test run on the granular testbed — the bounding gait carrying the quadruped across the bead bed.

The bet

Legged locomotion on granular media has a clean piece of physics behind it, from Li, Umbanhowar, Komsuoglu, and Goldman: on dense, packed sand a legged robot does efficient “rotary walking”; on loose, fluid-like sand the same robot degrades into “swimming” — lots of motion, no progress. The substrate’s state is the whole game.

Two more facts from the literature made the bet tempting:

1. Vibration fluidizes. Marston et al. showed a vibrating object penetrates sand with dramatically reduced resistance — the grains lose their force chains and flow.
2. Vibration compacts — after the fact. Stop shaking a box of grains and they settle denser and stronger than before (Raihane et al. and others). The aftermath of vibration is a firmer packing.

Nobody had combined the two into one gait cycle: shake during swing (low drag for the recovering leg), stop during stance (firm foothold for the pushing leg). Timed, intermittent, synchronized to the stride. Our research question: can a legged robot improve locomotor efficiency by cyclically switching the sand between fluid and solid in sync with its gait?

The machine

Four Dynamixel XL-320 servos, one degree of freedom per leg, on a rigid chassis. The gait is a Buehler clock — the standard trick for legged robots: each stride splits into a slow phase (stance, on the ground) and a fast phase (swing, in the air), set by the slow-phase extent, a phase offset, a duty cycle, and the stride period. Ours ran a bounding gait — front pair and rear pair half a period apart, 4-second period, 0.56 duty cycle.

The vibration system: six 14 mm coin motors — the kind that buzz in a phone — under the chassis, driven by two Adafruit DRV2605L haptic controllers (front pair on hardware I2C, rear pair on bit-banged software I2C, because of course we ran out of hardware buses). An Arduino orchestrated everything: legs in swing → vibrate; touchdown → keep vibrating 500 ms into stance to help the foot settle, then cut it.

The rig on the workbench: Arduino with the driver shield, coin vibration motors scattered around, and the DRV2605L wiring notes open on the laptop.

The part I’m proudest of isn’t the idea, it’s the instrumentation. The XL-320s report present load, so every 20 ms the firmware logged per-leg torque (load × stall torque) and mechanical power (torque × angular velocity), streaming tab-separated telemetry at 115200 baud. Plus the unglamorous hack the project needed: the XL-320 only positions over 0–300°, so when the Buehler clock commanded an angle inside the dead zone, the firmware flipped that servo to velocity mode, coasted through, and flipped back. Robots are 10% inspiration, 90% dead-zone handling.

The course built toward this honestly. Lab 1 was single-servo trajectories — theta vs. time, theta vs. torque plots. Lab 2 was open playground. Lab 3 was the measurement pipeline: the telemetry discipline, displacement tracking, the “how do you know what you claim” part. The final project was all of it at once, with sand.

The experiment

A wooden box of uniform white beads — macro-scale, spherical, standing in for sand. Zero incline. Cross 2 feet. Control run: bounding gait, no vibration. Experimental run: same gait, timed vibration. Metrics straight from the literature:

• Forward velocity, from video timing.
• Per-leg torque and power, from the servo telemetry.
• Cost of transport: CoT = P / (W * v) — power over weight times velocity. Dimensionless, the standard efficiency score. Lower is better.

The testbed: a wooden box of beads standing in for loose terrain.

The numbers

Read the honest column first. Leg power alone dropped from 2.37 W to 2.28 W — stop there and you’d write “marginal improvement” and move on. That’s the metric lying. The vibration motors drew 1.3 W, measured with an INA219 current sensor — more than half the legs’ power again — and the haptic rig added 50 g to a 275 g robot, an 18% mass penalty before it spent a single joule. Put it all in: CoT 50 → 77. Not a marginal win. A clear loss.

The terrain-interaction numbers back it up: peak stance torque — the ground’s yield force, the foothold quality — didn’t move (0.47–0.49 vs 0.47 N·m). Swing drag didn’t move either (0.144 vs 0.143 N·m). The vibration changed nothing about the sand. It just cost power and weight.

Why it failed

A scaling mismatch, and it’s the most useful thing we learned. Our “sand” was macro-scale beads with real individual inertia. Our vibration source was phone-haptic coin motors. In the literature where vibration fluidizes grains, the vibration is powerful relative to the particle size — ultrasonic shaking on fine powder. We had the ratio inverted: big beads form stable force chains, and a 14 mm coin motor cannot break them. There is a threshold power density for fluidization, and it scales with grain size. We were under it by an order of magnitude, not a rounding error.

What I’d do next

Two paths, both about fixing the ratio: fine silica sand (sub-millimeter grains), where the current motors might actually fluidize; or real actuators — geared eccentric masses, low frequency, high amplitude — that can physically displace the beads we had. The control strategy (timed, gait-synced) is still the right shape. It just needs an actuator that can win the fight it’s picking.

The point

I’m keeping this result because null results with good instrumentation are worth more than positive results with bad instrumentation. We know exactly how much it didn’t work, why, and what would change the answer. That’s not a failed project. That’s a measurement.

Built with Danie Craig Kulandai and Dhyanik Pujara — EE 579, Fall 2025. Firmware and report live in the project repo; the full writeup is on the project page.

I collected and published the EMAHA surface-EMG datasets (DB4–DB7) and co-authored the papers on how measurement conditions affect activity classification. This is the long version: what the datasets are, what we learned, where the EMG field has moved since (a lot, fast), the problems still unsolved, and where it’s going. Think of it as a map of the space my research sits in.

Introduction: why EMG suddenly matters

For decades, surface electromyography (sEMG) — reading the tiny electrical signals your muscles emit when they contract — lived mostly in research labs, prosthetics clinics, and sports-science studies. In 2025 that changed. Meta shipped the Neural Band, a wrist-worn EMG device that turns subtle finger movements into input for AR glasses, and Mark Zuckerberg publicly bet that this kind of interface will surpass the keyboard by the end of the decade. EMG went from “niche biosignal” to “the input layer for the next computing platform” in about two years.

That’s the arc this post traces: from the kind of careful, condition-controlled research datasets I worked on (2023–24), to the consumer neural interfaces and EMG foundation models of 2025–26 — and the hard, still-unsolved problems in between. If you’re getting into EMG, this is the lay of the land.

Part 1 — The EMAHA datasets (my corner of it)

EMAHA = ElectroMyography Analysis of Human Activity: a series of multi-channel sEMG datasets for classifying activities of daily living (ADL) and hand gestures, recorded with Noraxon Ultium wireless sensors. The series began with EMAHA-DB1 (Karnam, Turlapaty, Dubey & Gokaraju, IEEE Transactions on Instrumentation and Measurement, 2023): 25 subjects, 22 ADLs organized by the FAABOS taxonomy (Functional Arm Activity Behavioral Observation System), five sEMG sensors. DB4–DB7 — the ones I helped build — extend it.

(Confirm exact subject counts, channels, and labels on each Kaggle page before citing.) The defining idea: most EMG datasets fix one condition; EMAHA deliberately varies posture, arm position, pace, and load — so you can test whether a model survives a change in condition, not just whether it memorized one.

Part 2 — What our papers found

The datasets answer one question: how much do measurement conditions change sEMG-based ADL classification?

• Impact of Activity Pace and Arm Position on Classification of ADLs (EMBC 2024) — using the DB7 design, we showed pace and arm position are not nuisance details: they shift the signal and change accuracy. Features spanned time, frequency, wavelet, and eigenvalue domains.
• Fine-ADL Classification Using sEMG under Varying Measurement Conditions (BIOSIGNALS 2024) — the same idea pushed to fine-grained activity distinctions.
• Impact of Measurement Conditions on ADL Classification Using Surface EMG (ISPA 2023, Rome) — the earlier result establishing the effect.

The through-line: if you benchmark on a single condition, you overstate your accuracy. The honest test is train on one condition, test on another — and that gap is where EMG systems actually fail in the world.

Part 3 — Where the field is in 2026

This is what changed since our papers, and why they matter more now, not less.

Consumer neural interfaces arrived. Meta’s Neural Band (announced Meta Connect 2025, released Sep 30 2025; the first product from Meta’s 2019 CTRL-Labs acquisition, bundled with Ray-Ban Display glasses at $799) reads wrist sEMG for text entry and gesture control. The science behind it — Meta’s Nature 2025 paper, “A generic non-invasive neuromotor interface for human-computer interaction” — is the headline result: trained on ~200,000 participants, it generalizes across users with no per-person calibration. That “works out of the box for a stranger’s arm” property is the holy grail EMG spent decades chasing.

EMG is going the “foundation model” route. Large, multi-user datasets (e.g. Meta’s emg2qwerty typing corpus) and models trained on them now show robust zero-shot cross-user gesture recognition, and tiny on-device foundation models like TinyMyo are pushing flexible EMG processing to the edge. The playbook that transformed NLP — scale + pretraining + transfer — is now being applied to muscle signals.

The hardware is getting wearable. The classic blocker was wet gel electrodes. New dry electrodes — micro-textured soft composites, textile-based, 3D-printed, and high-density dry arrays — are making all-day, motion-tolerant EMG plausible in a consumer band.

The company landscape: Meta/CTRL-Labs (AR input), Mudra / Wearable Devices (neural wristbands to control phones, even EMG-based weight estimation), Pison, Delsys and Noraxon (research-grade systems), plus new form factors like EMG-to-speech necklaces and synthetic EMG generation to fight data scarcity. Applications now span AR/VR input, prosthetics, silent-speech, robotics teleoperation, and rehabilitation.

Part 4 — The hard problems (still open)

Here’s the honest part, and it’s exactly where datasets like EMAHA connect to the frontier:

1. Cross-user generalization. EMG is intensely personal — muscle anatomy, skin conductivity, fat, electrode placement all differ. Models trained on one set of users degrade on new ones. Meta’s whole achievement was reducing this; it’s far from fully solved.
2. Electrode shift & placement. Move the band a centimeter, or let the limb move, and the signal shifts. Robustness to this is an active research area (data augmentation, spatial normalization, HD arrays).
3. Long-term, real-world robustness. Sweat, hydration, motion artifacts, multi-day wear — the lab-to-life gap that even Meta flags as unsolved.
4. Calibration burden. Every minute a user spends calibrating is friction; the field is racing toward zero-calibration, generic models.
5. Data diversity. Big, condition-diverse datasets are the bottleneck — hence synthetic data and large-scale collection efforts.

Why EMAHA fits here: condition-varied datasets are a controlled microcosm of problems (2)–(5). If you want to measure whether a model is robust to pace, arm position, or load before you ship it to a stranger’s wrist, you need exactly the kind of labeled-condition data these datasets provide.

Part 5 — Where it’s heading (future work)

• EMG foundation models + few-shot personalization — pretrain on massive multi-user data, adapt to a new user in seconds via domain adaptation instead of long calibration.
• Multimodal fusion — EMG + IMU + vision, so gesture systems use motion and context, not muscle alone.
• EMG as an input layer for LLMs/agents — silent typing, intent, and “neural text entry” feeding language models; EMG-to-speech for accessibility.
• Robotics teleoperation & prosthetics — richer, continuous control (force, not just discrete gestures; note Wearable Devices’ weight-estimation work).
• On-device tiny models — TinyMyo-style edge inference for latency, privacy, and battery.
• Robustness benchmarks — the field needs standard cross-condition / cross-user evaluations. This is a place where an EMAHA-style, condition-labeled dataset directly contributes.

Conclusion

In two years EMG went from a specialist research signal to the input layer of a shipping consumer product, and the research playbook flipped from “hand-tuned features on one condition” to “large models pretrained across hundreds of thousands of users.” But the core problem hasn’t changed — it’s just gotten a bigger spotlight: EMG signals refuse to generalize. Different bodies, shifting electrodes, sweat, and movement all conspire against the model.

That’s the exact problem the EMAHA datasets were built to probe. Studying how pace, arm position, and load change the signal isn’t a footnote to the Meta era — it’s a controlled way to measure the robustness that the Meta era still hasn’t fully won. Whether you’re building a prosthetic, an AR wristband, or an EMG foundation model, the question is the same: does it still work when the condition changes? If you build something with these datasets that helps answer that, I’d love to hear about it.

Links & references

• Datasets: DB4 · DB5 · DB6 · DB7 · Lab dataset page
• Foundational paper: EMAHA-DB1 (arXiv 2301.03325)
• Our conditions paper: Pace & Arm Position on ADLs, EMBC 2024
• Meta Neural Band / Nature 2025: Neural Band overview · the generic-interface result
• Foundation models / big-data EMG: TinyMyo (arXiv) · large multi-user zero-shot
• Dry electrodes: micro-textured soft dry electrode (Wiley Small 2026) · high-density dry array (arXiv)
• Other directions: EMG-to-speech necklace · synthetic EMG generation · Mudra / Wearable Devices · Delsys

About

I’m Vidya Sagar Reddy Venna — I led data collection for EMAHA-DB4–DB7 during my honours research at the Human Movement Analysis Lab and co-authored the measurement-conditions papers above. Datasets are published by Anish Turlapaty et al. on Kaggle.

What is EMG?

Electromyography (EMG) measures the electrical activity produced by skeletal muscles. Surface EMG (sEMG) uses electrodes placed on the skin to detect these signals non-invasively, making it ideal for applications in rehabilitation, prosthetics control, and human-computer interaction.

Setting Up Your Environment

First, let’s install the necessary Python libraries:

pip install numpy scipy matplotlib pandas

For this tutorial, we’ll use NumPy for numerical operations, SciPy for signal processing, and Matplotlib for visualization.

Loading and Visualizing EMG Data

Let’s start by loading a sample EMG signal and visualizing it:

import numpy as np
import matplotlib.pyplot as plt
from scipy import signal

# Load your EMG data (example)
# data = np.loadtxt('emg_data.csv')
# For demo, let's create synthetic data
fs = 1000  # Sampling frequency (Hz)
t = np.linspace(0, 2, 2*fs)
emg_signal = np.random.randn(len(t)) * 0.1

# Plot raw signal
plt.figure(figsize=(12, 4))
plt.plot(t, emg_signal)
plt.xlabel('Time (s)')
plt.ylabel('Amplitude (mV)')
plt.title('Raw EMG Signal')
plt.grid(True)
plt.show()

Signal Preprocessing

Raw EMG signals typically contain noise and artifacts. Here’s a standard preprocessing pipeline:

1. Band-pass Filtering

Remove low-frequency motion artifacts and high-frequency noise:

# Design bandpass filter (20-450 Hz)
low_cutoff = 20
high_cutoff = 450
order = 4

# Butterworth bandpass filter
b, a = signal.butter(order, [low_cutoff, high_cutoff],
                     btype='band', fs=fs)
filtered_signal = signal.filtfilt(b, a, emg_signal)

2. Rectification

Take the absolute value to get the signal envelope:

rectified_signal = np.abs(filtered_signal)

3. Envelope Detection

Apply low-pass filter for smooth envelope:

# Low-pass filter at 10 Hz
envelope_cutoff = 10
b_env, a_env = signal.butter(order, envelope_cutoff,
                             btype='low', fs=fs)
envelope = signal.filtfilt(b_env, a_env, rectified_signal)

Onset Detection

Detecting when muscle activation begins is crucial for many applications. A simple threshold-based approach:

def detect_onset(signal, threshold_factor=3, min_duration=0.05):
    """
    Detect muscle activation onset

    Parameters:
    -----------
    signal : array
        Processed EMG signal
    threshold_factor : float
        Multiplier of baseline standard deviation
    min_duration : float
        Minimum duration (seconds) to be considered onset

    Returns:
    --------
    onsets : array
        Indices of detected onsets
    """
    # Calculate baseline (first 10% of signal)
    baseline = signal[:int(len(signal)*0.1)]
    threshold = np.mean(baseline) + threshold_factor * np.std(baseline)

    # Find points above threshold
    above_threshold = signal > threshold

    # Find onset points (transitions from False to True)
    onsets = np.where(np.diff(above_threshold.astype(int)) == 1)[0]

    return onsets, threshold

Feature Extraction

Common features used for EMG analysis:

def extract_features(signal, window_size=200):
    """Extract time-domain EMG features"""

    # Root Mean Square (RMS)
    rms = np.sqrt(np.mean(signal**2))

    # Mean Absolute Value (MAV)
    mav = np.mean(np.abs(signal))

    # Variance
    var = np.var(signal)

    # Zero Crossings
    zc = np.sum(np.diff(np.sign(signal)) != 0)

    return {
        'RMS': rms,
        'MAV': mav,
        'Variance': var,
        'Zero_Crossings': zc
    }

Practical Applications

This basic pipeline forms the foundation for many EMG applications:

• Prosthetics Control: Pattern recognition for controlling robotic limbs
• Rehabilitation: Monitoring muscle activation during physical therapy
• Gesture Recognition: Human-computer interaction through muscle movements
• Fatigue Assessment: Tracking muscle fatigue in sports or workplace ergonomics

Next Steps

This tutorial covered the basics, but there’s much more to explore:

• Advanced filtering techniques (adaptive filters, wavelet denoising)
• Frequency-domain analysis (power spectral density, median frequency)
• Machine learning for pattern classification
• Real-time processing considerations

Resources

Check out these resources for deeper learning:

• Our open-source EMAHA-DB datasets on GitHub
• SciPy signal processing documentation
• Research papers on EMG classification techniques