"""
Design rules command implementations for KiCAD interface
"""
import os
import pcbnew
import logging
from typing import Dict, Any, Optional, List, Tuple
logger = logging.getLogger('kicad_interface')
class DesignRuleCommands:
"""Handles design rule checking and configuration"""
def __init__(self, board: Optional[pcbnew.BOARD] = None):
"""Initialize with optional board instance"""
self.board = board
def set_design_rules(self, params: Dict[str, Any]) -> Dict[str, Any]:
"""Set design rules for the PCB"""
try:
if not self.board:
return {
"success": False,
"message": "No board is loaded",
"errorDetails": "Load or create a board first"
}
design_settings = self.board.GetDesignSettings()
# Convert mm to nanometers for KiCAD internal units
scale = 1000000 # mm to nm
# Set clearance
if "clearance" in params:
design_settings.SetMinClearance(int(params["clearance"] * scale))
# Set track width
if "trackWidth" in params:
design_settings.SetCurrentTrackWidth(int(params["trackWidth"] * scale))
# Set via settings
if "viaDiameter" in params:
design_settings.SetCurrentViaSize(int(params["viaDiameter"] * scale))
if "viaDrill" in params:
design_settings.SetCurrentViaDrill(int(params["viaDrill"] * scale))
# Set micro via settings
if "microViaDiameter" in params:
design_settings.SetCurrentMicroViaSize(int(params["microViaDiameter"] * scale))
if "microViaDrill" in params:
design_settings.SetCurrentMicroViaDrill(int(params["microViaDrill"] * scale))
# Set minimum values
if "minTrackWidth" in params:
design_settings.m_TrackMinWidth = int(params["minTrackWidth"] * scale)
if "minViaDiameter" in params:
design_settings.m_ViasMinSize = int(params["minViaDiameter"] * scale)
if "minViaDrill" in params:
design_settings.m_ViasMinDrill = int(params["minViaDrill"] * scale)
if "minMicroViaDiameter" in params:
design_settings.m_MicroViasMinSize = int(params["minMicroViaDiameter"] * scale)
if "minMicroViaDrill" in params:
design_settings.m_MicroViasMinDrill = int(params["minMicroViaDrill"] * scale)
# Set hole diameter
if "minHoleDiameter" in params:
design_settings.m_MinHoleDiameter = int(params["minHoleDiameter"] * scale)
# Set courtyard settings
if "requireCourtyard" in params:
design_settings.m_RequireCourtyards = params["requireCourtyard"]
if "courtyardClearance" in params:
design_settings.m_CourtyardMinClearance = int(params["courtyardClearance"] * scale)
return {
"success": True,
"message": "Updated design rules",
"rules": {
"clearance": design_settings.GetMinClearance() / scale,
"trackWidth": design_settings.GetCurrentTrackWidth() / scale,
"viaDiameter": design_settings.GetCurrentViaSize() / scale,
"viaDrill": design_settings.GetCurrentViaDrill() / scale,
"microViaDiameter": design_settings.GetCurrentMicroViaSize() / scale,
"microViaDrill": design_settings.GetCurrentMicroViaDrill() / scale,
"minTrackWidth": design_settings.m_TrackMinWidth / scale,
"minViaDiameter": design_settings.m_ViasMinSize / scale,
"minViaDrill": design_settings.m_ViasMinDrill / scale,
"minMicroViaDiameter": design_settings.m_MicroViasMinSize / scale,
"minMicroViaDrill": design_settings.m_MicroViasMinDrill / scale,
"minHoleDiameter": design_settings.m_MinHoleDiameter / scale,
"requireCourtyard": design_settings.m_RequireCourtyards,
"courtyardClearance": design_settings.m_CourtyardMinClearance / scale
}
}
except Exception as e:
logger.error(f"Error setting design rules: {str(e)}")
return {
"success": False,
"message": "Failed to set design rules",
"errorDetails": str(e)
}
def get_design_rules(self, params: Dict[str, Any]) -> Dict[str, Any]:
"""Get current design rules"""
try:
if not self.board:
return {
"success": False,
"message": "No board is loaded",
"errorDetails": "Load or create a board first"
}
design_settings = self.board.GetDesignSettings()
scale = 1000000 # nm to mm
return {
"success": True,
"rules": {
"clearance": design_settings.GetMinClearance() / scale,
"trackWidth": design_settings.GetCurrentTrackWidth() / scale,
"viaDiameter": design_settings.GetCurrentViaSize() / scale,
"viaDrill": design_settings.GetCurrentViaDrill() / scale,
"microViaDiameter": design_settings.GetCurrentMicroViaSize() / scale,
"microViaDrill": design_settings.GetCurrentMicroViaDrill() / scale,
"minTrackWidth": design_settings.m_TrackMinWidth / scale,
"minViaDiameter": design_settings.m_ViasMinSize / scale,
"minViaDrill": design_settings.m_ViasMinDrill / scale,
"minMicroViaDiameter": design_settings.m_MicroViasMinSize / scale,
"minMicroViaDrill": design_settings.m_MicroViasMinDrill / scale,
"minHoleDiameter": design_settings.m_MinHoleDiameter / scale,
"requireCourtyard": design_settings.m_RequireCourtyards,
"courtyardClearance": design_settings.m_CourtyardMinClearance / scale
}
}
except Exception as e:
logger.error(f"Error getting design rules: {str(e)}")
return {
"success": False,
"message": "Failed to get design rules",
"errorDetails": str(e)
}
def run_drc(self, params: Dict[str, Any]) -> Dict[str, Any]:
"""Run Design Rule Check"""
try:
if not self.board:
return {
"success": False,
"message": "No board is loaded",
"errorDetails": "Load or create a board first"
}
report_path = params.get("reportPath")
# Create DRC runner
drc = pcbnew.DRC(self.board)
# Run DRC
drc.Run()
# Get violations
violations = []
for marker in drc.GetMarkers():
violations.append({
"type": marker.GetErrorCode(),
"severity": "error",
"message": marker.GetDescription(),
"location": {
"x": marker.GetPos().x / 1000000,
"y": marker.GetPos().y / 1000000,
"unit": "mm"
}
})
# Save report if path provided
if report_path:
report_path = os.path.abspath(os.path.expanduser(report_path))
drc.WriteReport(report_path)
return {
"success": True,
"message": f"Found {len(violations)} DRC violations",
"violations": violations,
"reportPath": report_path if report_path else None
}
except Exception as e:
logger.error(f"Error running DRC: {str(e)}")
return {
"success": False,
"message": "Failed to run DRC",
"errorDetails": str(e)
}
def get_drc_violations(self, params: Dict[str, Any]) -> Dict[str, Any]:
"""Get list of DRC violations"""
try:
if not self.board:
return {
"success": False,
"message": "No board is loaded",
"errorDetails": "Load or create a board first"
}
severity = params.get("severity", "all")
# Get DRC markers
violations = []
for marker in self.board.GetDRCMarkers():
violation = {
"type": marker.GetErrorCode(),
"severity": "error", # KiCAD DRC markers are always errors
"message": marker.GetDescription(),
"location": {
"x": marker.GetPos().x / 1000000,
"y": marker.GetPos().y / 1000000,
"unit": "mm"
}
}
# Filter by severity if specified
if severity == "all" or severity == violation["severity"]:
violations.append(violation)
return {
"success": True,
"violations": violations
}
except Exception as e:
logger.error(f"Error getting DRC violations: {str(e)}")
return {
"success": False,
"message": "Failed to get DRC violations",
"errorDetails": str(e)
}
