@modular-circuit/perc 0.0.51

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

@@ -0,0 +1,112 @@
+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;
+};
+import { LABEL_ASSOCIATED } from '@modular-circuit/electronics-model';
+var LinkTesterBase = /** @class */ (function () {
+    function LinkTesterBase(ctx, ports) {
+        this.ctx = ctx;
+        this.ports = ports;
+    }
+    LinkTesterBase.prototype.test = function () {
+        if (!this.init_link())
+            return;
+        this.check_parameter_propagation();
+    };
+    Object.defineProperty(LinkTesterBase.prototype, "all_port_ids", {
+        get: function () {
+            var _this = this;
+            if (!this._all_port_ids)
+                this._all_port_ids = this.ports.map(function (v) { return _this.ctx.port_id.get(v); });
+            return this._all_port_ids;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return LinkTesterBase;
+}());
+export { LinkTesterBase };
+var CompositePortLinkTesterBase = /** @class */ (function (_super) {
+    __extends(CompositePortLinkTesterBase, _super);
+    function CompositePortLinkTesterBase() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CompositePortLinkTesterBase.prototype.test = function () {
+        var e_1, _a;
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var port = _c.value;
+                this.annot_composite_port(port, this.ctx.port_id.get(port));
+            }
+        }
+        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; }
+        }
+        _super.prototype.test.call(this);
+    };
+    CompositePortLinkTesterBase.prototype.annot_composite_port = function (port, uuid) {
+        var e_2, _a;
+        try {
+            for (var _b = __values(Object.entries(port)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), k = _d[0], v = _d[1];
+                if (k === LABEL_ASSOCIATED && typeof v === 'string') {
+                    this.ctx.port_id.set(port, v);
+                }
+                else if (typeof v === 'object' && !Array.isArray(v) && v !== null) {
+                    this.annot_composite_port(v, uuid);
+                }
+            }
+        }
+        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; }
+        }
+    };
+    return CompositePortLinkTesterBase;
+}(LinkTesterBase));
+export { CompositePortLinkTesterBase };

package/build/erc/parameter_propagation/link_testers/tester_impl.d.ts

@@ -0,0 +1,247 @@
+import { CompositePortLinkTesterBase, LinkTesterBase } from './link_tester_base';
+import type { AnalogLink, CanDiffLink, CanLogicLink, CrystalLink, DigitalLink, Dvp8Link, GroundLink, I2cLink, I2sLink, SpeakerLink, SpiLink, SwdLink, TouchLink, UartLink, UsbCcLink, UsbLink, VoltageLink } from '@modular-circuit/electronics-model';
+/**
+    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 declare class AnalogLinkTester extends LinkTesterBase<AnalogLink> {
+    protected init_link(): boolean;
+    check_parameter_propagation(): void;
+}
+/**
+ 
+    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 declare class DigitalLinkTester extends LinkTesterBase<DigitalLink> {
+    protected init_link(): boolean;
+    check_parameter_propagation(): void;
+}
+/**
+  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 declare class VoltageLinkTester extends LinkTesterBase<VoltageLink> {
+    protected check_parameter_propagation(): void;
+    protected init_link(): boolean;
+}
+export declare class GroundLinkTester extends LinkTesterBase<GroundLink> {
+    protected check_parameter_propagation(): void;
+    protected init_link(): boolean;
+}
+/**
+    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 declare class CanLogicLinkTester extends CompositePortLinkTesterBase<CanLogicLink> {
+    protected check_parameter_propagation(): void;
+    protected init_link(): boolean;
+}
+/**
+    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 declare class CanDiffLinkTester extends CompositePortLinkTesterBase<CanDiffLink> {
+    protected check_parameter_propagation(): void;
+    protected init_link(): boolean;
+}
+/**
+    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 declare class CrystalLinkTester extends CompositePortLinkTesterBase<CrystalLink> {
+    protected check_parameter_propagation(): void;
+    protected init_link(): boolean;
+}
+/**
+    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 declare class SwdLinkTester extends CompositePortLinkTesterBase<SwdLink> {
+    protected check_parameter_propagation(): void;
+    protected init_link(): boolean;
+}
+/**
+    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 declare class I2cLinkTester extends CompositePortLinkTesterBase<I2cLink> {
+    protected check_parameter_propagation(): void;
+    protected init_link(): boolean;
+}
+/**
+    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 declare class I2sLinkTester extends CompositePortLinkTesterBase<I2sLink> {
+    protected check_parameter_propagation(): void;
+    protected init_link(): boolean;
+}
+/**
+    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 declare class SpiLinkTester extends CompositePortLinkTesterBase<SpiLink> {
+    protected check_parameter_propagation(): void;
+    protected init_link(): boolean;
+}
+/**
+    self.a = self.connect(self.source.a, self.sink.a)
+    self.b = self.connect(self.source.b, self.sink.b)
+ */
+export declare class SpeakerLinkTester extends CompositePortLinkTesterBase<SpeakerLink> {
+    protected check_parameter_propagation(): void;
+    protected init_link(): boolean;
+}
+/**
+    self.driver = self.Port(TouchDriver())
+    self.pad = self.Port(TouchPadPort())
+ */
+export declare class TouchLinkTester extends LinkTesterBase<TouchLink> {
+    protected init_link(): boolean;
+    protected check_parameter_propagation(): void;
+}
+/**
+    self.a_tx = self.connect(self.a.tx, self.b.rx)
+    self.b_tx = self.connect(self.b.tx, self.a.rx)
+
+ */
+export declare class UartLinkTester extends CompositePortLinkTesterBase<UartLink> {
+    protected check_parameter_propagation(): void;
+    protected init_link(): boolean;
+}
+/**
+
+    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 declare class UsbLinkTester extends CompositePortLinkTesterBase<UsbLink> {
+    protected check_parameter_propagation(): void;
+    protected init_link(): boolean;
+}
+/**
+    self.cc1 = self.Port(DigitalBidir(pullup_capable=pullup_capable))
+    self.cc2 = self.Port(DigitalBidir(pullup_capable=pullup_capable))
+
+ */
+export declare class UsbCcLinkTester extends CompositePortLinkTesterBase<UsbCcLink> {
+    protected check_parameter_propagation(): void;
+    protected init_link(): boolean;
+}
+/**
+
+    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 declare class Dvp8LinkTester extends CompositePortLinkTesterBase<Dvp8Link> {
+    protected check_parameter_propagation(): void;
+    protected init_link(): boolean;
+}
+//# sourceMappingURL=tester_impl.d.ts.map

package/build/erc/parameter_propagation/link_testers/tester_impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tester_impl.d.ts","sourceRoot":"","sources":["../../../../src/erc/parameter_propagation/link_testers/tester_impl.ts"],"names":[],"mappings":"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"}