ERC

The ERCOperations module provides electrical rules checking to validate schematic connectivity and design rules.

sch = kicad.get_schematic()
erc = sch.erc

Running ERC

run()

Runs ERC and returns the results.

result = sch.erc.run()

print(f"Errors: {len(result.errors)}")
print(f"Warnings: {len(result.warnings)}")

for error in result.errors:
    print(f"  {error.description} at {error.position}")

for warning in result.warnings:
    print(f"  {warning.description} at {error.position}")

run_and_report()

Runs ERC and generates a report file.

sch.erc.run_and_report("/path/to/erc_report.txt")

ERC Settings

get_settings()

Gets the current ERC settings.

settings = sch.erc.get_settings()
print(f"Check for unconnected pins: {settings.check_unconnected}")

set_settings(**kwargs)

Updates ERC settings.

sch.erc.set_settings(
    check_unconnected=True,
    check_duplicate_pins=True,
    check_off_grid=True,
    check_no_connect=True
)

ERC Exclusions

add_exclusion(item_id)

Excludes an item from ERC checks.

# Exclude a specific pin from unconnected pin warnings
sch.erc.add_exclusion(pin_id)

remove_exclusion(item_id)

Removes an ERC exclusion.

sch.erc.remove_exclusion(pin_id)

get_exclusions()

Gets all current exclusions.

exclusions = sch.erc.get_exclusions()

Pin Matrix Settings

get_pin_conflicts()

Gets the pin conflict matrix settings.

matrix = sch.erc.get_pin_conflicts()

set_pin_conflict(pin_type1, pin_type2, severity)

Sets the conflict severity between two pin types.

# Set input-to-input connection as warning
sch.erc.set_pin_conflict("input", "input", "warning")

# Allow output-to-passive connection (no error)
sch.erc.set_pin_conflict("output", "passive", "ok")

Pin types: "input", "output", "bidirectional", "tri_state", "passive", "power_in", "power_out", "open_collector", "open_emitter", "unconnected", "not_specified"

Severity: "ok", "warning", "error"

Example: Full ERC Workflow

from kipy import KiCad

kicad = KiCad()
sch = kicad.get_schematic()

# Configure ERC
sch.erc.set_settings(
    check_unconnected=True,
    check_duplicate_pins=True,
    check_off_grid=True
)

# Run ERC
result = sch.erc.run()

if result.errors:
    print("ERC FAILED")
    for error in result.errors:
        print(f"  ERROR: {error.description}")
        print(f"         at {error.sheet}:{error.position}")
elif result.warnings:
    print("ERC PASSED with warnings")
    for warning in result.warnings:
        print(f"  WARNING: {warning.description}")
else:
    print("ERC PASSED - no issues found")

# Generate report
sch.erc.run_and_report("erc_report.txt")

Example: Handling Specific Errors

result = sch.erc.run()

# Filter for specific error types
unconnected_errors = [e for e in result.errors if "unconnected" in e.description.lower()]
duplicate_errors = [e for e in result.errors if "duplicate" in e.description.lower()]

print(f"Unconnected pins: {len(unconnected_errors)}")
print(f"Duplicate pins: {len(duplicate_errors)}")

# Exclude intentional unconnected pins
for error in unconnected_errors:
    if should_exclude(error):  # Your logic here
        sch.erc.add_exclusion(error.item_id)

# Re-run ERC
result = sch.erc.run()

ERC Result Structure

class ERCResult:
    errors: List[ERCViolation]      # Error-level violations
    warnings: List[ERCViolation]    # Warning-level violations
    exclusions: List[ERCExclusion]  # Excluded items

class ERCViolation:
    description: str    # Human-readable description
    position: Vector2   # Location in schematic
    sheet: str          # Sheet path
    item_id: str        # Item KIID for exclusion
    severity: str       # "error" or "warning"