A production-grade embedded system enabling communication across speech, text, Morse, and haptic sig

ds dynamically adapt to user cadence.

• State Machine Architecture: Event-driven transitions between IDLE, DOT, DASH, CHARACTER_COMPLETE, WORD_COMPLETE, and ERROR states. Watchdog timers enforce timeout-based segmentation.
• Haptic & Audio Output: PWM drives the LRA at its resonant frequency (~200Hz) for efficient vibration. Active buzzer provides audio fallback. Both are scheduled via non-blocking state transitions to prevent blocking the main loop.
• Hardware Protections: Integrated PMIC manages Li-ion charging with overcharge, deep-discharge, short-circuit, and thermal cutoff thresholds. Brown-out reset (BOR) prevents MCU corruption during voltage sag.

Representative Code: Interrupt-Driven Morse Decoder (ATmega328P)

// ATmega328P Interrupt-Driven Morse State Machine
volatile uint32_t pulse_start = 0;
volatile uint32_t pulse_width = 0;
volatile enum { IDLE, DOT, DASH, CHAR_DONE, WORD_DONE } state = IDLE;

ISR(INT0_vect) {
    if (digitalRead(SWITCH_PIN) == HIGH) {
        pulse_start = micros();
        state = IDLE;
    } else {
        pulse_width = micros() - pulse_start;
        if (pulse_width < DOT_THRESHOLD) {
            state = DOT;
        } else if (pulse_width < DASH_THRESHOLD) {
            state = DASH;
        } else {
            state = WORD_DONE; // Long pause indicates word boundary
        }
        pulse_start = 0;
    }
}

void loop() {
    switch(state) {
        case DOT:
            buffer_append('.');
            state = IDLE;
            break;
        case DASH:
            buffer_append('-');
            state = IDLE;
            break;
        case WORD_DONE:
            decode_morse_to_text(buffer);
            transmit_via_uart();
            clear_buffer();
            state = IDLE;
            break;
        default:
            // Check inter-element timeout for character boundary
            if (micros() - last_pulse > CHAR_TIMEOUT) {
                state = CHAR_DONE;
            }
            break;
    }
    schedule_haptic_pwm();
}

Pitfall Guide

1. OS Jitter Contamination: Running real-time I/O on a general-purpose OS introduces non-deterministic scheduling delays. Best Practice: Strictly isolate time-critical operations (sensor polling, timing measurement, actuator driving) to a dedicated MCU with hardware interrupts and deterministic execution loops.
2. Fixed Morse Timing Thresholds: Hardcoded dot/dash boundaries fail across users with varying input speeds or fatigue levels. Best Practice: Implement adaptive timing windows using rolling averages or calibration routines that adjust DOT_THRESHOLD and DASH_THRESHOLD based on recent input history.
3. Li-ion Battery Mismanagement: Portable assistive devices risk thermal runaway, capacity degradation, or sudden brownouts. Best Practice: Use a dedicated PMIC with hardware-enforced overcharge, deep-discharge, and thermal cutoffs. Implement software-level voltage monitoring with graceful degradation (e.g., disable TTS, reduce PWM duty cycle) before hard shutdown.
4. Bluetooth Stack Latency & Packet Loss: Classic Bluetooth (HC-05) introduces variable latency and lacks built-in flow control for real-time streams. Best Practice: Implement application-level ACK/retry mechanisms, use UART with hardware flow control (RTS/CTS if available), and buffer critical packets to prevent data corruption during RF interference.
5. State Machine Ambiguity: Missing explicit idle/timeout states or overlapping transitions cause mode confusion and decoding drift. Best Practice: Enforce strict state transitions with explicit watchdog timers. Every state must have a defined exit condition (timeout, valid input, or error reset) to prevent lockup.
6. PWM Haptic Resonance Mismatch: Driving an LRA with arbitrary PWM frequencies drastically reduces efficiency and tactile clarity. Best Practice: Match PWM frequency to the LRA's mechanical resonant frequency (~180–220Hz). Use back-EMF sensing or impedance matching if available, and limit duty cycle to prevent coil overheating.

Deliverables

• 📘 Architecture Blueprint: Dual-layer system topology diagram detailing signal flow (Speech ⇄ Text ⇄ Morse ⇄ Haptic), component interconnects (Pi ↔ UART/Bluetooth ↔ ATmega328P), power distribution network, and protection circuit placement. Includes timing budget allocation and interrupt priority mapping.
• ✅ Validation Checklist:
  • Hardware: PMIC threshold verification, LRA resonance tuning, BT pairing stability, SPDT switch debouncing, thermal cutoff validation.
  • Software: State machine coverage (all transitions tested), timing window calibration, UART buffer overflow handling, STT/TTS pipeline fallback verification.
  • Safety: Brown-out reset behavior, deep-discharge cutoff, short-circuit response, emergency stop mechanism.
• ⚙️ Configuration Templates:
  • morse_timing.cfg: Adaptive threshold parameters, inter-element/character/word spacing ratios, timeout values.
  • uart_bt_config.yaml: Baud rate, parity, stop bits, flow control flags, packet framing structure, ACK/retry intervals.
  • haptic_pwm_table.csv: Duty cycle vs. vibration intensity mapping, resonant frequency settings, thermal limit thresholds.
  • pi_pipeline.env: STT/TTS engine flags, Morse lookup table path, Bluetooth service UUID, logging levels, and fallback modes.