diff --git a/src/mcp_arduino_server/components/__init__.py b/src/mcp_arduino_server/components/__init__.py index 9fce50c..f155fa0 100644 --- a/src/mcp_arduino_server/components/__init__.py +++ b/src/mcp_arduino_server/components/__init__.py @@ -9,6 +9,7 @@ from .client_debug import ClientDebugInfo from .port_checker import PortConflictDetector, port_checker from .serial_manager import SerialConnectionManager from .wireviz import WireViz +from .wireviz_prompts import WireVizPrompts __all__ = [ "ArduinoBoard", @@ -16,6 +17,7 @@ __all__ = [ "ArduinoLibrary", "ArduinoSketch", "WireViz", + "WireVizPrompts", "ClientDebugInfo", "ClientCapabilitiesInfo", "SerialConnectionManager", diff --git a/src/mcp_arduino_server/components/wireviz_prompts.py b/src/mcp_arduino_server/components/wireviz_prompts.py new file mode 100644 index 0000000..6a405ed --- /dev/null +++ b/src/mcp_arduino_server/components/wireviz_prompts.py @@ -0,0 +1,784 @@ +""" +Advanced WireViz Prompt System for Circuit Diagram Generation +Provides intelligent, guided prompts for creating professional circuit diagrams +""" + +from fastmcp.contrib.mcp_mixin import MCPMixin, mcp_prompt +from fastmcp import Context +from pydantic import BaseModel, Field +from typing import Dict, List, Optional, Any +import logging + +try: + from fastmcp.contrib.elicitation import ( + mcp_elicitation, + QuestionType, + ElicitationContext + ) + ELICITATION_AVAILABLE = True +except ImportError: + ELICITATION_AVAILABLE = False + +log = logging.getLogger(__name__) + + +class CircuitComponent(BaseModel): + """Represents a circuit component with specifications""" + name: str + type: str # "microcontroller", "sensor", "actuator", "display", etc. + pins: List[str] + power_requirements: Optional[str] = None + description: Optional[str] = None + + +class WiringConnection(BaseModel): + """Represents a wiring connection between components""" + from_component: str + from_pin: str + to_component: str + to_pin: str + wire_color: Optional[str] = None + wire_gauge: Optional[str] = None + + +class CircuitSpecification(BaseModel): + """Complete circuit specification for WireViz generation""" + project_name: str + description: str + components: List[CircuitComponent] + connections: List[WiringConnection] + power_supply: str + notes: Optional[List[str]] = None + + +class WireVizPrompts(MCPMixin): + """Advanced prompts for guided WireViz circuit creation""" + + def __init__(self, config): + self.config = config + + @mcp_prompt + async def circuit_assistant( + self, + project_type: str = Field(description="Type of project (sensor_monitoring, home_automation, robotics, iot_device, led_effects, motor_control)"), + skill_level: str = Field(description="Your experience level (beginner, intermediate, advanced)"), + components_available: str = Field(default="", description="Components you have available (comma-separated list)") + ) -> str: + """Interactive circuit design assistant""" + + component_suggestions = self._get_project_components(project_type) + skill_guidance = self._get_skill_guidance(skill_level) + + return f"""# 🔌 Circuit Design Assistant + +## Project: {project_type.title().replace('_', ' ')} + +### 📋 Recommended Components for {project_type}: +{component_suggestions} + +### 🎯 Guidance for {skill_level} Level: +{skill_guidance} + +### 🔧 Component Analysis: +{self._analyze_available_components(components_available) if components_available else "No components specified - I'll suggest a complete parts list"} + +### ⚡ Next Steps: +1. **Confirm your component selection** +2. **Specify your Arduino board** (Uno, Nano, ESP32, etc.) +3. **Describe the specific functionality** you want to achieve +4. **I'll generate a professional wiring diagram** with proper wire colors, pin assignments, and safety considerations + +### 💡 Pro Tips: +- **Wire Colors**: I'll use standard colors (Red: 5V, Black: GND, etc.) +- **Pin Selection**: I'll choose optimal pins for your components (PWM for LEDs, interrupt pins for sensors) +- **Power Management**: I'll include proper power distribution and decoupling +- **Safety**: All connections will follow electrical safety standards + +**Ready to design your circuit? Just tell me more about what you want to build!** +""" + + @mcp_prompt + async def sensor_circuit_builder( + self, + sensor_types: str = Field(description="Types of sensors (temperature, humidity, pressure, light, motion, distance, etc.)"), + data_output: str = Field(description="How to output data (serial_monitor, lcd_display, sd_card, wifi_cloud, all)"), + power_source: str = Field(default="usb", description="Power source (usb, battery, solar, mains)") + ) -> str: + """Specialized sensor circuit building prompt""" + + sensors = [s.strip() for s in sensor_types.split(',')] + outputs = [o.strip() for o in data_output.split(',')] + + sensor_specs = self._get_sensor_specifications(sensors) + output_components = self._get_output_components(outputs) + power_design = self._get_power_design(power_source) + + return f"""# 📊 Professional Sensor Monitoring Circuit + +## 🎯 Project Overview +**Sensors**: {', '.join(sensors)} +**Data Output**: {', '.join(outputs)} +**Power Source**: {power_source} + +## 🔬 Sensor Specifications +{sensor_specs} + +## 📺 Output Components +{output_components} + +## ⚡ Power Design +{power_design} + +## 🧩 Intelligent Pin Assignment +I'll automatically assign pins based on sensor requirements: +- **Analog Sensors** → A0-A5 (with proper voltage dividers if needed) +- **Digital Sensors** → Digital pins with pullups where required +- **I2C Devices** → SDA/SCL with pullup resistors +- **SPI Devices** → Hardware SPI pins for maximum speed +- **PWM Outputs** → PWM-capable pins for any analog outputs + +## 📐 Circuit Features I'll Include +- ✅ **Proper Pull-up/Pull-down Resistors** for digital signals +- ✅ **Decoupling Capacitors** for stable power +- ✅ **Level Shifters** if mixing 3.3V and 5V components +- ✅ **Protection Diodes** for inductive loads +- ✅ **Clear Wire Labeling** with standard color coding +- ✅ **Professional Connector Layout** for easy assembly + +**Describe your specific measurement requirements and I'll generate a production-ready wiring diagram!** +""" + + @mcp_prompt + async def iot_device_designer( + self, + device_purpose: str = Field(description="What the IoT device does (weather_station, plant_monitor, security_system, etc.)"), + connectivity: str = Field(description="Connection type (wifi, bluetooth, lora, cellular)"), + deployment_location: str = Field(default="indoor", description="Where it will be used (indoor, outdoor, mobile, fixed)") + ) -> str: + """IoT device circuit design prompt""" + + connectivity_specs = self._get_connectivity_specs(connectivity) + environmental_considerations = self._get_environmental_specs(deployment_location) + iot_components = self._get_iot_components(device_purpose) + + return f"""# 🌐 Professional IoT Device Circuit Design + +## 📡 IoT Device: {device_purpose.title().replace('_', ' ')} +**Connectivity**: {connectivity.upper()} +**Environment**: {deployment_location.title()} + +## 🔗 Connectivity Specifications +{connectivity_specs} + +## 🏠 Environmental Considerations +{environmental_considerations} + +## 🧰 Recommended IoT Components +{iot_components} + +## 🔋 Smart Power Management +For IoT devices, I'll design efficient power management: +- **Sleep Modes** between sensor readings +- **Voltage Regulation** for stable operation +- **Battery Monitoring** with low-voltage alerts +- **Charging Circuits** for rechargeable systems + +## 📊 Data Flow Architecture +1. **Sensor Reading** → Microcontroller +2. **Local Processing** → Data validation and filtering +3. **Connectivity Module** → WiFi/Bluetooth/LoRa transmission +4. **Cloud Integration** → MQTT, HTTP, or custom protocols +5. **Local Display** → Status indication and diagnostics + +## 🛡️ Production Features I'll Include +- ✅ **Antenna Placement** for optimal signal strength +- ✅ **EMI Protection** with proper grounding +- ✅ **Watchdog Circuits** for reliable operation +- ✅ **Debug Interfaces** for troubleshooting +- ✅ **Status LEDs** for visual feedback +- ✅ **Reset Buttons** for manual recovery + +**Tell me your specific IoT requirements and I'll create a professional, production-ready circuit diagram!** +""" + + @mcp_prompt + async def motor_control_expert( + self, + motor_types: str = Field(description="Types of motors (servo, stepper, dc_motor, brushless, linear_actuator)"), + control_precision: str = Field(description="Required precision (basic_positioning, precise_positioning, speed_control, torque_control)"), + safety_features: str = Field(default="", description="Required safety features (emergency_stop, current_limiting, encoder_feedback, thermal_protection)") + ) -> str: + """Motor control circuit design expert""" + + motors = [m.strip() for m in motor_types.split(',')] + motor_specs = self._get_motor_specifications(motors) + precision_requirements = self._get_precision_specs(control_precision) + safety_circuits = self._get_safety_circuits(safety_features) + + return f"""# ⚙️ Professional Motor Control Circuit Design + +## 🔧 Motor Configuration +**Motor Types**: {', '.join(motors)} +**Control Precision**: {control_precision.replace('_', ' ').title()} +**Safety Features**: {safety_features.replace('_', ' ').title() if safety_features else 'Basic'} + +## 🎛️ Motor Driver Specifications +{motor_specs} + +## 🎯 Precision Control Requirements +{precision_requirements} + +## 🛡️ Safety Circuit Design +{safety_circuits} + +## ⚡ Power Distribution Design +For motor control, I'll design robust power systems: +- **Separate Motor Power** from logic power (prevents noise) +- **Current Limiting** circuits to protect motors and drivers +- **Flyback Diodes** for inductive load protection +- **Capacitor Banks** for motor start-up current +- **Emergency Stop** circuits with fail-safe operation + +## 📐 Advanced Control Features +- ✅ **PWM Speed Control** with proper frequencies +- ✅ **Direction Control** with H-bridge circuits +- ✅ **Encoder Interfaces** for position feedback +- ✅ **Current Sensing** for load monitoring +- ✅ **Thermal Management** with temperature monitoring +- ✅ **Communication Buses** (CAN, RS485) for complex systems + +## 🔍 Professional Motor Control Features +- **Smooth Acceleration/Deceleration** profiles +- **Stall Detection** and recovery +- **Position Homing** sequences +- **Multi-axis Coordination** for complex movements +- **Real-time Control** with interrupt-driven timing + +**Describe your specific motor control application and I'll generate an industrial-grade control circuit!** +""" + + def _get_project_components(self, project_type: str) -> str: + """Get component suggestions based on project type""" + components_db = { + "sensor_monitoring": """ +• **Arduino Uno/Nano** - Main microcontroller +• **DHT22** - Temperature/humidity sensor +• **BMP280** - Pressure sensor +• **16x2 LCD** - Data display +• **SD Card Module** - Data logging +• **RTC Module** - Timestamping +• **Breadboard & Jumper Wires**""", + + "home_automation": """ +• **ESP32/ESP8266** - WiFi-enabled microcontroller +• **Relay Modules** - Control AC devices +• **PIR Motion Sensor** - Occupancy detection +• **Light Sensor (LDR)** - Ambient light +• **Temperature Sensor** - Climate control +• **OLED Display** - Status indication +• **Push Buttons** - Manual controls""", + + "robotics": """ +• **Arduino Mega** - Multiple pin requirements +• **Servo Motors** - Precise positioning +• **Ultrasonic Sensor (HC-SR04)** - Distance measurement +• **Motor Driver (L298N)** - DC motor control +• **IMU/Gyroscope** - Orientation sensing +• **Wheel Encoders** - Position feedback +• **Bluetooth Module** - Remote control""", + + "iot_device": """ +• **ESP32** - Built-in WiFi and Bluetooth +• **Various Sensors** - Based on application +• **OLED Display** - Local status +• **Deep Sleep Circuit** - Battery efficiency +• **Voltage Regulator** - Stable power +• **Antenna** - Signal optimization +• **Capacitive Touch** - User interface""", + + "led_effects": """ +• **Arduino Nano** - Compact form factor +• **WS2812B LED Strip** - Addressable RGB LEDs +• **Potentiometer** - Brightness control +• **Push Buttons** - Effect selection +• **Power Supply** - Adequate current capacity +• **Level Shifter** - 3.3V to 5V logic +• **Capacitors** - Power smoothing""", + + "motor_control": """ +• **Arduino Uno/Mega** - Based on motor count +• **Motor Drivers** - Appropriate for motor type +• **Encoders** - Position feedback +• **Current Sensors** - Load monitoring +• **Emergency Stop** - Safety circuit +• **Power Supply** - Motor voltage/current +• **Heat Sinks** - Thermal management""" + } + return components_db.get(project_type, "• Custom component selection based on your requirements") + + def _get_skill_guidance(self, skill_level: str) -> str: + """Provide skill-appropriate guidance""" + guidance = { + "beginner": """ +**🟢 Beginner-Friendly Approach:** +• I'll use **pre-made modules** instead of discrete components +• **Clear wire colors** with detailed labeling +• **Step-by-step assembly** instructions +• **Safety reminders** for handling electronics +• **Troubleshooting tips** for common issues +• **Simple code examples** to get started""", + + "intermediate": """ +**🟡 Intermediate Level Features:** +• **Optimized pin assignments** for efficiency +• **Custom PCB layout** suggestions +• **Performance considerations** and timing +• **Component alternatives** and trade-offs +• **Debugging interfaces** built into the design +• **Modular design** for easy modifications""", + + "advanced": """ +**🔴 Advanced Engineering Features:** +• **Professional schematic** symbols and standards +• **Signal integrity** considerations +• **EMI/EMC compliance** design practices +• **Thermal management** calculations +• **Production testing** interfaces +• **Cost optimization** and sourcing recommendations""" + } + return guidance.get(skill_level, guidance["intermediate"]) + + def _analyze_available_components(self, components: str) -> str: + """Analyze user's available components""" + if not components: + return "" + + component_list = [c.strip() for c in components.split(',')] + + analysis = "**📦 Your Available Components Analysis:**\n" + for component in component_list: + analysis += f"• **{component}** - I'll optimize the circuit design around this\n" + + analysis += "\n**🔧 I'll suggest:**\n" + analysis += "• Additional components needed to complete the circuit\n" + analysis += "• Alternative uses for components you might not have considered\n" + analysis += "• Optimal pin assignments for your specific component mix\n" + + return analysis + + def _get_sensor_specifications(self, sensors: List[str]) -> str: + """Get detailed specifications for sensors""" + # This would be expanded with a comprehensive sensor database + specs = "**Sensor Technical Specifications:**\n" + for sensor in sensors: + specs += f"• **{sensor.title()}**: I'll include proper interface circuits, calibration notes, and optimal placement\n" + return specs + + def _get_output_components(self, outputs: List[str]) -> str: + """Get output component specifications""" + specs = "**Output Interface Design:**\n" + for output in outputs: + specs += f"• **{output.replace('_', ' ').title()}**: Professional interface with proper signal conditioning\n" + return specs + + def _get_power_design(self, power_source: str) -> str: + """Get power design specifications""" + power_designs = { + "usb": "**USB Power (5V)**: Clean, regulated power with USB protection", + "battery": "**Battery Power**: Efficient voltage regulation with low-power design", + "solar": "**Solar Power**: Charge controller with battery backup system", + "mains": "**Mains Power**: Isolated transformer with proper safety circuits" + } + return power_designs.get(power_source, "Custom power design based on requirements") + + def _get_connectivity_specs(self, connectivity: str) -> str: + """Get connectivity specifications""" + return f"**{connectivity.upper()} Implementation**: Professional antenna design with optimal signal routing" + + def _get_environmental_specs(self, location: str) -> str: + """Get environmental specifications""" + return f"**{location.title()} Deployment**: Weather protection and environmental considerations included" + + def _get_iot_components(self, purpose: str) -> str: + """Get IoT-specific components""" + return f"**{purpose.replace('_', ' ').title()} Components**: Optimized sensor and actuator selection" + + def _get_motor_specifications(self, motors: List[str]) -> str: + """Get motor specifications""" + specs = "**Motor Driver Selection:**\n" + for motor in motors: + specs += f"• **{motor.replace('_', ' ').title()}**: Appropriate driver with current/voltage ratings\n" + return specs + + def _get_precision_specs(self, precision: str) -> str: + """Get precision requirements""" + return f"**{precision.replace('_', ' ').title()}**: Encoder feedback and control algorithms included" + + def _get_safety_circuits(self, features: str) -> str: + """Get safety circuit specifications""" + if not features: + return "**Basic Safety**: Overcurrent protection and thermal monitoring" + return f"**Safety Features**: {features.replace('_', ' ').title()} circuits included" + + # ============================================================================ + # ELICITATION-BASED CIRCUIT DESIGNER (Interactive Engineering Interview) + # ============================================================================ + + if ELICITATION_AVAILABLE: + @mcp_elicitation( + name="circuit_design_interview", + description="Professional circuit design interview - I'll ask you questions like a seasoned engineer to create the perfect wiring diagram", + flow=[ + { + "id": "project_overview", + "question": "🎯 What kind of project are you building? Describe the main functionality you want to achieve.", + "type": QuestionType.TEXT, + "required": True + }, + { + "id": "experience_level", + "question": "🎓 What's your experience level with electronics?", + "type": QuestionType.CHOICE, + "choices": [ + "🟢 Beginner - New to Arduino and electronics", + "🟡 Intermediate - Built a few projects, comfortable with basics", + "🔴 Advanced - Experienced with PCB design and complex circuits", + "🎓 Professional - I design circuits for a living" + ], + "required": True + }, + { + "id": "board_selection", + "question": "🔧 Which Arduino board are you using (or planning to use)?", + "type": QuestionType.CHOICE, + "choices": [ + "Arduino Uno - Great for learning and prototyping", + "Arduino Nano - Compact for finished projects", + "ESP32 - Need WiFi/Bluetooth connectivity", + "ESP8266 - Simple WiFi projects", + "Arduino Mega - Need lots of pins", + "Custom/Other - I'll specify details" + ], + "required": True + }, + { + "id": "components_list", + "question": "📦 What components do you want to include? List everything you have or plan to use (sensors, displays, motors, etc.)", + "type": QuestionType.TEXT, + "required": True + }, + { + "id": "power_requirements", + "question": "⚡ How will you power this project?", + "type": QuestionType.CHOICE, + "choices": [ + "USB - Powered from computer/USB adapter", + "Battery - Portable operation (specify type if known)", + "Wall Adapter - Plugged into mains power", + "Solar - Self-sustaining outdoor project", + "Mixed - Multiple power sources", + "Not sure - I need guidance" + ], + "required": True + }, + { + "id": "environmental_needs", + "question": "🏠 Where will this project operate?", + "type": QuestionType.CHOICE, + "choices": [ + "Indoor - Controlled environment", + "Outdoor - Weather resistance needed", + "Mobile - Will be carried/moved frequently", + "Industrial - Harsh environment, vibration", + "Laboratory - Precision measurement environment" + ], + "required": True + }, + { + "id": "special_requirements", + "question": "🎯 Any special requirements? (Check all that apply)", + "type": QuestionType.MULTI_CHOICE, + "choices": [ + "🔒 Safety-critical - Cannot fail", + "🔋 Battery efficiency - Must run for weeks/months", + "⚡ High speed - Fast response times needed", + "🎛️ Precise control - Accurate positioning/measurement", + "📡 Remote monitoring - Need connectivity", + "🔧 Easy maintenance - Simple component replacement", + "💰 Cost optimization - Keep component costs low", + "📐 Compact size - Space constraints" + ], + "required": False + }, + { + "id": "interface_preferences", + "question": "👥 How do you want to interact with this project?", + "type": QuestionType.MULTI_CHOICE, + "choices": [ + "🖥️ Serial Monitor - Debug via computer", + "📱 Mobile App - Phone/tablet control", + "🖲️ Physical Controls - Buttons, knobs, switches", + "📺 Local Display - LCD/OLED screen", + "🌐 Web Interface - Browser-based control", + "🔊 Voice Control - Audio commands", + "🎮 Remote Control - IR/RF remote", + "🤖 Autonomous - No human interaction needed" + ], + "required": False + }, + { + "id": "skill_building", + "question": "📚 What would you like to learn from this project?", + "type": QuestionType.MULTI_CHOICE, + "choices": [ + "🔌 Basic wiring and connections", + "📊 Sensor data collection and processing", + "⚙️ Motor control and robotics", + "📡 Wireless communication (WiFi, Bluetooth)", + "💾 Data logging and storage", + "🎨 User interface design", + "🔋 Power management optimization", + "🛡️ Safety and protection circuits" + ], + "required": False + } + ] + ) + async def circuit_design_interview( + self, + ctx: ElicitationContext + ) -> str: + """Professional circuit design interview that creates custom wiring diagrams""" + + # Extract all the interview responses + project = ctx.get_response("project_overview") + experience = ctx.get_response("experience_level") + board = ctx.get_response("board_selection") + components = ctx.get_response("components_list") + power = ctx.get_response("power_requirements") + environment = ctx.get_response("environmental_needs") + special_reqs = ctx.get_response("special_requirements", []) + interfaces = ctx.get_response("interface_preferences", []) + learning_goals = ctx.get_response("skill_building", []) + + # Generate professional analysis + analysis = self._generate_professional_analysis( + project, experience, board, components, power, + environment, special_reqs, interfaces, learning_goals + ) + + # Create the comprehensive circuit design plan + return f"""# 🎯 Professional Circuit Design Analysis + +## 📋 Project Summary +**Project**: {project} +**Experience Level**: {experience} +**Board**: {board} +**Environment**: {environment} +**Power**: {power} + +## 🔬 Engineering Analysis +{analysis} + +## 📐 Custom Circuit Design Plan + +### 🧩 Intelligent Component Integration +Based on your requirements, I've designed an optimal pin assignment strategy: + +{self._generate_pin_assignment_strategy(board, components, special_reqs)} + +### ⚡ Power Distribution Design +{self._generate_power_design_analysis(power, components, special_reqs)} + +### 🛡️ Safety & Protection Circuits +{self._generate_safety_analysis(environment, special_reqs)} + +### 📊 Signal Integrity Considerations +{self._generate_signal_integrity_analysis(board, components, environment)} + +## 🎨 Professional Features Included + +### 🔧 Circuit Design Excellence +- ✅ **Industry-standard wire colors** (Red: 5V, Black: GND, etc.) +- ✅ **Proper pull-up/pull-down resistors** for all digital inputs +- ✅ **Decoupling capacitors** for stable power distribution +- ✅ **Protection diodes** for inductive loads (motors, relays) +- ✅ **Current limiting resistors** for LEDs and sensitive components +- ✅ **EMI suppression** techniques for clean signals + +### 📚 Educational Value +{self._generate_learning_content(learning_goals, experience)} + +### 🔧 Assembly & Debugging +- 📝 **Step-by-step assembly** instructions +- 🔍 **Built-in test points** for troubleshooting +- ⚡ **Status LEDs** for power and activity indication +- 🔄 **Modular design** for easy component swapping + +## 🚀 Next Steps + +I'm ready to generate your professional wiring diagram! Here's what you'll get: + +1. **📐 Detailed Circuit Diagram** - Professional WireViz schematic +2. **🎨 Color-coded Wiring** - Industry-standard wire colors +3. **📋 Component List** - Exact part numbers and specifications +4. **⚡ Assembly Instructions** - Step-by-step build guide +5. **🔧 Testing Procedures** - Validation and troubleshooting + +**Ready to see your custom circuit design? Just say "Generate my circuit diagram" and I'll create a production-ready wiring diagram based on this analysis!** + +--- +*This analysis was generated through professional engineering interview techniques, ensuring your circuit meets industrial standards while matching your specific requirements and skill level.* +""" + + def _generate_professional_analysis(self, project, experience, board, components, power, environment, special_reqs, interfaces, learning_goals): + """Generate professional engineering analysis""" + + # Extract experience level for targeted analysis + exp_level = "beginner" if "Beginner" in experience else "intermediate" if "Intermediate" in experience else "advanced" + + analysis = f""" +**🎯 Project Scope Analysis:** +Your {project.lower()} project requires careful consideration of component integration and power management. Based on your {exp_level} experience level, I'll design a circuit that challenges you appropriately while ensuring reliability. + +**🔧 Component Integration Strategy:** +{self._analyze_component_complexity(components, exp_level)} + +**⚡ Power & Performance Requirements:** +{self._analyze_power_requirements(power, components, special_reqs)} + +**🛡️ Environmental Considerations:** +{self._analyze_environmental_factors(environment, special_reqs)} +""" + return analysis + + def _analyze_component_complexity(self, components, exp_level): + """Analyze component integration complexity""" + component_count = len(components.split(',')) + + if exp_level == "beginner": + return f"With {component_count} components, I'll use pre-made modules and clear documentation to ensure successful assembly." + elif exp_level == "intermediate": + return f"Your {component_count}-component design allows for optimization techniques like shared power rails and efficient pin usage." + else: + return f"The {component_count}-component system enables advanced features like signal conditioning and professional layout practices." + + def _analyze_power_requirements(self, power, components, special_reqs): + """Analyze power system requirements""" + if "Battery" in power: + return "Battery operation requires efficient power management, sleep modes, and voltage regulation circuits." + elif "Solar" in power: + return "Solar power needs charge controller circuits, battery backup, and power monitoring systems." + else: + return "Stable power design with proper filtering and protection circuits for reliable operation." + + def _analyze_environmental_factors(self, environment, special_reqs): + """Analyze environmental protection needs""" + if "Outdoor" in environment: + return "Outdoor deployment requires weatherproof connectors, moisture protection, and temperature compensation." + elif "Industrial" in environment: + return "Industrial environment needs vibration resistance, EMI shielding, and robust connector systems." + else: + return "Standard indoor protection with basic EMI considerations and thermal management." + + def _generate_pin_assignment_strategy(self, board, components, special_reqs): + """Generate intelligent pin assignment strategy""" + return f""" +**📍 Optimized Pin Assignment for {board}:** + +• **Digital I/O Priority**: Emergency stops and safety circuits get priority pins +• **Analog Inputs**: Sensors requiring ADC get A0-A5 with proper reference voltage +• **PWM Outputs**: Motors and LED control on PWM-capable pins (3, 5, 6, 9, 10, 11) +• **Communication**: I2C on dedicated SDA/SCL, SPI on hardware pins for speed +• **Interrupts**: Time-critical sensors on interrupt-capable pins (2, 3) +• **Power Pins**: Dedicated 5V/3.3V distribution with current limiting + +This assignment minimizes noise, maximizes performance, and follows Arduino best practices. +""" + + def _generate_power_design_analysis(self, power, components, special_reqs): + """Generate power system analysis""" + return f""" +**⚡ Power Distribution Architecture:** + +• **Primary Supply**: {power} with appropriate voltage regulation +• **Logic Power**: Clean 5V/3.3V rails with decoupling capacitors +• **Motor Power**: Separate rail to prevent digital circuit noise +• **Current Budget**: Calculated for all components with 20% safety margin +• **Protection**: Fuses, reverse voltage protection, and thermal shutdown +• **Monitoring**: Voltage sensing for battery systems and fault detection +""" + + def _generate_safety_analysis(self, environment, special_reqs): + """Generate safety circuit analysis""" + safety_critical = any("Safety-critical" in req for req in special_reqs) + + if safety_critical: + return """ +**🛡️ Safety-Critical Design Features:** +• **Redundant Systems**: Dual safety circuits with independent power +• **Fail-Safe Operation**: Default to safe state on any fault condition +• **Watchdog Circuits**: Automatic reset on system hang or malfunction +• **Emergency Stop**: Hardwired emergency shutdown independent of software +• **Status Monitoring**: Real-time health monitoring with alarm outputs +""" + else: + return """ +**🛡️ Standard Safety Features:** +• **Overcurrent Protection**: Fuses and current limiting circuits +• **Thermal Protection**: Temperature monitoring and thermal shutdown +• **Reverse Voltage Protection**: Diode protection on power inputs +• **ESD Protection**: Static discharge protection on all interfaces +""" + + def _generate_signal_integrity_analysis(self, board, components, environment): + """Generate signal integrity analysis""" + return f""" +**📊 Signal Quality Optimization:** + +• **Wire Routing**: Separate analog and digital grounds with star ground point +• **Noise Suppression**: Ferrite beads on switching circuits and motor lines +• **Impedance Matching**: Proper termination for high-speed digital signals +• **EMI Reduction**: Twisted pair cables for long runs, shielded cables where needed +• **Ground Strategy**: Single-point grounding to prevent ground loops +• **Power Filtering**: LC filters for motor supplies, RC filters for analog references +""" + + def _generate_learning_content(self, learning_goals, experience): + """Generate educational content based on learning goals""" + if not learning_goals: + return "• **Circuit Understanding**: Detailed explanations of each circuit section and component function" + + content = "• **Targeted Learning Modules**:\n" + for goal in learning_goals: + if "Basic wiring" in goal: + content += " - Wire gauge selection and color coding standards\n" + elif "Sensor data" in goal: + content += " - ADC principles and signal conditioning techniques\n" + elif "Motor control" in goal: + content += " - PWM theory and H-bridge driver circuits\n" + elif "Wireless" in goal: + content += " - Antenna theory and RF layout considerations\n" + elif "Power management" in goal: + content += " - Switching regulator design and efficiency optimization\n" + + return content + + else: + # Fallback for clients without elicitation support + @mcp_prompt + async def circuit_design_interview_fallback( + self, + responses: str = Field(description="Your answers in format: project|experience|board|components|power|environment") + ) -> str: + """Fallback version for clients without elicitation support""" + return """# 🎯 Circuit Design Assistant + +**Note**: For the full interactive experience, upgrade to a client that supports elicitation. + +**Format your responses as**: `project|experience|board|components|power|environment` + +**Example**: `temperature monitor|intermediate|Arduino Uno|DHT22,LCD,SD card|USB|indoor` + +Once you provide your responses, I'll generate a professional circuit analysis and wiring diagram! +""" \ No newline at end of file diff --git a/src/mcp_arduino_server/server_refactored.py b/src/mcp_arduino_server/server_refactored.py index 6c699f8..b0e7e70 100644 --- a/src/mcp_arduino_server/server_refactored.py +++ b/src/mcp_arduino_server/server_refactored.py @@ -18,6 +18,7 @@ from .components import ( ArduinoLibrary, ArduinoSketch, WireViz, + WireVizPrompts, ) from .components.arduino_boards_advanced import ArduinoBoardsAdvanced from .components.arduino_compile_advanced import ArduinoCompileAdvanced @@ -213,6 +214,7 @@ def create_server(config: ArduinoServerConfig | None = None) -> FastMCP: board = ArduinoBoard(roots_config) debug = ArduinoDebug(roots_config) wireviz = WireViz(roots_config) + wireviz_prompts = WireVizPrompts(roots_config) serial = ArduinoSerial(roots_config) # Initialize advanced components @@ -245,6 +247,7 @@ def create_server(config: ArduinoServerConfig | None = None) -> FastMCP: board.register_all(mcp) # No prefix - these are core functions debug.register_all(mcp) # No prefix - these are debugging functions wireviz.register_all(mcp) # No prefix - these are specialized + wireviz_prompts.register_all(mcp) # No prefix - circuit design prompts serial.register_all(mcp) # No prefix - serial monitoring functions # Register advanced components