electronic-mcp-server: Skill for Claude Code

Mermaid Diagram Generator

Generates Mermaid diagrams from Arduino code to visualize state machines, timing, architecture, and workflows.

Resources

• scripts/generate_diagram.py - Python script with PEP 723 inline dependencies
• references/diagram-templates.md - Mermaid templates for common patterns
• assets/examples/ - Example diagrams for reference

Quick Start

# Generate state machine diagram from Arduino code
uv run mermaid-diagram-generator/scripts/generate_diagram.py \
    --input src/main.ino \
    --type state-machine \
    --output docs/state-machine.mmd

# Generate timing diagram for I2C communication
uv run mermaid-diagram-generator/scripts/generate_diagram.py \
    --type timing \
    --signals "SDA,SCL,START,DATA,STOP" \
    --output docs/i2c-timing.mmd

# Interactive mode
uv run mermaid-diagram-generator/scripts/generate_diagram.py --interactive

When to Use

Use this skill when:

• Visualizing state machines - FSM from switch/case or enum states
• Documenting timing - I2C, SPI, UART protocol sequences
• Architecture diagrams - Show task relationships in FreeRTOS
• Flowcharts - Visualize control flow for complex logic
• Sequence diagrams - Inter-task communication patterns

Don't use when:

• ❌ Simple code (3-5 lines) doesn't need visualization
• ❌ No state/timing complexity to illustrate

Core Principles

1. Code Analysis - Parse Arduino code to extract states, transitions, timing
2. Template Selection - Choose appropriate Mermaid diagram type
3. Auto-Generation - Produce valid Mermaid syntax from code patterns
4. Validation - Check diagram syntax before output
5. Integration - Embed diagrams in README.md or documentation

Implementation

Pattern 1: State Machine Extraction

#!/usr/bin/env python3
# /// script
# requires-python = ">=3.8"
# dependencies = ["re"]
# ///

"""Extract state machine from Arduino code."""

import re

def extract_states(code):
    """Find enum states or #define constants."""
    states = []
    
    # Pattern 1: enum StateType { STATE_A, STATE_B, ... }
    enum_pattern = r'enum\s+\w+\s*\{([^}]+)\}'
    enum_match = re.search(enum_pattern, code)
    if enum_match:
        states_str = enum_match.group(1)
        states = [s.strip().split('=')[0].strip() 
                 for s in states_str.split(',') if s.strip()]
    
    # Pattern 2: #define STATE_A 0
    define_pattern = r'#define\s+(STATE_\w+)\s+\d+'
    states += re.findall(define_pattern, code)
    
    return list(set(states))

def extract_transitions(code, states):
    """Find state transitions in code."""
    transitions = []
    
    for i, state in enumerate(states):
        # Look for assignments: currentState = NEXT_STATE
        pattern = rf'{state}.*?=\s*(\w+)'
        matches = re.findall(pattern, code)
        
        for next_state in matches:
            if next_state in states and next_state != state:
                transitions.append((state, next_state))
    
    return transitions

# Example usage
arduino_code = '''
enum State {
    STATE_IDLE,
    STATE_READING,
    STATE_PROCESSING,
    STATE_DONE
};

State currentState = STATE_IDLE;

void loop() {
    switch(currentState) {
        case STATE_IDLE:
            if (buttonPressed()) {
                currentState = STATE_READING;
            }
            break;
        case STATE_READING:
            readSensor();
            currentState = STATE_PROCESSING;
            break;
        case STATE_PROCESSING:
            processData();
            currentState = STATE_DONE;
            break;
        case STATE_DONE:
            currentState = STATE_IDLE;
            break;
    }
}
'''

states = extract_states(arduino_code)
transitions = extract_transitions(arduino_code, states)

print("States:", states)
print("Transitions:", transitions)