@modular-circuit/perc 0.0.59 → 0.1.0

package/build/erc/parameter_propagation/link_testers/tester_impl.js

@@ -1,994 +0,0 @@
-// add the other testers following the  AnalogLinkTester
-import { PortType, all_range_are_defined, contains, filter_defined_range, hull, interests, intersection, r_div, range_is_defined, sum, } from '@modular-circuit/electronics-model';
-import { CompositePortLinkTesterBase, LinkTesterBase } from './link_tester_base';
-import { PP_DUPLICATED_SOURCES, PP_ILLEGAL_CONNECTION, PP_IMPEDANCE_SIGNAL_INTEGRITY, PP_INCOMPATIBLE_DIGITAL_THRESHOLDS, PP_INCOMPATIBLE_SIGNAL_LEVELS, PP_INCOMPATIBLE_VOLTAGE_LEVELS, PP_NOT_DRIVEN, PP_OVER_DRIVEN, PP_REQUIRES_CONNECTED_SOURCE_OR_BIDIR, PP_SIGNAL_LEVELS_NOT_CONTAINED_WITHIN_VOLTAGE, } from '../../../report';
-/**
-    self.assign(self.sink_impedance, 1 / (1 / self.sinks.map_extract(lambda x: x.impedance)).sum())
-    self.require(self.source.impedance.upper() <= self.sink_impedance.lower() * 0.1)  # about 10x for signal integrity
-    self.assign(self.current_drawn, self.sinks.sum(lambda x: x.current_draw))
-
-    self.assign(self.voltage_limits, self.sinks.intersection(lambda x: x.voltage_limits))
-    self.require(self.voltage_limits.contains(self.voltage), "incompatible voltage levels")
-    self.assign(self.signal_limits, self.sinks.intersection(lambda x: x.signal_limits))
-    self.require(self.voltage.contains(self.signal), "signal levels not contained within voltage")
-    self.require(self.signal_limits.contains(self.signal), "incompatible signal levels")
-    self.assign(self.current_limits, self.source.current_limits)
-    self.require(self.current_limits.contains(self.current_drawn), "overcurrent")
- */
-export class AnalogLinkTester extends LinkTesterBase {
-    init_link() {
-        const sources = [];
-        const sinks = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.AnalogSource: {
-                    sources.push(v);
-                    break;
-                }
-                case PortType.AnalogSink: {
-                    sinks.push(v);
-                    break;
-                }
-            }
-        }
-        if (sources.length === 0) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'Requires a connected analog source'));
-            return false;
-        }
-        if (sources.length > 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'Multiple analog sources are not allowed'));
-            return false;
-        }
-        this.link = {
-            source: sources[0],
-            sinks,
-        };
-        return true;
-    }
-    check_parameter_propagation() {
-        if (!this.link)
-            return;
-        const source = this.link.source;
-        const sinks = this.link.sinks;
-        const source_id = this.ctx.port_id.get(source);
-        if (range_is_defined(source.impedance)) {
-            const all_sinks_impedance = filter_defined_range(sinks.map((v) => v.impedance));
-            if (all_sinks_impedance.length > 0) {
-                const sink_impedance = r_div(sum(all_sinks_impedance.map((v) => r_div(v, 1))), 1);
-                if (source.impedance.upper > sink_impedance.lower * 0.1) {
-                    this.ctx.report.erc_errors.push(PP_IMPEDANCE_SIGNAL_INTEGRITY(this.all_port_ids));
-                }
-            }
-        }
-        if (range_is_defined(source.voltage_out)) {
-            const all_voltage_limits = filter_defined_range(sinks.map((v) => v.voltage_limits));
-            if (all_voltage_limits.length > 0) {
-                const voltage_limits = intersection(all_voltage_limits);
-                if (!interests(voltage_limits, source.voltage_out)) {
-                    this.ctx.report.erc_errors.push(PP_INCOMPATIBLE_VOLTAGE_LEVELS(source_id));
-                }
-            }
-        }
-        if (all_range_are_defined(source.signal_out, source.voltage_out)) {
-            if (!interests(source.voltage_out, source.signal_out)) {
-                this.ctx.report.erc_errors.push(PP_SIGNAL_LEVELS_NOT_CONTAINED_WITHIN_VOLTAGE(source_id));
-            }
-        }
-        if (range_is_defined(source.signal_out)) {
-            const all_sinks_signal_limits = filter_defined_range(sinks.map((v) => v.signal_limits));
-            if (all_sinks_signal_limits.length > 0) {
-                const signal_limits = intersection(all_sinks_signal_limits);
-                if (!interests(signal_limits, source.signal_out)) {
-                    this.ctx.report.erc_errors.push(PP_INCOMPATIBLE_SIGNAL_LEVELS(source_id));
-                }
-            }
-        }
-        if (range_is_defined(source.current_limits)) {
-            const all_sinks_current_drawn = filter_defined_range(sinks.map((v) => v.current_drawn));
-            if (all_sinks_current_drawn.length > 0) {
-                const current_drawn = sum(all_sinks_current_drawn);
-                if (interests(current_drawn, source.current_limits)) {
-                    this.ctx.report.erc_errors.push(PP_OVER_DRIVEN([source_id], 'current'));
-                }
-            }
-        }
-    }
-}
-/**
- 
-    voltage_hull = self.bidirs.hull(lambda x: x.voltage_out)
-    voltage_hull = self.sources.any_connected().then_else(
-      voltage_hull.hull(self.sources.hull(lambda x: x.voltage_out)),
-      voltage_hull
-    )
-    self.assign(self.voltage, voltage_hull)
-
-    self.assign(self.voltage_limits,
-      self.sinks.intersection(lambda x: x.voltage_limits).intersect(self.bidirs.intersection(lambda x: x.voltage_limits))
-    )
-    self.require(self.voltage_limits.contains(self.voltage), "overvoltage")
-
-    self.assign(self.current_drawn,
-      self.sinks.sum(lambda x: x.current_draw) + self.bidirs.sum(lambda x: x.current_draw)
-    )
-    self.assign(self.current_limits,
-                self.sources.intersection(lambda x: x.current_limits)
-                .intersect(self.bidirs.intersection(lambda x: x.current_limits)))
-    self.require(self.current_limits.contains(self.current_drawn), "overcurrent")
-
-    self.assign(self.output_thresholds,
-                self.sources.intersection(lambda x: x.output_thresholds)
-                .intersect(self.bidirs.intersection(lambda x: x.output_thresholds),))
-    self.assign(self.input_thresholds,
-      self.sinks.hull(lambda x: x.input_thresholds).hull(self.bidirs.hull(lambda x: x.input_thresholds)),
-    )
-    self.require(self.output_thresholds.contains(self.input_thresholds), "incompatible digital thresholds")
-
-    self.require(self.sources.any_connected() | (self.bidirs.length() > 0),
-                 "requires connected source or bidir")
-
-    # ensure both digital levels can be driven (but pull-up or -down only connections are allowed)
-    self.assign(self.pullup_capable,
-                self.sources.any(lambda x: x.pullup_capable) |
-                self.sinks.any(lambda x: x.pullup_capable) |
-                self.bidirs.any(lambda x: x.pullup_capable))
-    self.assign(self.pulldown_capable,
-                self.sources.any(lambda x: x.pulldown_capable) |
-                self.sinks.any(lambda x: x.pulldown_capable) |
-                self.bidirs.any(lambda x: x.pulldown_capable))
-    self.assign(self._has_low_signal_driver,  # assumed bidirs are true directional drivers
-                self.bidirs.any_connected() | self.sources.any(lambda x: x.low_driver))
-    self.assign(self._has_high_signal_driver,
-                self.bidirs.any_connected() | self.sources.any(lambda x: x.high_driver))
-
-    is_bridged_internal = (self.sources.any(lambda x: x._bridged_internal) |
-                           self.sinks.any(lambda x: x._bridged_internal) |
-                           self.bidirs.any(lambda x: x._bridged_internal))
-    self.require(is_bridged_internal |
-                 self._has_high_signal_driver.implies(self._has_low_signal_driver | self.pulldown_capable), "requires low driver or pulldown")
-    self.require(is_bridged_internal |
-                 self._has_low_signal_driver.implies(self._has_high_signal_driver | self.pullup_capable), "requires high driver or pullup")
-
-    # when multiple sources, ensure they all drive only one signal direction (eg, open drain)
-    self.require((self.sources.count(lambda x: x.high_driver) > 1).implies(~self.sources.any(lambda x: x.low_driver)) &
-                 (self.sources.count(lambda x: x.low_driver) > 1).implies(~self.sources.any(lambda x: x.high_driver)),
-                 "conflicting source drivers")
-
-
- */
-export class DigitalLinkTester extends LinkTesterBase {
-    init_link() {
-        const sinks = [];
-        const sources = [];
-        const bidirs = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.DigitalSource: {
-                    sources.push(v);
-                    break;
-                }
-                case PortType.DigitalSink: {
-                    sinks.push(v);
-                    break;
-                }
-                case PortType.DigitalBidir: {
-                    bidirs.push(v);
-                    break;
-                }
-            }
-        }
-        this.link = {
-            sources,
-            sinks,
-            bidirs,
-        };
-        return true;
-    }
-    check_parameter_propagation() {
-        if (!this.link)
-            return;
-        const sources = this.link.sources ?? [];
-        const sinks = this.link.sinks ?? [];
-        const bidirs = this.link.bidirs ?? [];
-        const all_defined_voltage = filter_defined_range(...bidirs.map((v) => v.voltage_out), ...sources.map((v) => v.voltage_out));
-        if (all_defined_voltage.length > 0) {
-            const voltage = hull(all_defined_voltage);
-            const all_defined_voltage_limits = filter_defined_range(sinks.map((v) => v.voltage_limits));
-            if (all_defined_voltage_limits.length > 0) {
-                const voltage_limits = intersection(all_defined_voltage_limits);
-                if (!contains(voltage_limits, voltage)) {
-                    this.ctx.report.erc_errors.push(PP_OVER_DRIVEN(this.all_port_ids, 'voltage'));
-                }
-            }
-        }
-        const all_defined_current_limits = filter_defined_range(...bidirs.map((v) => v.current_limits), ...sources.map((v) => v.current_limits));
-        if (all_defined_current_limits.length > 0) {
-            const current_limits = sum(all_defined_current_limits);
-            const all_defined_current_drawn = filter_defined_range(sinks.map((v) => v.current_drawn));
-            if (all_defined_current_drawn.length > 0) {
-                const current_drawn = sum(all_defined_current_drawn);
-                if (interests(current_drawn, current_limits)) {
-                    this.ctx.report.erc_errors.push(PP_OVER_DRIVEN(this.all_port_ids, 'current'));
-                }
-            }
-        }
-        const all_defined_output_thresholds = filter_defined_range(...bidirs.map((v) => v.output_thresholds), ...sources.map((v) => v.output_thresholds));
-        if (all_defined_output_thresholds.length > 0) {
-            const output_thresholds = intersection(all_defined_output_thresholds);
-            const all_defined_input_thresholds = filter_defined_range(sinks.map((v) => v.input_thresholds));
-            if (all_defined_input_thresholds.length > 0) {
-                const input_thresholds = hull(all_defined_input_thresholds);
-                if (!contains(output_thresholds, input_thresholds)) {
-                    this.ctx.report.erc_errors.push(PP_INCOMPATIBLE_DIGITAL_THRESHOLDS(this.all_port_ids));
-                }
-            }
-        }
-        if (!sources.length && !bidirs.length) {
-            this.ctx.report.erc_errors.push(PP_REQUIRES_CONNECTED_SOURCE_OR_BIDIR(this.all_port_ids));
-        }
-    }
-}
-/**
-  self.assign(self.voltage, self.source.voltage_out)
-  self.assign(self.voltage_limits, self.sinks.intersection(lambda x: x.voltage_limits))
-  self.require(self.voltage_limits.contains(self.voltage), "overvoltage")
-  self.assign(self.current_limits, self.source.current_limits)
-
-  self.assign(self.current_drawn, self.sinks.sum(lambda x: x.current_draw))
-  self.require(self.current_limits.contains(self.current_drawn), "overcurrent")
- */
-export class VoltageLinkTester extends LinkTesterBase {
-    check_parameter_propagation() {
-        const source = this.link.source;
-        const sinks = this.link.sinks;
-        if (range_is_defined(source.voltage_out)) {
-            const all_voltage_limits = filter_defined_range(sinks.map((v) => v.voltage_limits));
-            if (all_voltage_limits.length > 0) {
-                const voltage_limits = intersection(all_voltage_limits);
-                if (!interests(voltage_limits, source.voltage_out)) {
-                    this.ctx.report.erc_errors.push(PP_OVER_DRIVEN(this.all_port_ids, 'voltage'));
-                }
-            }
-        }
-        if (range_is_defined(source.current_limits)) {
-            const all_sinks_current_drawn = filter_defined_range(sinks.map((v) => v.current_drawn));
-            if (all_sinks_current_drawn.length > 0) {
-                const current_drawn = sum(all_sinks_current_drawn);
-                if (interests(current_drawn, source.current_limits)) {
-                    this.ctx.report.erc_errors.push(PP_OVER_DRIVEN(this.all_port_ids, 'current'));
-                }
-            }
-        }
-    }
-    init_link() {
-        const sources = [];
-        const sinks = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.VoltageSource: {
-                    sources.push(v);
-                    break;
-                }
-                case PortType.VoltageSink: {
-                    sinks.push(v);
-                    break;
-                }
-            }
-        }
-        if (sources.length === 0) {
-            this.ctx.report.erc_errors.push(PP_NOT_DRIVEN(this.all_port_ids));
-            return false;
-        }
-        if (sources.length > 1) {
-            this.ctx.report.erc_errors.push(PP_DUPLICATED_SOURCES(this.all_port_ids));
-            return false;
-        }
-        this.link = {
-            source: sources[0],
-            sinks,
-        };
-        return true;
-    }
-}
-/*
-  self.description = DescriptionString(
-      "<b>voltage</b>: ", DescriptionString.FormatUnits(self.voltage, "V"),
-      " <b>of limits</b>: ", DescriptionString.FormatUnits(self.voltage_limits, "V"))
-
-  self.assign(self.voltage, self.ref.is_connected().then_else(
-      self.ref.voltage_out, (0, 0)*Volt
-  ))
-  self.assign(self.voltage_limits, self.gnds.intersection(lambda x: x.voltage_limits))
-  self.require(self.voltage_limits.contains(self.voltage), "overvoltage")
- */
-export class GroundLinkTester extends LinkTesterBase {
-    check_parameter_propagation() {
-        if (!this.link)
-            return;
-        const ref = this.link.ref;
-        const gnds = this.link.gnds;
-        let voltage = ref?.voltage_out;
-        if (!voltage || !range_is_defined(voltage))
-            voltage = { lower: 0, upper: 0 };
-        const all_defined_voltage_limits = filter_defined_range(gnds.map((v) => v.voltage_limits));
-        if (all_defined_voltage_limits.length > 0) {
-            const voltage_limits = intersection(all_defined_voltage_limits);
-            if (!interests(voltage_limits, voltage)) {
-                this.ctx.report.erc_errors.push(PP_OVER_DRIVEN(this.all_port_ids, 'voltage'));
-            }
-        }
-    }
-    init_link() {
-        const refs = [];
-        const gnds = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.GroundReference: {
-                    refs.push(v);
-                    break;
-                }
-                case PortType.Ground: {
-                    gnds.push(v);
-                    break;
-                }
-            }
-        }
-        if (refs.length > 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'Cannot connect multiple ground references to a ground.'));
-            return false;
-        }
-        this.link = {
-            ref: refs[0],
-            gnds,
-        };
-        return true;
-    }
-}
-/**
-    self.txd = self.connect(self.controller.txd, self.transceiver.txd, self.passive.map_extract(lambda port: port.txd),
-                            flatten=True)
-    self.rxd = self.connect(self.controller.rxd, self.transceiver.rxd, self.passive.map_extract(lambda port: port.rxd),
-                            flatten=True)
- */
-export class CanLogicLinkTester extends CompositePortLinkTesterBase {
-    check_parameter_propagation() {
-        if (!this.link)
-            return;
-        const txd_tester = new DigitalLinkTester(this.ctx, [
-            this.link.controller.txd,
-            this.link.transceiver.rxd,
-            ...this.link.passive.map((port) => port.rxd),
-        ]);
-        const rxd_tester = new DigitalLinkTester(this.ctx, [
-            this.link.controller.rxd,
-            this.link.transceiver.txd,
-            ...this.link.passive.map((port) => port.txd),
-        ]);
-        for (const tst of [txd_tester, rxd_tester])
-            tst.test();
-    }
-    init_link() {
-        const controllers = [];
-        const transceivers = [];
-        const passive = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.CanControllerPort: {
-                    controllers.push(v);
-                    break;
-                }
-                case PortType.CanTransceiverPort: {
-                    transceivers.push(v);
-                    break;
-                }
-                case PortType.CanPassivePort: {
-                    passive.push(v);
-                    break;
-                }
-            }
-        }
-        if (controllers.length !== 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one controller port.'));
-            return false;
-        }
-        if (transceivers.length !== 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one transceiver port.'));
-            return false;
-        }
-        this.link = {
-            controller: controllers[0],
-            transceiver: transceivers[0],
-            passive,
-        };
-        return true;
-    }
-}
-/**
-    self.canh = self.connect(self.nodes.map_extract(lambda node: node.canh),
-                             flatten=True)
-    self.canl = self.connect(self.nodes.map_extract(lambda node: node.canl),
-                             flatten=True)
- */
-export class CanDiffLinkTester extends CompositePortLinkTesterBase {
-    check_parameter_propagation() {
-        if (!this.link)
-            return;
-        const canh_tester = new DigitalLinkTester(this.ctx, this.link.nodes.map((node) => node.canh));
-        const canl_tester = new DigitalLinkTester(this.ctx, this.link.nodes.map((node) => node.canl));
-        for (const tst of [canh_tester, canl_tester])
-            tst.test();
-    }
-    init_link() {
-        const nodes = [];
-        for (const v of this.ports) {
-            if (v.type === PortType.CanDiffPort) {
-                nodes.push(v);
-            }
-        }
-        if (nodes.length === 0) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'Requires at least one CAN differential port'));
-            return false;
-        }
-        this.link = {
-            nodes,
-        };
-        return true;
-    }
-}
-/**
-    self.require(self.driver.frequency_limits.contains(self.frequency))
-
-    self.xi = self.connect(self.driver.xtal_in, self.crystal.xtal_in)
-    self.xo = self.connect(self.driver.xtal_out, self.crystal.xtal_out)
- */
-export class CrystalLinkTester extends CompositePortLinkTesterBase {
-    check_parameter_propagation() {
-        if (!this.link)
-            return;
-        const driver = this.link.driver;
-        const crystal = this.link.crystal;
-        if (all_range_are_defined(driver.frequency_limits, crystal.frequency)) {
-            if (!contains(driver.frequency_limits, crystal.frequency)) {
-                this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'Frequency out of range'));
-            }
-        }
-    }
-    init_link() {
-        const drivers = [];
-        const crystals = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.CrystalDriver: {
-                    drivers.push(v);
-                    break;
-                }
-                case PortType.CrystalPort: {
-                    crystals.push(v);
-                    break;
-                }
-            }
-        }
-        if (drivers.length !== 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one crystal driver port.'));
-            return false;
-        }
-        if (crystals.length !== 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one crystal port.'));
-            return false;
-        }
-        this.link = {
-            driver: drivers[0],
-            crystal: crystals[0],
-        };
-        return true;
-    }
-}
-/**
-    self.swdio = self.connect(self.host.swdio, self.device.swdio, self.pull.map_extract(lambda port: port.swdio),
-                              flatten=True)
-    self.swclk = self.connect(self.host.swclk, self.device.swclk, self.pull.map_extract(lambda port: port.swclk),
-                              flatten=True)
- */
-export class SwdLinkTester extends CompositePortLinkTesterBase {
-    check_parameter_propagation() {
-        if (!this.link)
-            return;
-        const swdio_tester = new DigitalLinkTester(this.ctx, [
-            this.link.host.swdio,
-            this.link.device.swdio,
-            ...this.link.pull.map((port) => port.swdio),
-        ]);
-        const swclk_tester = new DigitalLinkTester(this.ctx, [
-            this.link.host.swclk,
-            this.link.device.swclk,
-            ...this.link.pull.map((port) => port.swclk),
-        ]);
-        for (const tst of [swdio_tester, swclk_tester])
-            tst.test();
-    }
-    init_link() {
-        const hosts = [];
-        const devices = [];
-        const pull = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.SwdHostPort: {
-                    hosts.push(v);
-                    break;
-                }
-                case PortType.SwdTargetPort: {
-                    devices.push(v);
-                    break;
-                }
-                case PortType.SwdPullPort: {
-                    pull.push(v);
-                    break;
-                }
-            }
-        }
-        if (hosts.length !== 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one SWD host port.'));
-            return false;
-        }
-        if (devices.length !== 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one SWD target port.'));
-            return false;
-        }
-        this.link = {
-            host: hosts[0],
-            device: devices[0],
-            pull,
-        };
-        return true;
-    }
-}
-/**
-    self.require(self.pull.any_connected() | self.controller.has_pullup)
-    self.require(self.pull.length() <= 1, "at most one pullup")
-    self.require(self.addresses.all_unique(), "conflicting addresses on I2C bus")
-    self.scl = self.connect(self.pull.map_extract(lambda device: device.scl),
-                            self.controller.scl, self.targets.map_extract(lambda device: device.scl),
-                            flatten=True)
-    self.sda = self.connect(self.pull.map_extract(lambda device: device.sda),
-                            self.controller.sda, self.targets.map_extract(lambda device: device.sda),
-                            flatten=True)
- */
-export class I2cLinkTester extends CompositePortLinkTesterBase {
-    check_parameter_propagation() {
-        if (!this.link)
-            return;
-        const scl_tester = new DigitalLinkTester(this.ctx, [
-            ...this.link.pull.map((device) => device.scl),
-            this.link.controller.scl,
-            ...this.link.targets.map((device) => device.scl),
-        ]);
-        const sda_tester = new DigitalLinkTester(this.ctx, [
-            ...this.link.pull.map((device) => device.sda),
-            this.link.controller.sda,
-            ...this.link.targets.map((device) => device.sda),
-        ]);
-        for (const tst of [scl_tester, sda_tester])
-            tst.test();
-        if (!this.link.pull.length && !this.link.controller.has_pullup) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'Requires at least one pullup'));
-        }
-        if (this.link.pull.length > 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'At most one pullup allowed'));
-        }
-        const addresses = this.link.targets.map((target) => target.addresses);
-        if (new Set(addresses).size !== addresses.length) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'Conflicting addresses on I2C bus'));
-        }
-    }
-    init_link() {
-        const pull = [];
-        const controllers = [];
-        const targets = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.I2cPullupPort: {
-                    pull.push(v);
-                    break;
-                }
-                case PortType.I2cController: {
-                    controllers.push(v);
-                    break;
-                }
-                case PortType.I2cTarget: {
-                    targets.push(v);
-                    break;
-                }
-            }
-        }
-        if (controllers.length !== 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one I2C controller port.'));
-            return false;
-        }
-        if (targets.length === 0) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be at least one I2C target port.'));
-            return false;
-        }
-        this.link = {
-            pull,
-            controller: controllers[0],
-            targets,
-        };
-        return true;
-    }
-}
-/**
-    self.sck = self.connect(self.controller.sck, self.target_receiver.sck)
-    self.ws = self.connect(self.controller.ws, self.target_receiver.ws)
-    self.sd = self.connect(self.controller.sd, self.target_receiver.sd)
-
- */
-export class I2sLinkTester extends CompositePortLinkTesterBase {
-    check_parameter_propagation() {
-        if (!this.link)
-            return;
-        const controller = this.link.controller;
-        const target_receiver = this.link.target_receiver;
-        const sck_tester = new DigitalLinkTester(this.ctx, [controller.sck, target_receiver.sck]);
-        const ws_tester = new DigitalLinkTester(this.ctx, [controller.ws, target_receiver.ws]);
-        const sd_tester = new DigitalLinkTester(this.ctx, [controller.sd, target_receiver.sd]);
-        for (const tst of [sck_tester, ws_tester, sd_tester])
-            tst.test();
-    }
-    init_link() {
-        const controllers = [];
-        const target_receivers = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.I2sController: {
-                    controllers.push(v);
-                    break;
-                }
-                case PortType.I2sTargetReceiver: {
-                    target_receivers.push(v);
-                    break;
-                }
-            }
-        }
-        if (controllers.length !== 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one I2S controller port.'));
-            return false;
-        }
-        if (target_receivers.length !== 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one I2S target receiver port.'));
-            return false;
-        }
-        this.link = {
-            controller: controllers[0],
-            target_receiver: target_receivers[0],
-        };
-        return true;
-    }
-}
-/**
-    self.sck = self.connect(self.controller.sck, self.peripherals.map_extract(lambda device: device.sck),
-                            flatten=True)
-    self.miso = self.connect(self.controller.miso, self.peripherals.map_extract(lambda device: device.miso),
-                             flatten=True)
-    self.mosi = self.connect(self.controller.mosi, self.peripherals.map_extract(lambda device: device.mosi),
-                             flatten=True)
-
- */
-export class SpiLinkTester extends CompositePortLinkTesterBase {
-    check_parameter_propagation() {
-        if (!this.link)
-            return;
-        const controller = this.link.controller;
-        const peripherals = this.link.peripherals;
-        const sck_tester = new DigitalLinkTester(this.ctx, [controller.sck, ...peripherals.map((device) => device.sck)]);
-        const miso_tester = new DigitalLinkTester(this.ctx, [controller.miso, ...peripherals.map((device) => device.miso)]);
-        const mosi_tester = new DigitalLinkTester(this.ctx, [controller.mosi, ...peripherals.map((device) => device.mosi)]);
-        for (const tst of [sck_tester, miso_tester, mosi_tester])
-            tst.test();
-    }
-    init_link() {
-        const controllers = [];
-        const peripherals = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.SpiController: {
-                    controllers.push(v);
-                    break;
-                }
-                case PortType.SpiPeripheral: {
-                    peripherals.push(v);
-                    break;
-                }
-            }
-        }
-        if (controllers.length !== 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one SPI controller port.'));
-            return false;
-        }
-        if (peripherals.length === 0) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be at least one SPI peripheral port.'));
-            return false;
-        }
-        this.link = {
-            controller: controllers[0],
-            peripherals,
-        };
-        return true;
-    }
-}
-/**
-    self.a = self.connect(self.source.a, self.sink.a)
-    self.b = self.connect(self.source.b, self.sink.b)
- */
-export class SpeakerLinkTester extends CompositePortLinkTesterBase {
-    check_parameter_propagation() {
-        if (!this.link)
-            return;
-        const a_tester = new AnalogLinkTester(this.ctx, [this.link.source.a, this.link.sink.a]);
-        const b_tester = new AnalogLinkTester(this.ctx, [this.link.source.b, this.link.sink.b]);
-        for (const tst of [a_tester, b_tester])
-            tst.test();
-    }
-    init_link() {
-        const sources = [];
-        const sinks = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.SpeakerDriverPort: {
-                    sources.push(v);
-                    break;
-                }
-                case PortType.SpeakerPort: {
-                    sinks.push(v);
-                    break;
-                }
-            }
-        }
-        if (sources.length !== 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one speaker driver port.'));
-            return false;
-        }
-        if (sinks.length !== 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one speaker port.'));
-            return false;
-        }
-        this.link = {
-            source: sources[0],
-            sink: sinks[0],
-        };
-        return true;
-    }
-}
-/**
-    self.driver = self.Port(TouchDriver())
-    self.pad = self.Port(TouchPadPort())
- */
-export class TouchLinkTester extends LinkTesterBase {
-    init_link() {
-        const drivers = [];
-        const pads = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.TouchDriver: {
-                    drivers.push(v);
-                    break;
-                }
-                case PortType.TouchPadPort: {
-                    pads.push(v);
-                    break;
-                }
-            }
-        }
-        if (drivers.length !== 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one touch driver port.'));
-            return false;
-        }
-        if (pads.length !== 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one touch pad port.'));
-            return false;
-        }
-        this.link = {
-            driver: drivers[0],
-            pad: pads[0],
-        };
-        return true;
-    }
-    check_parameter_propagation() {
-        return;
-    }
-}
-/**
-    self.a_tx = self.connect(self.a.tx, self.b.rx)
-    self.b_tx = self.connect(self.b.tx, self.a.rx)
-
- */
-export class UartLinkTester extends CompositePortLinkTesterBase {
-    check_parameter_propagation() {
-        if (!this.link)
-            return;
-        const tx_tester = new DigitalLinkTester(this.ctx, [this.link.a.tx, this.link.b.rx]);
-        const rx_tester = new DigitalLinkTester(this.ctx, [this.link.b.tx, this.link.a.rx]);
-        for (const tst of [tx_tester, rx_tester])
-            tst.test();
-    }
-    init_link() {
-        const ports = [];
-        for (const v of this.ports) {
-            if (v.type === PortType.UartPort) {
-                ports.push(v);
-            }
-        }
-        if (ports.length !== 2) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly two UART ports.'));
-            return false;
-        }
-        this.link = {
-            a: ports[0],
-            b: ports[1],
-        };
-        return true;
-    }
-}
-/**
-
-    self.d_P = self.connect(self.host.dp, self.device.dp, self.passive.map_extract(lambda port: port.dp),
-                            flatten=True)
-    self.d_N = self.connect(self.host.dm, self.device.dm, self.passive.map_extract(lambda port: port.dm),
-                            flatten=True)
- */
-export class UsbLinkTester extends CompositePortLinkTesterBase {
-    check_parameter_propagation() {
-        if (!this.link)
-            return;
-        const dp_tester = new DigitalLinkTester(this.ctx, [
-            this.link.host.dp,
-            this.link.device.dp,
-            ...this.link.passive.map((port) => port.dp),
-        ]);
-        const dm_tester = new DigitalLinkTester(this.ctx, [
-            this.link.host.dm,
-            this.link.device.dm,
-            ...this.link.passive.map((port) => port.dm),
-        ]);
-        for (const tst of [dp_tester, dm_tester])
-            tst.test();
-    }
-    init_link() {
-        const hosts = [];
-        const devices = [];
-        const passive = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.UsbHostPort: {
-                    hosts.push(v);
-                    break;
-                }
-                case PortType.UsbDevicePort: {
-                    devices.push(v);
-                    break;
-                }
-                case PortType.UsbPassivePort: {
-                    passive.push(v);
-                    break;
-                }
-            }
-        }
-        if (hosts.length !== 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one USB host port.'));
-            return false;
-        }
-        if (devices.length !== 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one USB device port.'));
-            return false;
-        }
-        this.link = {
-            host: hosts[0],
-            device: devices[0],
-            passive,
-        };
-        return true;
-    }
-}
-/**
-    self.cc1 = self.Port(DigitalBidir(pullup_capable=pullup_capable))
-    self.cc2 = self.Port(DigitalBidir(pullup_capable=pullup_capable))
-
- */
-export class UsbCcLinkTester extends CompositePortLinkTesterBase {
-    check_parameter_propagation() {
-        if (!this.link)
-            return;
-        const cc1_tester = new DigitalLinkTester(this.ctx, [this.link.a.cc1, this.link.b.cc1]);
-        const cc2_tester = new DigitalLinkTester(this.ctx, [this.link.a.cc2, this.link.b.cc2]);
-        for (const tst of [cc1_tester, cc2_tester])
-            tst.test();
-    }
-    init_link() {
-        const nodes = [];
-        for (const v of this.ports) {
-            if (v.type === PortType.UsbCcPort) {
-                nodes.push(v);
-            }
-        }
-        if (nodes.length !== 2) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly two CC ports.'));
-            return false;
-        }
-        this.link = {
-            a: nodes[0],
-            b: nodes[1],
-        };
-        return true;
-    }
-}
-/**
-
-    self.xclk = self.connect(self.host.xclk, self.cam.xclk)
-    self.pclk = self.connect(self.host.pclk, self.cam.pclk)
-    self.href = self.connect(self.host.href, self.cam.href)
-    self.vsync = self.connect(self.host.vsync, self.cam.vsync)
-
-    self.y0 = self.connect(self.host.y0, self.cam.y0)
-    self.y1 = self.connect(self.host.y1, self.cam.y1)
-    self.y2 = self.connect(self.host.y2, self.cam.y2)
-    self.y3 = self.connect(self.host.y3, self.cam.y3)
-    self.y4 = self.connect(self.host.y4, self.cam.y4)
-    self.y5 = self.connect(self.host.y5, self.cam.y5)
-    self.y6 = self.connect(self.host.y6, self.cam.y6)
-    self.y7 = self.connect(self.host.y7, self.cam.y7)
-
- */
-export class Dvp8LinkTester extends CompositePortLinkTesterBase {
-    check_parameter_propagation() {
-        if (!this.link)
-            return;
-        const host = this.link.host;
-        const cam = this.link.cam;
-        const digitalLinks = [
-            [host.xclk, cam.xclk],
-            [host.pclk, cam.pclk],
-            [host.href, cam.href],
-            [host.vsync, cam.vsync],
-            [host.y0, cam.y0],
-            [host.y1, cam.y1],
-            [host.y2, cam.y2],
-            [host.y3, cam.y3],
-            [host.y4, cam.y4],
-            [host.y5, cam.y5],
-            [host.y6, cam.y6],
-            [host.y7, cam.y7],
-        ];
-        for (const [hostPort, camPort] of digitalLinks) {
-            const tester = new DigitalLinkTester(this.ctx, [hostPort, camPort]);
-            tester.test();
-        }
-    }
-    init_link() {
-        const hosts = [];
-        const cams = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.Dvp8Host: {
-                    hosts.push(v);
-                    break;
-                }
-                case PortType.Dvp8Camera: {
-                    cams.push(v);
-                    break;
-                }
-            }
-        }
-        if (hosts.length !== 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one DVP8 host port.'));
-            return false;
-        }
-        if (cams.length !== 1) {
-            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one DVP8 camera port.'));
-            return false;
-        }
-        this.link = {
-            host: hosts[0],
-            cam: cams[0],
-        };
-        return true;
-    }
-}