enginehall 2.0.0__py3-none-any.whl

pcba/rules/kicad_components.py

@@ -0,0 +1,603 @@
+"""Rules that judge parts against component data and the project's requirements file.
+
+What a part tolerates (supply range, input thresholds, required connections) comes from the
+component database (`pcba/components.py`); what a rail carries comes from
+`pcba-requirements.toml` or, failing that, from the rail's name. A part without data, a
+capacitor without a voltage rating, a rail of unknown voltage: each is listed under the rule as
+not checked, never counted as passing.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+
+from pcba.components import (
+    Level,
+    Part,
+    capacitor_class,
+    parse_value,
+    pin_matches,
+    rated_power,
+    rated_voltage,
+)
+from pcba.model.design import Component, Net, SchPin
+from pcba.model.finding import Domain, Evidence, Finding, Location, Severity
+from pcba.model.pinmap import Project
+from pcba.rules.kicad_common import (
+    at_component,
+    at_pin,
+    classify,
+    detector_for,
+    is_ground_net,
+    is_supply_rail,
+    net_display,
+    other_nets,
+    parts,
+    pin_label,
+    pin_numbers,
+    rail,
+    rail_evidence,
+    requirements,
+    schematic,
+)
+
+VALUE_TOLERANCE = 0.2
+
+
+def _library(project: Project):
+    return project.design.components if project.design else None
+
+
+def _matched(project: Project) -> list[tuple[Component, Part, str]]:
+    library = _library(project)
+    if library is None:
+        return []
+    out = []
+    for component in parts(project):
+        hit = library.match(component)
+        if hit:
+            out.append((component, hit[0], hit[1]))
+    return out
+
+
+def _part_evidence(part: Part, how: str) -> Evidence:
+    return Evidence(kind="component_data", value=f"{part.id} ({how}): {part.description}", source=part.source)
+
+
+# --- supply range -------------------------------------------------------------------------------
+
+
+def supply_range(project: Project) -> Iterator[Finding]:
+    """Each supply pin's rail inside the part's operating range, and never past its absolute maximum."""
+    sch = schematic(project)
+    if sch is None:
+        return
+    for component, part, how in _matched(project):
+        for pin in sorted(component.pins, key=lambda p: p.number):
+            net = sch.net_of(component.ref, pin.number)
+            known = rail(project, net)
+            if known is None:
+                continue
+            for supply in part.supplies:
+                if not pin_matches(supply.pins, pin.name):
+                    continue
+                low, high = supply.operating
+                absolute = supply.absolute
+                if absolute and (known.high > absolute[1] or known.low < absolute[0]):
+                    severity, what = Severity.ERROR, f"beyond the absolute maximum {absolute[0]:g} to {absolute[1]:g} V"
+                elif known.high > high or known.low < low:
+                    severity, what = Severity.WARNING, f"outside the operating range {low:g} to {high:g} V"
+                else:
+                    continue
+                detector, confidence = detector_for(known)
+                yield Finding(
+                    rule_id="kicad.component.supply_range",
+                    title=f"{component.ref} {pin.name} on {known.voltage:g} V is {what}",
+                    severity=severity,
+                    domain=Domain.SCHEMATIC,
+                    location=at_pin(project, pin),
+                    evidence=(rail_evidence(project, net, known), _part_evidence(part, how),
+                              Evidence(kind="component_data", value=f"{pin.name}: operating {low:g} to {high:g} V"
+                                       + (f", absolute {absolute[0]:g} to {absolute[1]:g} V" if absolute else ""),
+                                       source=part.source)),
+                    explanation=(f"{component.ref} ({component.value}) pin {pin.number} {pin.name} is supplied from "
+                                 f"{net_display(net)!r} at {known.low:g} to {known.high:g} V."),
+                    consequence=("Past the absolute maximum the part is damaged; outside the operating range it is "
+                                 "not specified to work."),
+                    recommendation="Supply the pin from a rail inside its range, or choose a part rated for this rail.",
+                    detector=detector,
+                    confidence=confidence,
+                )
+            for ground in part.grounds:
+                if pin_matches(ground, pin.name) and known.voltage != 0 and not is_ground_net(net):
+                    detector, confidence = detector_for(known)
+                    yield Finding(
+                        rule_id="kicad.component.supply_range",
+                        title=f"{component.ref} ground pin {pin.name} is on {net_display(net)!r}",
+                        severity=Severity.ERROR,
+                        domain=Domain.SCHEMATIC,
+                        location=at_pin(project, pin),
+                        evidence=(rail_evidence(project, net, known), _part_evidence(part, how)),
+                        explanation=(f"{pin.name} is a ground pin of {part.id}, but its net carries "
+                                     f"{known.voltage:g} V."),
+                        consequence="The part sees a reversed or shorted supply.",
+                        recommendation="Connect the ground pin to ground.",
+                        detector=detector,
+                        confidence=confidence,
+                    )
+                    break
+
+
+def _supply_scope(project: Project) -> tuple[int, list[str]]:
+    sch = schematic(project)
+    library = _library(project)
+    if sch is None or library is None:
+        return 0, []
+    checked, unchecked = 0, []
+    for component in parts(project, "ic"):
+        hit = library.match(component)
+        if hit is None:
+            unchecked.append(f"{component.ref} ({component.value}): no component data")
+            continue
+        for pin in component.pins:
+            if any(pin_matches(s.pins, pin.name) for s in hit[0].supplies):
+                if rail(project, sch.net_of(component.ref, pin.number)) is None:
+                    unchecked.append(f"{component.ref}.{pin.number} ({pin.name}): rail voltage unknown")
+                else:
+                    checked += 1
+    return checked, unchecked
+
+
+# --- capacitor derating ---------------------------------------------------------------------------
+
+
+def _across(project: Project, component: Component):
+    sch = schematic(project)
+    nets = [sch.net_of(component.ref, n) for n in sorted(pin_numbers(component))]
+    rails = [rail(project, n) for n in nets]
+    return nets, rails
+
+
+def capacitor_derating(project: Project) -> Iterator[Finding]:
+    """The voltage across each capacitor within its derated rating."""
+    if schematic(project) is None:
+        return
+    limits = requirements(project).derating
+    for component in parts(project, "capacitor"):
+        if component.dnp or len(pin_numbers(component)) != 2:
+            continue
+        rating = rated_voltage(component)
+        nets, rails = _across(project, component)
+        if rating is None or None in rails:
+            continue
+        applied = max(abs(rails[0].high - rails[1].low), abs(rails[1].high - rails[0].low))
+        cls = capacitor_class(component)
+        limit = limits.get(cls, limits["ceramic"])
+        ratio = applied / rating[0] if rating[0] else float("inf")
+        if ratio <= limit:
+            continue
+        severity = Severity.ERROR if applied > rating[0] else Severity.WARNING
+        detector, confidence = detector_for(*rails)
+        yield Finding(
+            rule_id="kicad.component.capacitor_derating",
+            title=(f"{component.ref} sees {applied:g} V on a {rating[0]:g} V rating "
+                   f"({ratio:.0%}; {cls} limit {limit:.0%})"),
+            severity=severity,
+            domain=Domain.SCHEMATIC,
+            location=at_component(project, component),
+            evidence=(Evidence(kind="rating", value=f"{rating[0]:g} V from {rating[1]}",
+                               source=project.relative(component.sheet_file)),
+                      rail_evidence(project, nets[0], rails[0]), rail_evidence(project, nets[1], rails[1]),
+                      Evidence(kind="derating", value=f"{cls}: applied voltage at most {limit:.0%} of the rating",
+                               source=project.relative(requirements(project).path) if requirements(project).path
+                               else "EngineHall default")),
+            explanation=(f"{component.ref} ({component.value}) sits between {net_display(nets[0])!r} and "
+                         f"{net_display(nets[1])!r}."),
+            consequence=("A ceramic capacitor loses most of its capacitance near its rated voltage; an electrolytic "
+                         "ages fast; above the rating the part fails short."),
+            recommendation=f"Use a part rated for at least {applied / limit:.3g} V, or document why this derating is "
+                           "acceptable.",
+            detector=detector,
+            confidence=confidence,
+        )
+
+
+def _capacitor_scope(project: Project) -> tuple[int, list[str]]:
+    if schematic(project) is None:
+        return 0, []
+    checked, unchecked = 0, []
+    for component in parts(project, "capacitor"):
+        if component.dnp or len(pin_numbers(component)) != 2:
+            continue
+        nets, rails = _across(project, component)
+        if rated_voltage(component) is None:
+            unchecked.append(f"{component.ref} ({component.value}): no voltage rating in the value or a Voltage field")
+        elif None in rails:
+            unknown = [net_display(n) for n, r in zip(nets, rails) if r is None and n is not None]
+            unchecked.append(f"{component.ref}: voltage of {', '.join(unknown) or 'its nets'} unknown")
+        else:
+            checked += 1
+    return checked, unchecked
+
+
+# --- resistor power -----------------------------------------------------------------------------
+
+
+def resistor_power(project: Project) -> Iterator[Finding]:
+    """A resistor between two rails of known voltage within its derated power rating."""
+    if schematic(project) is None:
+        return
+    limit = requirements(project).derating["resistor_power"]
+    for component in parts(project, "resistor"):
+        if component.dnp or len(pin_numbers(component)) != 2:
+            continue
+        nets, rails = _across(project, component)
+        ohms = parse_value(component.value)
+        rating = rated_power(component)
+        if None in rails or not ohms or rating is None:
+            continue
+        volts = max(abs(rails[0].high - rails[1].low), abs(rails[1].high - rails[0].low))
+        watts = volts * volts / ohms
+        if watts <= rating[0] * limit:
+            continue
+        detector, confidence = detector_for(*rails)
+        yield Finding(
+            rule_id="kicad.component.resistor_power",
+            title=f"{component.ref} dissipates {watts:.3g} W on a {rating[0]:g} W rating",
+            severity=Severity.ERROR if watts > rating[0] else Severity.WARNING,
+            domain=Domain.SCHEMATIC,
+            location=at_component(project, component),
+            evidence=(Evidence(kind="rating", value=f"{rating[0]:g} W from {rating[1]}",
+                               source=project.relative(component.sheet_file)),
+                      rail_evidence(project, nets[0], rails[0]), rail_evidence(project, nets[1], rails[1]),
+                      Evidence(kind="derating", value=f"at most {limit:.0%} of the rated power")),
+            explanation=f"{volts:g} V across {component.value} is {watts:.3g} W.",
+            consequence="An overloaded resistor runs hot, drifts and eventually opens.",
+            recommendation=f"Use a resistor rated for at least {watts / limit:.3g} W, or a larger value.",
+            detector=detector,
+            confidence=confidence,
+        )
+
+
+def _resistor_scope(project: Project) -> tuple[int, list[str]]:
+    if schematic(project) is None:
+        return 0, []
+    checked, unchecked = 0, []
+    for component in parts(project, "resistor"):
+        if component.dnp or len(pin_numbers(component)) != 2:
+            continue
+        _nets, rails = _across(project, component)
+        if None in rails:
+            continue
+        if rated_power(component) is None or not parse_value(component.value):
+            unchecked.append(f"{component.ref} ({component.value}): no power rating or value")
+        else:
+            checked += 1
+    return checked, unchecked
+
+
+# --- logic levels -------------------------------------------------------------------------------
+
+
+def _levels(part: Part, pin: SchPin) -> tuple[Level | None, Level | None]:
+    driver = next((lv for lv in part.outputs if pin_matches(lv.pins, pin.name)), None)
+    receiver = next((lv for lv in part.inputs if pin_matches(lv.pins, pin.name)), None)
+    if pin.type == "input":
+        driver = None
+    elif pin.type in ("output", "power_out"):
+        receiver = None
+    return driver, receiver
+
+
+def _supply_voltage(project: Project, component: Component, part: Part) -> float | None:
+    sch = schematic(project)
+    values = []
+    for pin in component.pins:
+        if any(pin_matches(s.pins, pin.name) for s in part.supplies):
+            known = rail(project, sch.net_of(component.ref, pin.number))
+            if known is not None:
+                values.append(known.high)
+    return max(values) if values else None
+
+
+def _pull_up_voltage(project: Project, net: Net) -> float | None:
+    sch = schematic(project)
+    for pin in net.parts:
+        component = sch.components.get(pin.ref)
+        if component is None or classify(component) != "resistor":
+            continue
+        for far in other_nets(sch, component, pin.number):
+            if is_supply_rail(project, far):
+                known = rail(project, far)
+                if known is not None:
+                    return known.high
+    return None
+
+
+def _net_roles(project: Project, net: Net):
+    library = _library(project)
+    sch = schematic(project)
+    drivers, receivers = [], []
+    for pin in net.parts:
+        component = sch.components.get(pin.ref)
+        hit = library.match(component) if component is not None and library else None
+        if hit is None:
+            continue
+        driver, receiver = _levels(hit[0], pin)
+        if driver:
+            drivers.append((pin, component, hit[0], driver))
+        if receiver:
+            receivers.append((pin, component, hit[0], receiver))
+    return drivers, receivers
+
+
+def logic_level(project: Project) -> Iterator[Finding]:
+    """Driver output levels against receiver input thresholds and limits on one net."""
+    sch = schematic(project)
+    if sch is None or _library(project) is None:
+        return
+    for net in sch.nets:
+        if is_ground_net(net) or is_supply_rail(project, net):
+            continue
+        drivers, receivers = _net_roles(project, net)
+        reported: set[str] = set()
+        for d_pin, d_comp, d_part, d_level in drivers:
+            if d_level.kind == "open_drain":
+                high_level = _pull_up_voltage(project, net)
+                high_min = high_level
+            else:
+                high_level = _supply_voltage(project, d_comp, d_part) or d_level.high
+                high_min = d_level.high
+            for r_pin, r_comp, r_part, r_level in receivers:
+                if r_comp.ref == d_comp.ref or r_pin.ref + r_pin.number in reported:
+                    continue
+                problems = []
+                if high_level is not None and r_level.limit is not None and high_level > r_level.limit:
+                    problems.append((Severity.ERROR,
+                                     f"drives {high_level:g} V into an input rated {r_level.limit:g} V"))
+                if high_min is not None and r_level.high is not None and high_min < r_level.high:
+                    problems.append((Severity.ERROR, f"high level {high_min:g} V is below the input's VIH "
+                                                     f"{r_level.high:g} V"))
+                if d_level.low is not None and r_level.low is not None and d_level.low > r_level.low:
+                    problems.append((Severity.ERROR, f"low level {d_level.low:g} V is above the input's VIL "
+                                                     f"{r_level.low:g} V"))
+                if not problems:
+                    continue
+                reported.add(r_pin.ref + r_pin.number)
+                yield Finding(
+                    rule_id="kicad.component.logic_level",
+                    title=f"{pin_label(d_pin)} {problems[0][1]} at {pin_label(r_pin)}",
+                    severity=problems[0][0],
+                    domain=Domain.SCHEMATIC,
+                    location=at_pin(project, r_pin, key=net.name),
+                    evidence=(Evidence(kind="schematic_net", value=f"{pin_label(d_pin)} drives {net_display(net)!r} "
+                                       f"to {pin_label(r_pin)}", source=project.relative(r_pin.sheet_file)),
+                              Evidence(kind="component_data", value=f"driver {d_part.id}: VOL {d_level.low}, "
+                                       f"VOH {d_level.high}, {d_level.kind}", source=d_part.source),
+                              Evidence(kind="component_data", value=f"receiver {r_part.id}: VIL {r_level.low}, "
+                                       f"VIH {r_level.high}, max {r_level.limit}", source=r_part.source),
+                              *(Evidence(kind="logic_level", value=text) for _sev, text in problems)),
+                    explanation="The driver's guaranteed output levels do not meet the receiver's input "
+                                "requirements at their nominal supplies.",
+                    consequence="The signal is misread, or the receiver's input is driven past its rating.",
+                    recommendation="Add a level shifter, change one side's supply, or choose parts with compatible "
+                                   "levels.",
+                )
+        pull_up = _pull_up_voltage(project, net)
+        for r_pin, _r_comp, r_part, r_level in receivers:
+            if (pull_up is None or r_level.limit is None or pull_up <= r_level.limit
+                    or r_pin.ref + r_pin.number in reported):
+                continue
+            reported.add(r_pin.ref + r_pin.number)
+            yield Finding(
+                rule_id="kicad.component.logic_level",
+                title=(f"{net_display(net)!r} is pulled up to {pull_up:g} V into {pin_label(r_pin)}, "
+                       f"rated {r_level.limit:g} V"),
+                severity=Severity.ERROR,
+                domain=Domain.SCHEMATIC,
+                location=at_pin(project, r_pin, key=net.name),
+                evidence=(Evidence(kind="schematic_net",
+                                   value=f"a resistor pulls {net_display(net)!r} to {pull_up:g} V",
+                                   source=project.relative(r_pin.sheet_file)),
+                          Evidence(kind="component_data", value=f"receiver {r_part.id}: input max {r_level.limit:g} V",
+                                   source=r_part.source)),
+                explanation="The pull-up sets the high level of the whole net, above what this input tolerates.",
+                consequence="The input is driven past its rating whenever the line is high.",
+                recommendation="Pull the line up to the receiver's supply, or add a level shifter.",
+            )
+
+
+def _logic_scope(project: Project) -> tuple[int, list[str]]:
+    sch = schematic(project)
+    if sch is None or _library(project) is None:
+        return 0, []
+    checked, unchecked = 0, []
+    for net in sch.nets:
+        if is_ground_net(net) or is_supply_rail(project, net) or len(net.parts) < 2:
+            continue
+        drivers, receivers = _net_roles(project, net)
+        pairs = [(d, r) for d in drivers for r in receivers if d[1].ref != r[1].ref]
+        if pairs:
+            checked += 1
+        elif drivers or receivers:
+            known = {d[1].ref for d in drivers} | {r[1].ref for r in receivers}
+            others = sorted({p.ref for p in net.parts if classify(sch.components[p.ref]) == "ic"} - known)
+            if others:
+                unchecked.append(f"{net_display(net)}: no level data for {', '.join(others)}")
+    return checked, unchecked
+
+
+# --- required connections -----------------------------------------------------------------------
+
+
+def _capacitors_to_ground(project: Project, net: Net) -> list[Component]:
+    sch = schematic(project)
+    out = []
+    for pin in net.parts:
+        component = sch.components.get(pin.ref)
+        if component is None or component.dnp or classify(component) != "capacitor":
+            continue
+        if any(is_ground_net(far) for far in other_nets(sch, component, pin.number)):
+            out.append(component)
+    return out
+
+
+def _resistor_to(project: Project, net: Net, ground: bool) -> bool:
+    sch = schematic(project)
+    for pin in net.parts:
+        component = sch.components.get(pin.ref)
+        if component is None or component.dnp or classify(component) != "resistor":
+            continue
+        for far in other_nets(sch, component, pin.number):
+            if (is_ground_net(far) if ground else is_supply_rail(project, far)):
+                return True
+    return False
+
+
+def required_connection(project: Project) -> Iterator[Finding]:
+    """What the component data says a pin needs: a capacitor, a pull-up, not floating ..."""
+    sch = schematic(project)
+    if sch is None:
+        return
+    for component, part, how in _matched(project):
+        if component.dnp:
+            continue
+        for need in part.required:
+            for pin in sorted(component.pins, key=lambda p: p.number):
+                if not pin_matches(need.pin, pin.name):
+                    continue
+                net = sch.net_of(component.ref, pin.number)
+                if net is None:
+                    continue
+                problem = None
+                severity = Severity.ERROR
+                if need.requires == "capacitor_to_ground":
+                    caps = _capacitors_to_ground(project, net)
+                    if not caps:
+                        problem = f"needs a capacitor to ground{f' ({need.value})' if need.value else ''}; it has none"
+                    elif need.value and parse_value(need.value):
+                        want = parse_value(need.value)
+                        values = [(c, parse_value(c.value)) for c in caps]
+                        if not any(v and abs(v - want) <= want * VALUE_TOLERANCE for _c, v in values):
+                            severity = Severity.WARNING
+                            problem = (f"needs {need.value} to ground; found "
+                                       + ", ".join(f"{c.ref} {c.value}" for c, _v in values))
+                elif need.requires == "not_floating":
+                    if len(net.parts) < 2 and rail(project, net) is None and not net.power:
+                        problem = "must not float; it connects to nothing"
+                elif need.requires == "connected":
+                    if len(net.parts) < 2 and not net.labels:
+                        problem = "must be connected; it is not"
+                elif need.requires == "pull_up":
+                    if not _resistor_to(project, net, ground=False) and not is_supply_rail(project, net):
+                        problem = "needs a pull-up resistor to a supply; it has none"
+                elif need.requires == "pull_down":
+                    if not _resistor_to(project, net, ground=True) and not is_ground_net(net):
+                        problem = "needs a pull-down resistor to ground; it has none"
+                if problem is None:
+                    continue
+                yield Finding(
+                    rule_id="kicad.component.required_connection",
+                    title=f"{component.ref} {pin.name} {problem}",
+                    severity=severity,
+                    domain=Domain.SCHEMATIC,
+                    location=at_pin(project, pin, key=need.requires),
+                    evidence=(Evidence(kind="schematic_net", value=f"{pin_label(pin)} on {net_display(net)!r} with "
+                                       f"{len(net.parts)} part pin(s)", source=project.relative(pin.sheet_file)),
+                              _part_evidence(part, how),
+                              Evidence(kind="component_data", value=f"{need.pin}: {need.requires}"
+                                       + (f" {need.value}" if need.value else ""), source=part.source)),
+                    explanation=f"The component data for {part.id} requires this connection on {pin.name}.",
+                    consequence="The part does not start, resets at random, or its output oscillates.",
+                    recommendation=f"Add the {need.requires.replace('_', ' ')} on {pin.name} as the component data "
+                                   "(and the datasheet behind it) specify.",
+                )
+
+
+def _required_scope(project: Project) -> tuple[int, list[str]]:
+    library = _library(project)
+    if schematic(project) is None or library is None:
+        return 0, []
+    checked = sum(len(part.required) > 0 for _c, part, _h in _matched(project))
+    unchecked = [f"{c.ref} ({c.value}): no component data" for c in parts(project, "ic") if library.match(c) is None]
+    return checked, unchecked
+
+
+# --- connectors ---------------------------------------------------------------------------------
+
+
+def _same_signal(expected: str, net: Net | None) -> bool:
+    want = expected.strip().upper().lstrip("/")
+    if net is None:
+        return False
+    names = {n.upper() for n in (net.label, net.name.rsplit("/", 1)[-1], net.name) if n}
+    return want in names
+
+
+def connector_pin_assignment(project: Project) -> Iterator[Finding]:
+    """Each connector pin carries the signal the interface spec in the requirements file names."""
+    sch = schematic(project)
+    req = requirements(project)
+    if sch is None or not req.connectors:
+        return
+    source = project.relative(req.path) if req.path else "pcba-requirements.toml"
+    for spec in req.connectors:
+        component = sch.components.get(spec.ref)
+        if component is None:
+            yield Finding(
+                rule_id="kicad.connector.pin_assignment",
+                title=f"Connector {spec.ref} from the requirements file is not in the schematic",
+                severity=Severity.ERROR,
+                domain=Domain.SCHEMATIC,
+                location=Location(artifact=source, component=spec.ref, key=spec.interface or "connector"),
+                evidence=(Evidence(kind="requirement", value=f"[[connectors]] ref = {spec.ref!r}", source=source),),
+                explanation="The interface spec names a reference the schematic does not have.",
+                consequence="The interface cannot be checked; it may have been renamed or removed.",
+                recommendation="Correct the reference in pcba-requirements.toml or restore the connector.",
+            )
+            continue
+        for number, expected in sorted(spec.pins.items()):
+            pin = component.pin(number)
+            if pin is None:
+                actual, ok = "no such pin", False
+            else:
+                net = sch.net_of(component.ref, number)
+                if expected.strip().upper() in ("NC", "N/C", "-"):
+                    ok = pin.no_connect or (net is not None and len(net.parts) <= 1 and not net.labels)
+                    actual = "not connected" if ok else f"net {net_display(net)!r}" if net else "unknown"
+                else:
+                    ok = _same_signal(expected, net)
+                    actual = f"net {net_display(net)!r}" if net is not None else "no net"
+            if ok:
+                continue
+            location = at_pin(project, pin, key=spec.interface or None) if pin else at_component(
+                project, component, pin=number, key=spec.interface or None)
+            yield Finding(
+                rule_id="kicad.connector.pin_assignment",
+                title=f"{spec.ref} pin {number} should carry {expected}; it has {actual}",
+                severity=Severity.ERROR,
+                domain=Domain.SCHEMATIC,
+                location=location,
+                evidence=(Evidence(kind="requirement", value=f"{spec.interface or spec.ref}: pin {number} = {expected}",
+                                   source=source),
+                          Evidence(kind="schematic_net", value=f"{spec.ref}.{number}: {actual}",
+                                   source=project.relative(component.sheet_file))),
+                explanation=f"The interface spec for {spec.ref} assigns {expected} to pin {number}.",
+                consequence="A cable or mating board wired to the spec meets the wrong signal: at best it does not "
+                            "work, at worst a supply lands on a signal pin.",
+                recommendation="Fix the schematic, or the spec if the interface changed on purpose.",
+            )
+
+
+RULES = (supply_range, capacitor_derating, resistor_power, logic_level, required_connection,
+         connector_pin_assignment)
+
+SCOPE = {
+    "kicad.component.supply_range": _supply_scope,
+    "kicad.component.capacitor_derating": _capacitor_scope,
+    "kicad.component.resistor_power": _resistor_scope,
+    "kicad.component.logic_level": _logic_scope,
+    "kicad.component.required_connection": _required_scope,
+}
+
+__all__ = ["RULES", "SCOPE"]