424 lines
15 KiB
TypeScript
424 lines
15 KiB
TypeScript
import { describe, it, expect } from 'vitest';
|
|
import { buildNetlist } from '../simulation/spice/NetlistBuilder';
|
|
import { runNetlist } from './helpers/testSolver';
|
|
import { UnionFind } from '../simulation/spice/unionFind';
|
|
import { BOARD_PIN_GROUPS } from '../simulation/spice/boardPinGroups';
|
|
import { parseValueWithUnits } from '../simulation/spice/valueParser';
|
|
import type { BoardForSpice } from '../simulation/spice/types';
|
|
|
|
describe('UnionFind', () => {
|
|
it('unions transitively', () => {
|
|
const uf = new UnionFind();
|
|
uf.union('a', 'b');
|
|
uf.union('b', 'c');
|
|
expect(uf.find('a')).toBe(uf.find('c'));
|
|
});
|
|
it('canonical name propagates on union', () => {
|
|
const uf = new UnionFind();
|
|
uf.union('gnd_pin_x', 'r1_pin2');
|
|
uf.setCanonical('gnd_pin_x', '0');
|
|
expect(uf.find('r1_pin2')).toBe('0');
|
|
});
|
|
it('ground wins over vcc when both canonicals collide', () => {
|
|
const uf = new UnionFind();
|
|
uf.setCanonical('node_a', 'vcc_rail');
|
|
uf.setCanonical('node_b', '0');
|
|
uf.union('node_a', 'node_b');
|
|
expect(uf.find('node_a')).toBe('0');
|
|
});
|
|
});
|
|
|
|
describe('parseValueWithUnits', () => {
|
|
it('parses SPICE SI suffixes', () => {
|
|
expect(parseValueWithUnits('4.7k')).toBe(4700);
|
|
expect(parseValueWithUnits('220')).toBe(220);
|
|
expect(parseValueWithUnits('1Meg')).toBe(1_000_000);
|
|
expect(parseValueWithUnits('10u')).toBeCloseTo(1e-5);
|
|
expect(parseValueWithUnits('100n')).toBeCloseTo(1e-7);
|
|
expect(parseValueWithUnits('22p')).toBeCloseTo(2.2e-11);
|
|
expect(parseValueWithUnits('10mH')).toBeCloseTo(0.01);
|
|
expect(parseValueWithUnits('1.5H')).toBe(1.5);
|
|
expect(parseValueWithUnits('0.1u')).toBeCloseTo(1e-7);
|
|
});
|
|
it('passes numbers through', () => {
|
|
expect(parseValueWithUnits(1000)).toBe(1000);
|
|
});
|
|
it('returns fallback for garbage', () => {
|
|
expect(parseValueWithUnits('banana', 42)).toBe(42);
|
|
expect(parseValueWithUnits(undefined, 99)).toBe(99);
|
|
});
|
|
});
|
|
|
|
describe('NetlistBuilder — simple cases', () => {
|
|
it('emits a voltage divider and ngspice gets 6V', { timeout: 30_000 }, async () => {
|
|
const { netlist } = buildNetlist({
|
|
components: [
|
|
{ id: 'r1', metadataId: 'resistor', properties: { value: '1k' } },
|
|
{ id: 'r2', metadataId: 'resistor', properties: { value: '2k' } },
|
|
],
|
|
wires: [
|
|
{
|
|
id: 'w1',
|
|
start: { componentId: 'arduino', pinName: '5V' },
|
|
end: { componentId: 'r1', pinName: '1' },
|
|
},
|
|
{
|
|
id: 'w2',
|
|
start: { componentId: 'r1', pinName: '2' },
|
|
end: { componentId: 'r2', pinName: '1' },
|
|
},
|
|
{
|
|
id: 'w3',
|
|
start: { componentId: 'r2', pinName: '2' },
|
|
end: { componentId: 'arduino', pinName: 'GND' },
|
|
},
|
|
],
|
|
boards: [
|
|
{
|
|
id: 'arduino',
|
|
vcc: 5,
|
|
pins: { '5V': { type: 'digital', v: 5 }, GND: { type: 'digital', v: 0 } },
|
|
groundPinNames: ['GND'],
|
|
vccPinNames: ['5V'],
|
|
},
|
|
],
|
|
analysis: { kind: 'op' },
|
|
});
|
|
// Netlist should include two resistors and a vcc rail source
|
|
expect(netlist).toMatch(/R_r1/);
|
|
expect(netlist).toMatch(/R_r2/);
|
|
expect(netlist).toMatch(/V_VCC_RAIL vcc_rail 0 DC 5/);
|
|
expect(netlist).toMatch(/\.op/);
|
|
expect(netlist).toMatch(/\.end/);
|
|
|
|
// But critically: ngspice should accept it and return 10/3 V at midpoint
|
|
// (5V · 2k / 3k = 3.333V)
|
|
const result = await runNetlist(netlist);
|
|
// Find the middle net name — it's auto-generated as "n0" or similar
|
|
const midV = result.vec('v(n0)') as number[];
|
|
expect(midV[0]).toBeCloseTo((5 * 2) / 3, 2);
|
|
});
|
|
|
|
it(
|
|
'emits an LED + resistor from 5V rail and ngspice solves non-linear',
|
|
{ timeout: 30_000 },
|
|
async () => {
|
|
const { netlist } = buildNetlist({
|
|
components: [
|
|
{ id: 'r1', metadataId: 'resistor', properties: { value: '220' } },
|
|
{ id: 'led1', metadataId: 'led', properties: { color: 'red' } },
|
|
],
|
|
wires: [
|
|
{
|
|
id: 'w1',
|
|
start: { componentId: 'board', pinName: 'VCC' },
|
|
end: { componentId: 'r1', pinName: '1' },
|
|
},
|
|
{
|
|
id: 'w2',
|
|
start: { componentId: 'r1', pinName: '2' },
|
|
end: { componentId: 'led1', pinName: 'A' },
|
|
},
|
|
{
|
|
id: 'w3',
|
|
start: { componentId: 'led1', pinName: 'C' },
|
|
end: { componentId: 'board', pinName: 'GND' },
|
|
},
|
|
],
|
|
boards: [
|
|
{
|
|
id: 'board',
|
|
vcc: 5,
|
|
pins: {},
|
|
groundPinNames: ['GND'],
|
|
vccPinNames: ['VCC'],
|
|
},
|
|
],
|
|
analysis: { kind: 'op' },
|
|
});
|
|
expect(netlist).toMatch(/D_led1 \S+ 0 LED_RED/);
|
|
expect(netlist).toMatch(/\.model LED_RED D\(Is=1e-20 N=1\.7\)/);
|
|
|
|
const result = await runNetlist(netlist);
|
|
// Forward voltage on the anode should be ≈ 2.0 V for a red LED
|
|
const anodeNet = netlist.match(/D_led1 (\S+) 0 LED_RED/)?.[1];
|
|
expect(anodeNet).toBeTruthy();
|
|
const Vf = (result.vec(`v(${anodeNet})`) as number[])[0];
|
|
expect(Vf).toBeGreaterThan(1.7);
|
|
expect(Vf).toBeLessThan(2.3);
|
|
},
|
|
);
|
|
|
|
it('NTC divider: T=25°C produces V(a0) ≈ 2.5V', { timeout: 30_000 }, async () => {
|
|
const { netlist } = buildNetlist({
|
|
components: [
|
|
{ id: 'r1', metadataId: 'resistor', properties: { value: '10k' } },
|
|
{ id: 'ntc1', metadataId: 'ntc-temperature-sensor', properties: { temperature: 25 } },
|
|
],
|
|
wires: [
|
|
{
|
|
id: 'w1',
|
|
start: { componentId: 'uno', pinName: '5V' },
|
|
end: { componentId: 'r1', pinName: '1' },
|
|
},
|
|
{
|
|
id: 'w2',
|
|
start: { componentId: 'r1', pinName: '2' },
|
|
end: { componentId: 'ntc1', pinName: '1' },
|
|
},
|
|
{
|
|
id: 'w3',
|
|
start: { componentId: 'ntc1', pinName: '2' },
|
|
end: { componentId: 'uno', pinName: 'GND' },
|
|
},
|
|
],
|
|
boards: [
|
|
{
|
|
id: 'uno',
|
|
vcc: 5,
|
|
pins: {},
|
|
groundPinNames: ['GND'],
|
|
vccPinNames: ['5V'],
|
|
},
|
|
],
|
|
analysis: { kind: 'op' },
|
|
});
|
|
const result = await runNetlist(netlist);
|
|
// Net between R1 and NTC is auto-named; find it.
|
|
const midNet = netlist.match(/R_r1 vcc_rail (\S+) /)?.[1];
|
|
expect(midNet).toBeTruthy();
|
|
const v = (result.vec(`v(${midNet})`) as number[])[0];
|
|
expect(v).toBeCloseTo(2.5, 1);
|
|
});
|
|
|
|
it('adds auto pull-down on floating cap-only node', () => {
|
|
// Two caps share a node (net x) that only touches capacitors → DC-floating.
|
|
const { netlist } = buildNetlist({
|
|
components: [
|
|
{ id: 'c1', metadataId: 'capacitor', properties: { value: '1u' } },
|
|
{ id: 'c2', metadataId: 'capacitor', properties: { value: '1u' } },
|
|
],
|
|
wires: [
|
|
{
|
|
id: 'w_share',
|
|
start: { componentId: 'c1', pinName: '1' },
|
|
end: { componentId: 'c2', pinName: '1' },
|
|
},
|
|
{
|
|
id: 'w1',
|
|
start: { componentId: 'c1', pinName: '2' },
|
|
end: { componentId: 'board', pinName: 'GND' },
|
|
},
|
|
{
|
|
id: 'w2',
|
|
start: { componentId: 'c2', pinName: '2' },
|
|
end: { componentId: 'board', pinName: 'GND' },
|
|
},
|
|
],
|
|
boards: [{ id: 'board', vcc: 5, pins: {}, groundPinNames: ['GND'] }],
|
|
analysis: { kind: 'op' },
|
|
});
|
|
expect(netlist).toMatch(/R_autopull_/);
|
|
});
|
|
|
|
it('PWM pin emits DC-equivalent voltage source', () => {
|
|
const { netlist } = buildNetlist({
|
|
components: [],
|
|
wires: [
|
|
{
|
|
id: 'w1',
|
|
start: { componentId: 'uno', pinName: 'D9' },
|
|
end: { componentId: 'uno', pinName: 'GND' },
|
|
},
|
|
],
|
|
boards: [
|
|
{
|
|
id: 'uno',
|
|
vcc: 5,
|
|
pins: { D9: { type: 'pwm', duty: 0.5 } },
|
|
groundPinNames: ['GND'],
|
|
},
|
|
],
|
|
analysis: { kind: 'op' },
|
|
});
|
|
// D9 is wired directly to GND → same net as ground → no source emitted
|
|
// (this is a degenerate case; just ensure we don't crash)
|
|
expect(netlist).toMatch(/\.end/);
|
|
});
|
|
});
|
|
|
|
describe('NetlistBuilder — aux supply rails (off-voltage supply pins, B16)', () => {
|
|
// Boards built exactly the way storeAdapter builds them, so these tests
|
|
// exercise the real BOARD_PIN_GROUPS tables.
|
|
const boardFromGroup = (id: string, kind: keyof typeof BOARD_PIN_GROUPS): BoardForSpice => {
|
|
const g = BOARD_PIN_GROUPS[kind];
|
|
return {
|
|
id,
|
|
boardKind: kind,
|
|
vcc: g.vcc,
|
|
pins: {},
|
|
groundPinNames: g.gnd,
|
|
vccPinNames: g.vcc_pins,
|
|
auxPinNames: g.aux?.pins,
|
|
auxVolts: g.aux?.volts,
|
|
};
|
|
};
|
|
const wire = (id: string, aId: string, aPin: string, bId: string, bPin: string) => ({
|
|
id,
|
|
start: { componentId: aId, pinName: aPin },
|
|
end: { componentId: bId, pinName: bPin },
|
|
});
|
|
|
|
it(
|
|
'ESP32 VIN solves at 5 V while vcc_rail stays at 3.3 V',
|
|
{ timeout: 30_000 },
|
|
async () => {
|
|
const { netlist, pinNetMap } = buildNetlist({
|
|
components: [
|
|
{ id: 'r1', metadataId: 'resistor', properties: { value: '10k' } },
|
|
{ id: 'r2', metadataId: 'resistor', properties: { value: '10k' } },
|
|
],
|
|
wires: [
|
|
wire('w1', 'esp32', 'VIN', 'r1', '1'),
|
|
wire('w2', 'r1', '2', 'esp32', 'GND'),
|
|
wire('w3', 'esp32', '3V3', 'r2', '1'),
|
|
wire('w4', 'r2', '2', 'esp32', 'GND'),
|
|
],
|
|
boards: [boardFromGroup('esp32', 'esp32')],
|
|
analysis: { kind: 'op' },
|
|
});
|
|
// VIN must land on its own 5 V aux rail, NOT collapse onto vcc_rail
|
|
// (the customer-reported clamp: 5 V pin reading 3.3 V).
|
|
expect(pinNetMap.get('esp32:VIN')).toBe('aux_rail_5');
|
|
expect(pinNetMap.get('esp32:3V3')).toBe('vcc_rail');
|
|
expect(netlist).toMatch(/V_AUX_RAIL_5 aux_rail_5 0 DC 5/);
|
|
expect(netlist).toMatch(/V_VCC_RAIL vcc_rail 0 DC 3\.3/);
|
|
const result = await runNetlist(netlist);
|
|
expect(result.dcValue('v(aux_rail_5)')).toBeCloseTo(5, 2);
|
|
expect(result.dcValue('v(vcc_rail)')).toBeCloseTo(3.3, 2);
|
|
},
|
|
);
|
|
|
|
it(
|
|
'Arduino Uno 3.3V pin solves at 3.3 V while the 5 V rail stays at 5 V',
|
|
{ timeout: 30_000 },
|
|
async () => {
|
|
const { netlist, pinNetMap } = buildNetlist({
|
|
components: [
|
|
{ id: 'r1', metadataId: 'resistor', properties: { value: '10k' } },
|
|
{ id: 'r2', metadataId: 'resistor', properties: { value: '10k' } },
|
|
],
|
|
wires: [
|
|
wire('w1', 'uno', '3.3V', 'r1', '1'),
|
|
wire('w2', 'r1', '2', 'uno', 'GND'),
|
|
wire('w3', 'uno', '5V', 'r2', '1'),
|
|
wire('w4', 'r2', '2', 'uno', 'GND'),
|
|
],
|
|
boards: [boardFromGroup('uno', 'arduino-uno')],
|
|
analysis: { kind: 'op' },
|
|
});
|
|
expect(pinNetMap.get('uno:3.3V')).toBe('aux_rail_3v3');
|
|
expect(pinNetMap.get('uno:5V')).toBe('vcc_rail');
|
|
expect(netlist).toMatch(/V_AUX_RAIL_3V3 aux_rail_3v3 0 DC 3\.3/);
|
|
expect(netlist).toMatch(/V_VCC_RAIL vcc_rail 0 DC 5/);
|
|
const result = await runNetlist(netlist);
|
|
expect(result.dcValue('v(aux_rail_3v3)')).toBeCloseTo(3.3, 2);
|
|
expect(result.dcValue('v(vcc_rail)')).toBeCloseTo(5, 2);
|
|
},
|
|
);
|
|
|
|
it('a module VCC pin wired to VIN stays on the 5 V aux rail', () => {
|
|
// The VCC pin-name heuristic canonicalizes to vcc_rail; the wire to VIN
|
|
// must win (aux rails outrank the heuristic in pickCanonical) or the
|
|
// module would be "powered" at 3.3 V despite being wired to 5 V.
|
|
const { pinNetMap } = buildNetlist({
|
|
components: [
|
|
{ id: 'oled', metadataId: 'ssd1306-i2c-4pin', properties: {} },
|
|
],
|
|
wires: [
|
|
wire('w1', 'oled', 'VCC', 'esp32', 'VIN'),
|
|
wire('w2', 'oled', 'GND', 'esp32', 'GND'),
|
|
],
|
|
boards: [boardFromGroup('esp32', 'esp32')],
|
|
analysis: { kind: 'op' },
|
|
});
|
|
expect(pinNetMap.get('oled:VCC')).toBe('aux_rail_5');
|
|
expect(pinNetMap.get('esp32:VIN')).toBe('aux_rail_5');
|
|
});
|
|
});
|
|
|
|
describe('NetlistBuilder — ESP32 internal pull-up (INPUT_PULLUP)', () => {
|
|
// GPIO4 set INPUT_PULLUP, with a pushbutton from GPIO4 (1.l) to GND (2.l).
|
|
// This is the canonical active-low button. Without the internal pull the
|
|
// input floats to 0 V and reads LOW even at idle; the stamped 45k pull-up
|
|
// to the 3.3 V rail makes idle read HIGH and a press read LOW.
|
|
const build = (pressed: boolean) =>
|
|
buildNetlist({
|
|
components: [{ id: 'btn', metadataId: 'pushbutton', properties: { pressed } }],
|
|
wires: [
|
|
{
|
|
id: 'w1',
|
|
start: { componentId: 'esp32', pinName: '4' },
|
|
end: { componentId: 'btn', pinName: '1.l' },
|
|
},
|
|
{
|
|
id: 'w2',
|
|
start: { componentId: 'btn', pinName: '2.l' },
|
|
end: { componentId: 'esp32', pinName: 'GND2' },
|
|
},
|
|
],
|
|
boards: [
|
|
{
|
|
id: 'esp32',
|
|
vcc: 3.3,
|
|
pins: { '4': { type: 'input', pull: 1 } },
|
|
// NOTE: "GND2" is deliberately NOT listed in groundPinNames — it must
|
|
// canonicalize to node 0 via GROUND_PIN_RE (bare GNDn spelling). This
|
|
// is the exact pin the ESP32 DevKit element labels; before the regex
|
|
// fix it floated and the pulled-up input never read a clean level.
|
|
},
|
|
],
|
|
analysis: { kind: 'op' as const },
|
|
});
|
|
|
|
it('stamps the pull resistor + rail source', () => {
|
|
const { netlist } = build(false);
|
|
expect(netlist).toMatch(/R_pull_esp32_4 \S+ vcc_rail 45000/);
|
|
// The rail source must exist even though no wire references VCC.
|
|
expect(netlist).toMatch(/V_VCC_RAIL vcc_rail 0 DC 3\.3/);
|
|
});
|
|
|
|
it('idles HIGH (~3.3 V) when the button is open', { timeout: 30_000 }, async () => {
|
|
const { netlist, pinNetMap } = build(false);
|
|
const net = pinNetMap.get('esp32:4')!;
|
|
const result = await runNetlist(netlist);
|
|
expect(result.dcValue(`v(${net})`)).toBeCloseTo(3.3, 1);
|
|
});
|
|
|
|
it('reads LOW (~0 V) when the button is pressed', { timeout: 30_000 }, async () => {
|
|
const { netlist, pinNetMap } = build(true);
|
|
const net = pinNetMap.get('esp32:4')!;
|
|
const result = await runNetlist(netlist);
|
|
expect(result.dcValue(`v(${net})`)).toBeCloseTo(0, 1);
|
|
});
|
|
|
|
it('pull-down (INPUT_PULLDOWN) ties the idle level to 0 V', { timeout: 30_000 }, async () => {
|
|
const { netlist, pinNetMap } = buildNetlist({
|
|
components: [{ id: 'r', metadataId: 'resistor', properties: { value: '1Meg' } }],
|
|
wires: [
|
|
{
|
|
id: 'w1',
|
|
start: { componentId: 'esp32', pinName: '5' },
|
|
end: { componentId: 'r', pinName: '1' },
|
|
},
|
|
],
|
|
boards: [{ id: 'esp32', vcc: 3.3, pins: { '5': { type: 'input', pull: 2 } } }],
|
|
analysis: { kind: 'op' as const },
|
|
});
|
|
expect(netlist).toMatch(/R_pull_esp32_5 \S+ 0 45000/);
|
|
const net = pinNetMap.get('esp32:5')!;
|
|
const result = await runNetlist(netlist);
|
|
expect(result.dcValue(`v(${net})`)).toBeCloseTo(0, 1);
|
|
});
|
|
});
|