75 lines
3.0 KiB
TypeScript
75 lines
3.0 KiB
TypeScript
/**
|
||
* Synthetic pin numbers for custom-chip output pins.
|
||
*
|
||
* A custom-chip output pin wired DIRECTLY to a component (e.g. a wokwi-led)
|
||
* has no board GPIO on its net, so the wire-graph trace returns null and the
|
||
* chip can drive nothing through the digital PinManager. We give every such
|
||
* chip pin a stable synthetic pin NUMBER, far above any real board pin
|
||
* (max ~69), so the chip's driver and every component on the same net share
|
||
* one PinManager key — making the chip a first-class pin source.
|
||
*
|
||
* The same (chipId, pinName) identity keys the SPICE chip voltage source (see
|
||
* chipPinDrives + spice/componentToSpice) so the analog engine drives the net
|
||
* too. Kept in this dependency-light module so both the resolver
|
||
* (components/DynamicComponent) and the chip runtime (ChipRuntime) can import
|
||
* it without pulling in React / the store.
|
||
*/
|
||
|
||
export const SYNTHETIC_CHIP_PIN_BASE = 100000;
|
||
|
||
const synthChipPinMap = new Map<string, number>();
|
||
let nextSyntheticChipPin = SYNTHETIC_CHIP_PIN_BASE;
|
||
|
||
/** Stable synthetic pin number for a custom-chip pin. Allocate-on-first-use. */
|
||
export function syntheticChipPin(chipId: string, pinName: string): number {
|
||
const key = `${chipId} ${pinName}`;
|
||
let n = synthChipPinMap.get(key);
|
||
if (n === undefined) {
|
||
n = nextSyntheticChipPin++;
|
||
synthChipPinMap.set(key, n);
|
||
}
|
||
return n;
|
||
}
|
||
|
||
/**
|
||
* Stable synthetic pin number for a whole chip-to-chip NET (multi-chip bus),
|
||
* keyed by the net's canonical id rather than by a single (chipId, pinName).
|
||
*
|
||
* Phase 0 of the multi-chip digital bus track (project/multichip-bus/): two or
|
||
* more chips on one wire must share ONE PinManager key. `syntheticChipPin`
|
||
* mints a per-endpoint key, which is correct for the single-chip-to-component
|
||
* case but gives each chip on a bus a different number (root cause A).
|
||
* `syntheticNetPin` mints ONE number per net so every endpoint resolves to the
|
||
* same key. It shares the same allocator + numbering space as
|
||
* `syntheticChipPin` (disjoint string keys via the `net:` prefix), so
|
||
* `isSyntheticChipPin` and the SPICE drive / boardless-input bridge keep
|
||
* treating both kinds uniformly.
|
||
*/
|
||
const netPins = new Set<number>();
|
||
|
||
export function syntheticNetPin(netId: string): number {
|
||
const key = `net:${netId}`;
|
||
let n = synthChipPinMap.get(key);
|
||
if (n === undefined) {
|
||
n = nextSyntheticChipPin++;
|
||
synthChipPinMap.set(key, n);
|
||
netPins.add(n);
|
||
}
|
||
return n;
|
||
}
|
||
|
||
/**
|
||
* True if `pin` is a multi-chip BUS net key (minted by syntheticNetPin), vs a
|
||
* single-chip synthetic pin or a real board pin. The chip-bus driver-strength
|
||
* resolution (busNets) only manages these — single-chip-to-component synthetic
|
||
* pins keep the legacy last-writer-wins path.
|
||
*/
|
||
export function isSyntheticNetPin(pin: number): boolean {
|
||
return netPins.has(pin);
|
||
}
|
||
|
||
/** True if `pin` is a minted synthetic chip-pin number (vs a real board pin). */
|
||
export function isSyntheticChipPin(pin: number): boolean {
|
||
return pin >= SYNTHETIC_CHIP_PIN_BASE && pin < nextSyntheticChipPin;
|
||
}
|