@modular-circuit/perc 0.0.51

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

@@ -0,0 +1,1456 @@
+// add the other testers following the  AnalogLinkTester
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+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")
+ */
+var AnalogLinkTester = /** @class */ (function (_super) {
+    __extends(AnalogLinkTester, _super);
+    function AnalogLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    AnalogLinkTester.prototype.init_link = function () {
+        var e_1, _a;
+        var sources = [];
+        var sinks = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.AnalogSource: {
+                        sources.push(v);
+                        break;
+                    }
+                    case PortType.AnalogSink: {
+                        sinks.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        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: sinks,
+        };
+        return true;
+    };
+    AnalogLinkTester.prototype.check_parameter_propagation = function () {
+        if (!this.link)
+            return;
+        var source = this.link.source;
+        var sinks = this.link.sinks;
+        var source_id = this.ctx.port_id.get(source);
+        if (range_is_defined(source.impedance)) {
+            var all_sinks_impedance = filter_defined_range(sinks.map(function (v) { return v.impedance; }));
+            if (all_sinks_impedance.length > 0) {
+                var sink_impedance = r_div(sum(all_sinks_impedance.map(function (v) { return 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)) {
+            var all_voltage_limits = filter_defined_range(sinks.map(function (v) { return v.voltage_limits; }));
+            if (all_voltage_limits.length > 0) {
+                var 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)) {
+            var all_sinks_signal_limits = filter_defined_range(sinks.map(function (v) { return v.signal_limits; }));
+            if (all_sinks_signal_limits.length > 0) {
+                var 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)) {
+            var all_sinks_current_drawn = filter_defined_range(sinks.map(function (v) { return v.current_drawn; }));
+            if (all_sinks_current_drawn.length > 0) {
+                var 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'));
+                }
+            }
+        }
+    };
+    return AnalogLinkTester;
+}(LinkTesterBase));
+export { AnalogLinkTester };
+/**
+ 
+    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")
+
+
+ */
+var DigitalLinkTester = /** @class */ (function (_super) {
+    __extends(DigitalLinkTester, _super);
+    function DigitalLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DigitalLinkTester.prototype.init_link = function () {
+        var e_2, _a;
+        var sinks = [];
+        var sources = [];
+        var bidirs = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.DigitalSource: {
+                        sources.push(v);
+                        break;
+                    }
+                    case PortType.DigitalSink: {
+                        sinks.push(v);
+                        break;
+                    }
+                    case PortType.DigitalBidir: {
+                        bidirs.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        this.link = {
+            sources: sources,
+            sinks: sinks,
+            bidirs: bidirs,
+        };
+        return true;
+    };
+    DigitalLinkTester.prototype.check_parameter_propagation = function () {
+        var _a, _b, _c;
+        if (!this.link)
+            return;
+        var sources = (_a = this.link.sources) !== null && _a !== void 0 ? _a : [];
+        var sinks = (_b = this.link.sinks) !== null && _b !== void 0 ? _b : [];
+        var bidirs = (_c = this.link.bidirs) !== null && _c !== void 0 ? _c : [];
+        var all_defined_voltage = filter_defined_range.apply(void 0, __spreadArray(__spreadArray([], __read(bidirs.map(function (v) { return v.voltage_out; })), false), __read(sources.map(function (v) { return v.voltage_out; })), false));
+        if (all_defined_voltage.length > 0) {
+            var voltage = hull(all_defined_voltage);
+            var all_defined_voltage_limits = filter_defined_range(sinks.map(function (v) { return v.voltage_limits; }));
+            if (all_defined_voltage_limits.length > 0) {
+                var 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'));
+                }
+            }
+        }
+        var all_defined_current_limits = filter_defined_range.apply(void 0, __spreadArray(__spreadArray([], __read(bidirs.map(function (v) { return v.current_limits; })), false), __read(sources.map(function (v) { return v.current_limits; })), false));
+        if (all_defined_current_limits.length > 0) {
+            var current_limits = sum(all_defined_current_limits);
+            var all_defined_current_drawn = filter_defined_range(sinks.map(function (v) { return v.current_drawn; }));
+            if (all_defined_current_drawn.length > 0) {
+                var 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'));
+                }
+            }
+        }
+        var all_defined_output_thresholds = filter_defined_range.apply(void 0, __spreadArray(__spreadArray([], __read(bidirs.map(function (v) { return v.output_thresholds; })), false), __read(sources.map(function (v) { return v.output_thresholds; })), false));
+        if (all_defined_output_thresholds.length > 0) {
+            var output_thresholds = intersection(all_defined_output_thresholds);
+            var all_defined_input_thresholds = filter_defined_range(sinks.map(function (v) { return v.input_thresholds; }));
+            if (all_defined_input_thresholds.length > 0) {
+                var 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));
+        }
+    };
+    return DigitalLinkTester;
+}(LinkTesterBase));
+export { DigitalLinkTester };
+/**
+  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")
+ */
+var VoltageLinkTester = /** @class */ (function (_super) {
+    __extends(VoltageLinkTester, _super);
+    function VoltageLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    VoltageLinkTester.prototype.check_parameter_propagation = function () {
+        var source = this.link.source;
+        var sinks = this.link.sinks;
+        if (range_is_defined(source.voltage_out)) {
+            var all_voltage_limits = filter_defined_range(sinks.map(function (v) { return v.voltage_limits; }));
+            if (all_voltage_limits.length > 0) {
+                var 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)) {
+            var all_sinks_current_drawn = filter_defined_range(sinks.map(function (v) { return v.current_drawn; }));
+            if (all_sinks_current_drawn.length > 0) {
+                var 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'));
+                }
+            }
+        }
+    };
+    VoltageLinkTester.prototype.init_link = function () {
+        var e_3, _a;
+        var sources = [];
+        var sinks = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.VoltageSource: {
+                        sources.push(v);
+                        break;
+                    }
+                    case PortType.VoltageSink: {
+                        sinks.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        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: sinks,
+        };
+        return true;
+    };
+    return VoltageLinkTester;
+}(LinkTesterBase));
+export { VoltageLinkTester };
+/*
+  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")
+ */
+var GroundLinkTester = /** @class */ (function (_super) {
+    __extends(GroundLinkTester, _super);
+    function GroundLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    GroundLinkTester.prototype.check_parameter_propagation = function () {
+        if (!this.link)
+            return;
+        var ref = this.link.ref;
+        var gnds = this.link.gnds;
+        var voltage = ref === null || ref === void 0 ? void 0 : ref.voltage_out;
+        if (!voltage || !range_is_defined(voltage))
+            voltage = { lower: 0, upper: 0 };
+        var all_defined_voltage_limits = filter_defined_range(gnds.map(function (v) { return v.voltage_limits; }));
+        if (all_defined_voltage_limits.length > 0) {
+            var 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'));
+            }
+        }
+    };
+    GroundLinkTester.prototype.init_link = function () {
+        var e_4, _a;
+        var refs = [];
+        var gnds = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.GroundReference: {
+                        refs.push(v);
+                        break;
+                    }
+                    case PortType.Ground: {
+                        gnds.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        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: gnds,
+        };
+        return true;
+    };
+    return GroundLinkTester;
+}(LinkTesterBase));
+export { GroundLinkTester };
+/**
+    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)
+ */
+var CanLogicLinkTester = /** @class */ (function (_super) {
+    __extends(CanLogicLinkTester, _super);
+    function CanLogicLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CanLogicLinkTester.prototype.check_parameter_propagation = function () {
+        var e_5, _a;
+        if (!this.link)
+            return;
+        var txd_tester = new DigitalLinkTester(this.ctx, __spreadArray([
+            this.link.controller.txd,
+            this.link.transceiver.rxd
+        ], __read(this.link.passive.map(function (port) { return port.rxd; })), false));
+        var rxd_tester = new DigitalLinkTester(this.ctx, __spreadArray([
+            this.link.controller.rxd,
+            this.link.transceiver.txd
+        ], __read(this.link.passive.map(function (port) { return port.txd; })), false));
+        try {
+            for (var _b = __values([txd_tester, rxd_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+    };
+    CanLogicLinkTester.prototype.init_link = function () {
+        var e_6, _a;
+        var controllers = [];
+        var transceivers = [];
+        var passive = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.CanControllerPort: {
+                        controllers.push(v);
+                        break;
+                    }
+                    case PortType.CanTransceiverPort: {
+                        transceivers.push(v);
+                        break;
+                    }
+                    case PortType.CanPassivePort: {
+                        passive.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        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: passive,
+        };
+        return true;
+    };
+    return CanLogicLinkTester;
+}(CompositePortLinkTesterBase));
+export { CanLogicLinkTester };
+/**
+    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)
+ */
+var CanDiffLinkTester = /** @class */ (function (_super) {
+    __extends(CanDiffLinkTester, _super);
+    function CanDiffLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CanDiffLinkTester.prototype.check_parameter_propagation = function () {
+        var e_7, _a;
+        if (!this.link)
+            return;
+        var canh_tester = new DigitalLinkTester(this.ctx, this.link.nodes.map(function (node) { return node.canh; }));
+        var canl_tester = new DigitalLinkTester(this.ctx, this.link.nodes.map(function (node) { return node.canl; }));
+        try {
+            for (var _b = __values([canh_tester, canl_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+    };
+    CanDiffLinkTester.prototype.init_link = function () {
+        var e_8, _a;
+        var nodes = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                if (v.type === PortType.CanDiffPort) {
+                    nodes.push(v);
+                }
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        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: nodes,
+        };
+        return true;
+    };
+    return CanDiffLinkTester;
+}(CompositePortLinkTesterBase));
+export { CanDiffLinkTester };
+/**
+    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)
+ */
+var CrystalLinkTester = /** @class */ (function (_super) {
+    __extends(CrystalLinkTester, _super);
+    function CrystalLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CrystalLinkTester.prototype.check_parameter_propagation = function () {
+        if (!this.link)
+            return;
+        var driver = this.link.driver;
+        var 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'));
+            }
+        }
+    };
+    CrystalLinkTester.prototype.init_link = function () {
+        var e_9, _a;
+        var drivers = [];
+        var crystals = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.CrystalDriver: {
+                        drivers.push(v);
+                        break;
+                    }
+                    case PortType.CrystalPort: {
+                        crystals.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+        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;
+    };
+    return CrystalLinkTester;
+}(CompositePortLinkTesterBase));
+export { CrystalLinkTester };
+/**
+    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)
+ */
+var SwdLinkTester = /** @class */ (function (_super) {
+    __extends(SwdLinkTester, _super);
+    function SwdLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SwdLinkTester.prototype.check_parameter_propagation = function () {
+        var e_10, _a;
+        if (!this.link)
+            return;
+        var swdio_tester = new DigitalLinkTester(this.ctx, __spreadArray([
+            this.link.host.swdio,
+            this.link.device.swdio
+        ], __read(this.link.pull.map(function (port) { return port.swdio; })), false));
+        var swclk_tester = new DigitalLinkTester(this.ctx, __spreadArray([
+            this.link.host.swclk,
+            this.link.device.swclk
+        ], __read(this.link.pull.map(function (port) { return port.swclk; })), false));
+        try {
+            for (var _b = __values([swdio_tester, swclk_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+    };
+    SwdLinkTester.prototype.init_link = function () {
+        var e_11, _a;
+        var hosts = [];
+        var devices = [];
+        var pull = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.SwdHostPort: {
+                        hosts.push(v);
+                        break;
+                    }
+                    case PortType.SwdTargetPort: {
+                        devices.push(v);
+                        break;
+                    }
+                    case PortType.SwdPullPort: {
+                        pull.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+        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: pull,
+        };
+        return true;
+    };
+    return SwdLinkTester;
+}(CompositePortLinkTesterBase));
+export { SwdLinkTester };
+/**
+    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)
+ */
+var I2cLinkTester = /** @class */ (function (_super) {
+    __extends(I2cLinkTester, _super);
+    function I2cLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    I2cLinkTester.prototype.check_parameter_propagation = function () {
+        var e_12, _a;
+        if (!this.link)
+            return;
+        var scl_tester = new DigitalLinkTester(this.ctx, __spreadArray(__spreadArray(__spreadArray([], __read(this.link.pull.map(function (device) { return device.scl; })), false), [
+            this.link.controller.scl
+        ], false), __read(this.link.targets.map(function (device) { return device.scl; })), false));
+        var sda_tester = new DigitalLinkTester(this.ctx, __spreadArray(__spreadArray(__spreadArray([], __read(this.link.pull.map(function (device) { return device.sda; })), false), [
+            this.link.controller.sda
+        ], false), __read(this.link.targets.map(function (device) { return device.sda; })), false));
+        try {
+            for (var _b = __values([scl_tester, sda_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
+        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'));
+        }
+        var addresses = this.link.targets.map(function (target) { return 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'));
+        }
+    };
+    I2cLinkTester.prototype.init_link = function () {
+        var e_13, _a;
+        var pull = [];
+        var controllers = [];
+        var targets = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.I2cPullupPort: {
+                        pull.push(v);
+                        break;
+                    }
+                    case PortType.I2cController: {
+                        controllers.push(v);
+                        break;
+                    }
+                    case PortType.I2cTarget: {
+                        targets.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_13_1) { e_13 = { error: e_13_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_13) throw e_13.error; }
+        }
+        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: pull,
+            controller: controllers[0],
+            targets: targets,
+        };
+        return true;
+    };
+    return I2cLinkTester;
+}(CompositePortLinkTesterBase));
+export { I2cLinkTester };
+/**
+    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)
+
+ */
+var I2sLinkTester = /** @class */ (function (_super) {
+    __extends(I2sLinkTester, _super);
+    function I2sLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    I2sLinkTester.prototype.check_parameter_propagation = function () {
+        var e_14, _a;
+        if (!this.link)
+            return;
+        var controller = this.link.controller;
+        var target_receiver = this.link.target_receiver;
+        var sck_tester = new DigitalLinkTester(this.ctx, [controller.sck, target_receiver.sck]);
+        var ws_tester = new DigitalLinkTester(this.ctx, [controller.ws, target_receiver.ws]);
+        var sd_tester = new DigitalLinkTester(this.ctx, [controller.sd, target_receiver.sd]);
+        try {
+            for (var _b = __values([sck_tester, ws_tester, sd_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_14) throw e_14.error; }
+        }
+    };
+    I2sLinkTester.prototype.init_link = function () {
+        var e_15, _a;
+        var controllers = [];
+        var target_receivers = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.I2sController: {
+                        controllers.push(v);
+                        break;
+                    }
+                    case PortType.I2sTargetReceiver: {
+                        target_receivers.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_15) throw e_15.error; }
+        }
+        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;
+    };
+    return I2sLinkTester;
+}(CompositePortLinkTesterBase));
+export { I2sLinkTester };
+/**
+    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)
+
+ */
+var SpiLinkTester = /** @class */ (function (_super) {
+    __extends(SpiLinkTester, _super);
+    function SpiLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SpiLinkTester.prototype.check_parameter_propagation = function () {
+        var e_16, _a;
+        if (!this.link)
+            return;
+        var controller = this.link.controller;
+        var peripherals = this.link.peripherals;
+        var sck_tester = new DigitalLinkTester(this.ctx, __spreadArray([controller.sck], __read(peripherals.map(function (device) { return device.sck; })), false));
+        var miso_tester = new DigitalLinkTester(this.ctx, __spreadArray([controller.miso], __read(peripherals.map(function (device) { return device.miso; })), false));
+        var mosi_tester = new DigitalLinkTester(this.ctx, __spreadArray([controller.mosi], __read(peripherals.map(function (device) { return device.mosi; })), false));
+        try {
+            for (var _b = __values([sck_tester, miso_tester, mosi_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        catch (e_16_1) { e_16 = { error: e_16_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_16) throw e_16.error; }
+        }
+    };
+    SpiLinkTester.prototype.init_link = function () {
+        var e_17, _a;
+        var controllers = [];
+        var peripherals = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.SpiController: {
+                        controllers.push(v);
+                        break;
+                    }
+                    case PortType.SpiPeripheral: {
+                        peripherals.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_17) throw e_17.error; }
+        }
+        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: peripherals,
+        };
+        return true;
+    };
+    return SpiLinkTester;
+}(CompositePortLinkTesterBase));
+export { SpiLinkTester };
+/**
+    self.a = self.connect(self.source.a, self.sink.a)
+    self.b = self.connect(self.source.b, self.sink.b)
+ */
+var SpeakerLinkTester = /** @class */ (function (_super) {
+    __extends(SpeakerLinkTester, _super);
+    function SpeakerLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SpeakerLinkTester.prototype.check_parameter_propagation = function () {
+        var e_18, _a;
+        if (!this.link)
+            return;
+        var a_tester = new AnalogLinkTester(this.ctx, [this.link.source.a, this.link.sink.a]);
+        var b_tester = new AnalogLinkTester(this.ctx, [this.link.source.b, this.link.sink.b]);
+        try {
+            for (var _b = __values([a_tester, b_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        catch (e_18_1) { e_18 = { error: e_18_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_18) throw e_18.error; }
+        }
+    };
+    SpeakerLinkTester.prototype.init_link = function () {
+        var e_19, _a;
+        var sources = [];
+        var sinks = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.SpeakerDriverPort: {
+                        sources.push(v);
+                        break;
+                    }
+                    case PortType.SpeakerPort: {
+                        sinks.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_19_1) { e_19 = { error: e_19_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_19) throw e_19.error; }
+        }
+        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;
+    };
+    return SpeakerLinkTester;
+}(CompositePortLinkTesterBase));
+export { SpeakerLinkTester };
+/**
+    self.driver = self.Port(TouchDriver())
+    self.pad = self.Port(TouchPadPort())
+ */
+var TouchLinkTester = /** @class */ (function (_super) {
+    __extends(TouchLinkTester, _super);
+    function TouchLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TouchLinkTester.prototype.init_link = function () {
+        var e_20, _a;
+        var drivers = [];
+        var pads = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.TouchDriver: {
+                        drivers.push(v);
+                        break;
+                    }
+                    case PortType.TouchPadPort: {
+                        pads.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_20_1) { e_20 = { error: e_20_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_20) throw e_20.error; }
+        }
+        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;
+    };
+    TouchLinkTester.prototype.check_parameter_propagation = function () {
+        return;
+    };
+    return TouchLinkTester;
+}(LinkTesterBase));
+export { TouchLinkTester };
+/**
+    self.a_tx = self.connect(self.a.tx, self.b.rx)
+    self.b_tx = self.connect(self.b.tx, self.a.rx)
+
+ */
+var UartLinkTester = /** @class */ (function (_super) {
+    __extends(UartLinkTester, _super);
+    function UartLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UartLinkTester.prototype.check_parameter_propagation = function () {
+        var e_21, _a;
+        if (!this.link)
+            return;
+        var tx_tester = new DigitalLinkTester(this.ctx, [this.link.a.tx, this.link.b.rx]);
+        var rx_tester = new DigitalLinkTester(this.ctx, [this.link.b.tx, this.link.a.rx]);
+        try {
+            for (var _b = __values([tx_tester, rx_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        catch (e_21_1) { e_21 = { error: e_21_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_21) throw e_21.error; }
+        }
+    };
+    UartLinkTester.prototype.init_link = function () {
+        var e_22, _a;
+        var ports = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                if (v.type === PortType.UartPort) {
+                    ports.push(v);
+                }
+            }
+        }
+        catch (e_22_1) { e_22 = { error: e_22_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_22) throw e_22.error; }
+        }
+        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;
+    };
+    return UartLinkTester;
+}(CompositePortLinkTesterBase));
+export { UartLinkTester };
+/**
+
+    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)
+ */
+var UsbLinkTester = /** @class */ (function (_super) {
+    __extends(UsbLinkTester, _super);
+    function UsbLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UsbLinkTester.prototype.check_parameter_propagation = function () {
+        var e_23, _a;
+        if (!this.link)
+            return;
+        var dp_tester = new DigitalLinkTester(this.ctx, __spreadArray([
+            this.link.host.dp,
+            this.link.device.dp
+        ], __read(this.link.passive.map(function (port) { return port.dp; })), false));
+        var dm_tester = new DigitalLinkTester(this.ctx, __spreadArray([
+            this.link.host.dm,
+            this.link.device.dm
+        ], __read(this.link.passive.map(function (port) { return port.dm; })), false));
+        try {
+            for (var _b = __values([dp_tester, dm_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        catch (e_23_1) { e_23 = { error: e_23_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_23) throw e_23.error; }
+        }
+    };
+    UsbLinkTester.prototype.init_link = function () {
+        var e_24, _a;
+        var hosts = [];
+        var devices = [];
+        var passive = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.UsbHostPort: {
+                        hosts.push(v);
+                        break;
+                    }
+                    case PortType.UsbDevicePort: {
+                        devices.push(v);
+                        break;
+                    }
+                    case PortType.UsbPassivePort: {
+                        passive.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_24_1) { e_24 = { error: e_24_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_24) throw e_24.error; }
+        }
+        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: passive,
+        };
+        return true;
+    };
+    return UsbLinkTester;
+}(CompositePortLinkTesterBase));
+export { UsbLinkTester };
+/**
+    self.cc1 = self.Port(DigitalBidir(pullup_capable=pullup_capable))
+    self.cc2 = self.Port(DigitalBidir(pullup_capable=pullup_capable))
+
+ */
+var UsbCcLinkTester = /** @class */ (function (_super) {
+    __extends(UsbCcLinkTester, _super);
+    function UsbCcLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UsbCcLinkTester.prototype.check_parameter_propagation = function () {
+        var e_25, _a;
+        if (!this.link)
+            return;
+        var cc1_tester = new DigitalLinkTester(this.ctx, [this.link.a.cc1, this.link.b.cc1]);
+        var cc2_tester = new DigitalLinkTester(this.ctx, [this.link.a.cc2, this.link.b.cc2]);
+        try {
+            for (var _b = __values([cc1_tester, cc2_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        catch (e_25_1) { e_25 = { error: e_25_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_25) throw e_25.error; }
+        }
+    };
+    UsbCcLinkTester.prototype.init_link = function () {
+        var e_26, _a;
+        var nodes = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                if (v.type === PortType.UsbCcPort) {
+                    nodes.push(v);
+                }
+            }
+        }
+        catch (e_26_1) { e_26 = { error: e_26_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_26) throw e_26.error; }
+        }
+        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;
+    };
+    return UsbCcLinkTester;
+}(CompositePortLinkTesterBase));
+export { UsbCcLinkTester };
+/**
+
+    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)
+
+ */
+var Dvp8LinkTester = /** @class */ (function (_super) {
+    __extends(Dvp8LinkTester, _super);
+    function Dvp8LinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Dvp8LinkTester.prototype.check_parameter_propagation = function () {
+        var e_27, _a;
+        if (!this.link)
+            return;
+        var host = this.link.host;
+        var cam = this.link.cam;
+        var 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],
+        ];
+        try {
+            for (var digitalLinks_1 = __values(digitalLinks), digitalLinks_1_1 = digitalLinks_1.next(); !digitalLinks_1_1.done; digitalLinks_1_1 = digitalLinks_1.next()) {
+                var _b = __read(digitalLinks_1_1.value, 2), hostPort = _b[0], camPort = _b[1];
+                var tester = new DigitalLinkTester(this.ctx, [hostPort, camPort]);
+                tester.test();
+            }
+        }
+        catch (e_27_1) { e_27 = { error: e_27_1 }; }
+        finally {
+            try {
+                if (digitalLinks_1_1 && !digitalLinks_1_1.done && (_a = digitalLinks_1.return)) _a.call(digitalLinks_1);
+            }
+            finally { if (e_27) throw e_27.error; }
+        }
+    };
+    Dvp8LinkTester.prototype.init_link = function () {
+        var e_28, _a;
+        var hosts = [];
+        var cams = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.Dvp8Host: {
+                        hosts.push(v);
+                        break;
+                    }
+                    case PortType.Dvp8Camera: {
+                        cams.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_28_1) { e_28 = { error: e_28_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_28) throw e_28.error; }
+        }
+        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;
+    };
+    return Dvp8LinkTester;
+}(CompositePortLinkTesterBase));
+export { Dvp8LinkTester };