Walking FES — full application walkthrough

examples/walking_fes/
├── main.py                         ← Entry point (dual-process launcher)
├── backend_mainloop.py             ← Backend coordinator (wraps ClosedLoopEngine)
├── walking_control_strategy.py     ← SwingStanceAdaptiveWalkingStrategy
├── waking_utils.py                 ← Gait phase utilities (4 utility classes)
└── gui/
    ├── main_window.py              ← MainWindow (3 tabs)
    ├── data_handler.py             ← Data routing to GUI components
    ├── tabs/
    │   ├── overview_tab.py         ← FES controls + step indicators
    │   ├── biomechanics_tab.py     ← Real-time joint angle plots
    │   └── gait_statistics_tab.py  ← Phase duration statistics
    └── widgets/                    ← Custom widgets (sliders, bar charts)

# Simplified version of examples/walking_fes/main.py
if __name__ == "__main__":
    freeze_support()

    utility_queue = Queue()
    control_queue = Queue()

    # Start backend in subprocess
    backend_process = Process(
        target=run_backend_process,
        args=(control_queue, utility_queue)
    )
    backend_process.start()

    time.sleep(5)  # Wait for Teslasuit hardware initialisation

    # Run GUI in main process
    run_gui(control_queue=control_queue, utility_queue=utility_queue)

# Modern equivalent of BackendMainloop:
from fes_framework.engine import ClosedLoopEngine
from examples.walking_fes.walking_control_strategy import SwingStanceAdaptiveWalkingStrategy

engine = ClosedLoopEngine(
    control_strategy=SwingStanceAdaptiveWalkingStrategy(),
    control_queue=control_queue,
    utility_queue=utility_queue,
)
engine.run()

class SwingStanceAdaptiveWalkingStrategy(
    SwingStanceAdaptiveScheduler,   # timing window management
    LegsEMSParameterUpdater,        # activate/deactivate methods
    ControlStrategyBase             # must be last in MRO
):
    def process(self) -> None:
        self.internal_logic_loop()

Step 1:  _check_swing_to_stance_transition_()
         Detect stance↔swing transitions for both legs by comparing
         current vs. previous foot contacts.

Step 2:  update_gait_timings()
         Update measured phase durations and running averages.
         Stance duration = time since last swing→stance transition.
         Swing duration  = time since last stance→swing transition.

Step 3:  update_stimulation_timeline_if_transition_occurs()
         When a transition occurs, recalculate absolute stimulation
         start/end times for all muscles based on measured durations.

Step 4:  _update_previous_foot_contact_()
         Cache current foot contact states for next cycle comparison.

Step 5:  check_is_standing() → if True, deactivate_all_stimulation()
         If both feet are on ground for > 1 second, enter standing mode.

Step 6:  LEFT LEG — stance or swing phase stimulation logic
         For each of the 5 muscles:
           if elapsed_time > start_time AND < end_time: activate
           else: deactivate

Step 7:  RIGHT LEG — same logic, mirrored

Stance phase duration = (measured from foot contact to lift-off)
    quadriceps window = [stance_start × duration, stance_end × duration]

Swing phase duration = (measured from lift-off to foot contact)
    quadriceps window = [swing_start × duration, swing_end × duration]

left_stance_to_swing_transition   # True for one cycle when left foot lifts
left_swing_to_stance_transition   # True for one cycle when left foot contacts
right_stance_to_swing_transition  # True for one cycle when right foot lifts
right_swing_to_stance_transition  # True for one cycle when right foot contacts

# Activate left quadriceps using params from ControlMessage:
self.activate_stimulation_left_quadriceps()

# Deactivate:
self.deactivate_stimulation_left_quadriceps()

# Available for all 10 lower-body muscles used in the walking strategy:
# activate/deactivate_stimulation_{side}_{muscle}
# where side: left/right, muscle: quadriceps/hamstring/gastrocnemius/tibialis/gluteus

cd fes_framework
python examples/walking_fes/main.py

Project root added to Python path: C:\path\to\fes_framework
Starting backend process...
[Backend] Connecting to Teslasuit hardware...
[Backend] SuitHandler initialised
[Backend] DataStreamer ready
[Backend] CalibrationAPI ready
(5 second wait for hardware init)
Starting production GUI...
QApplication created successfully
MainWindow created successfully
GUI window shown, starting event loop

# 1. Start from the control strategy pattern
from fes_framework.control.strategy_base import ControlStrategyBase
from examples.walking_fes.waking_utils import (
    SwingStanceAdaptiveScheduler,
    LegsEMSParameterUpdater,
)

class MyWalkingStrategy(SwingStanceAdaptiveScheduler,
                        LegsEMSParameterUpdater,
                        ControlStrategyBase):
    """Custom walking strategy building on Walking FES utilities."""

    def process(self) -> None:
        # Use Walking FES utilities for phase detection:
        self._check_swing_to_stance_transition_()
        self.update_gait_timings()
        self.update_stimulation_timeline_if_transition_occurs()
        self._update_previous_foot_contact_()

        # Add your own logic:
        if self.contacts.right_foot_contact:
            elapsed = time.time() - self.LOCAL_TIMER_START_TIME["RightStance"]
            if elapsed < 0.4:   # first 400ms of stance
                self.activate_stimulation_right_quadriceps()
            else:
                self.deactivate_stimulation_right_quadriceps()

# 2. Create a ControlMessage with your parameters
from dataclasses import dataclass, field
from fes_framework.data.types import ControlMessage, _default_stim_params

@dataclass
class MyControlMessage(ControlMessage):
    quadriceps_right: dict = field(default_factory=_default_stim_params)
    # ... add more muscles

# 3. Launch the application
from fes_framework.orchestrator import launch
from my_gui import my_gui_runner

if __name__ == "__main__":
    launch(
        MyWalkingStrategy,
        gui_runner=my_gui_runner,
        hardware_init_delay=5.0,
    )