Referência

O que o Mokxi simula: o contrato do simulador

O kernel digital, as ilhas analógicas e o executor de deck SPICE, e o que cada um não modela.

O Mokxi simula um circuito com três motores, e esta página é o contrato que cada um deles cumpre.

  • O kernel digital. Um kernel orientado a eventos roda cada microcontrolador, chip lógico e nó digital. A tensão de um nó vem dos drivers nele conectados, cada um uma tensão atrás de uma impedância de fonte, e seu nível lógico vem do mais forte (seção 6). É isso que permite que algumas centenas de componentes e um núcleo de CPU rodem em tempo real numa aba do navegador.
  • Ilhas analógicas. Um capacitor, um indutor, um amp op, um gerador de sinal, um diodo ou um transistor puxa os nós que ele toca para uma ilha, e a ilha é resolvida como uma matriz única por análise nodal modificada, com modelos de dispositivo atrás dos semicondutores: diodos de Shockley, transistores de Gummel-Poon e MOSFETs de nível 1, cada um com capacitância de junção, resolvidos por Newton-Raphson (seções 6a e 6b). No canvas você pode ler o ponto de operação DC, fazer uma varredura de um valor e plotar uma resposta em frequência (seção 7).
  • O executor de decks SPICE. Rodar um deck SPICE, no menu do editor, roda uma netlist SPICE em seu próprio motor: .op, .tran, .ac, .dc com varreduras aninhadas, .tf, .noise e .meas, com subcircuitos, parâmetros, .include, BJTs Gummel-Poon, MOSFETs dos níveis 1 a 3, JFETs, fontes comportamentais e .temp. Ele é verificado contra o ngspice em 42 circuitos de referência, cada um dentro de uma tolerância declarada (seção 7e).

O que cada um não faz, sem rodeios:

  • O canvas ao vivo não tem análise de ruído, temperatura ou distorção, nem função de transferência; toda junção nele está a 27 C. Seu amp op é um macromodelo de um polo com produto ganho-largura de banda, slew rate, headroom, um offset e um limite de corrente, mas sem um segundo polo.
  • O executor de deck SPICE não roda modelos MOSFET BSIM, linhas de transmissão com perdas, dispositivos XSPICE, nem as análises .four, .sens, .pz e .disto, e avisa, linha por linha, quando um deck usa uma delas. Não há análise de Monte Carlo nem biblioteca de modelos de fabricantes.
  • Nada tem uma especificação de potência. Um componente nunca queima, uma fonte nunca cai e um pino não tem limite de corrente, então um circuito que funciona aqui ainda pode falhar na bancada (como os componentes são modelados).

O contrato

O restante desta página é a fronteira entre o simulador em Rust (crates: sim-kernel, parts, analog, spice, sim-wasm) e a interface em TypeScript (web/). Os dois lados são compilados com base neste arquivo. Altere-o apenas editando este arquivo primeiro.

1. Netlist JSON (UI -> simulador)

A UI é dona do diagrama (posições, fios, protoboards). Antes de iniciar uma simulação, ela achata o diagrama numa netlist: as trilhas da protoboard e os fios são mesclados com union-find em nós. Protoboards nunca chegam ao simulador.

{
  "version": 1,
  "parts": [
    { "id": "led1", "type": "led", "props": { "color": "red" } },
    { "id": "r1",   "type": "resistor", "props": { "value": 220 } },
    { "id": "vcc1", "type": "vcc", "props": { "voltage": 5 } },
    { "id": "gnd1", "type": "gnd" }
  ],
  "nets": [
    ["vcc1:VCC", "r1:1"],
    ["r1:2", "led1:A"],
    ["led1:C", "gnd1:GND"]
  ]
}
  • A ordem de parts[i] define o partIndex usado por probes() e poke().
  • A ordem de nets[j] define o netIndex usado por netLevels() e netVoltages().
  • Uma referência de pino é "<partId>:<pinName>". Os nomes dos pinos vêm do catálogo. Tipo de componente desconhecido, pino desconhecido ou um pino em dois nós é um erro em create.
  • Props não informadas recebem o padrão do catálogo. Props desconhecidas são um erro.
  • Um nó pode conter um único pino. A UI emite um quando um pino fica sozinho numa trilha de protoboard (um nó real, necessário para chaves); o simulador o aceita.

2. Superfície WASM (crates/sim-wasm, wasm-bindgen, --target web)

O Rust usa snake_case; exporte com js_name para que o TypeScript veja exatamente isto:

export class Sim {
  static create(netlistJson: string): Sim;   // throws Error(message) on a bad netlist
  runForNs(ns: number): number;              // advance simulated time by ns (a duration, not an absolute target); 0 = ok, 1 = oscillation (see lastError)
  lastError(): string;
  nowNs(): number;
  probes(): Float32Array;                    // one f32 per part, in parts[] order; meaning is per part type (catalog "probe")
  netLevels(): Uint8Array;                   // one u8 per net: 0 Low, 1 High, 2 Unknown, 3 Floating
  netVoltages(): Float32Array;               // one f32 per net, NaN when floating
  netEdges(): Uint32Array;                   // one u32 per net: changes between low and high since the last call, which resets them
  poke(partIndex: number, code: number): number;  // external stimulus; code meaning is per part type; 0 = ok, 1 = oscillation
  stats(): string;                           // JSON: { events, dispatches, parts, nets, memoryBytes }
  loadProgram(partIndex: number, data: Uint8Array): string;  // program image for a part (catalog "program"); "" = ok, else the reason
  writeHost(partIndex: number, data: Uint8Array): number;    // host -> part bytes (catalog "host"); 0 = ok, 1 = oscillation
  readHost(partIndex: number): Uint8Array;   // part -> host bytes since the last call; empty when the part has no channel
  operatingPoint(): string;                  // JSON, see section 7a; runs no time
  sweep(specJson: string): string;           // JSON in, JSON out, see section 7b; runs no time on the circuit it is called on
  setMaxStepNs(ns: number, fixed: boolean): void;  // section 7c; 0 or less clears it
  acSweep(specJson: string): string;               // section 7d; the small-signal frequency response
  stepLimitNs(): Float64Array;               // [dtMinNs, dtMaxNs], empty when the circuit has no analog island
  takeUnsettled(): string;                   // JSON [{ timeNs, deltaCycles, nets }]: loops cut short since the last call, see below
  free(): void;
}
export function catalog(): string;           // JSON, see section 3
export function version(): string;

Um laço que não se estabiliza não interrompe a execução. Quando um instante de tempo simulado precisa de mais de 1000 ciclos delta (componentes passando um nó de um lado para o outro em tempo zero, geralmente dois componentes com duas pernas cada na mesma linha da protoboard), o motor corta o laço onde ele está: os nós que ainda mudam são resolvidos uma última vez e mantidos assim, o tempo continua, e toda chamada continua retornando 0. O instante é relatado uma vez por laço por execução através de takeUnsettled(), sendo nets índices em nets[]; o editor o transforma em uma linha no monitor serial e em um achado do Doutor de Circuitos (web/src/ui/unsettled-watch.ts). Depois de 16 desses instantes em uma execução, cada seguinte é cortado em 200 ciclos delta, de modo que um laço que dispara em cada borda de um PWM rápido não pode congelar a página. Os códigos 1 = oscillation acima são mantidos para os casos de índice inválido e para um motor construído antes disso.

Compilação: wasm-pack build --target web --release --out-dir ../../web/src/sim/wasm --out-name sim crates/sim-wasm (opções antes do caminho do crate). A saída é enviada ao git para que a interface compile sem Rust.

3. JSON do catálogo (simulador -> interface)

[
  {
    "type": "led",
    "pins": [ { "name": "A", "dir": "inout" }, { "name": "C", "dir": "inout" } ],
    "props": [ { "name": "color", "kind": "string", "default": "red", "options": ["red", "green", "blue", "yellow", "white"] } ],
    "probe": "brightness 0..1",
    "poke": null,
    "program": null,
    "host": null
  }
]

program diz o que loadProgram recebe para este componente ("elf32 riscv32imc" para uma placa), ou null. host diz o que o canal de bytes do hospedeiro transporta ("utf-8 bytes on UART0"), ou null. Um componente com canal host é com quem o monitor serial conversa.

dir é in, out ou inout. kind é number, string ou bool. options é opcional; quando presente, a interface mostra um seletor. Uma propriedade number também carrega o intervalo que aceita, min e max, com "minOpen": true quando o próprio min é recusado e "integer": true para apenas números inteiros (crates/parts/src/ranges.rs, no máximo 1e15 em qualquer sentido); a criação do componente recusa um valor fora do intervalo, e o painel de propriedades o bloqueia na digitação. Um visual de componente da interface (web/src/parts/<type>.ts) deve declarar uma posição de pino para cada pino do catálogo e nada além disso; um teste em web/ verifica isso contra web/src/sim/wasm/catalog.json, que a etapa de compilação do wasm também grava.

4. Tipos de componente congelados para o esqueleto da interface da Fase 1

O lado do kernel entrega estes primeiro para que a interface tenha algo para dirigir. Mais componentes chegam dos agentes de componentes e apenas adicionam entradas.

tipo pinos props ponta de prova poke
led A, C color string (red) brilho 0..1 nenhum
resistor 1, 2 value ohms (1000) corrente em amperes nenhum
pushbutton 1a, 1b, 2a, 2b (1a-1b curto-circuitados, 2a-2b curto-circuitados, pressionar une os pares) bounce string ("typical", um de none/typical/worst), veja 4a 1 pressionado, 0 solto 1 = pressionar, 0 = soltar
vcc VCC voltage (5) tensão nenhum
gnd GND nenhum 0 nenhum
clock OUT hz (1) 1 quando alto, 0 quando baixo nenhum

4a. Conjunto de componentes da Fase 1 (adicionados depois do esqueleto, apenas acrescentados no fim)

Unidades: resistor.value ohms, capacitor.value microfarads. Os chips listam seus pinos na ordem numérica dos pinos do encapsulamento. Uma ponta de prova que carrega mais de um bit empacota uma máscara de bits no f32.

tipo pinos props ponta de prova poke
capacitor 1, 2 value número (10) tensão sobre ele, V(1) - V(2) nenhum
gate A, B, Y function string ("and", um de and/or/nand/nor/xor/xnor) 1 quando Y está alto, 0 quando baixo, 0,5 quando desconhecido nenhum
not A, Y nenhum 1 quando Y está alto, 0 quando baixo, 0,5 quando desconhecido nenhum
bitin Q label string ("A"); value (0, 0 ou 1) 1 quando Q está alto, 0 quando baixo 0 puxa Q para baixo, 1 para alto; conduz através de um pull, então qualquer saída no nó vence
bitout A label string ("Y"); color string ("green", um de green/red/amber/blue) 1 alto, 0 baixo, 0,5 desconhecido ou não conduzido nenhum
bytein D0..D7 label string ("A"); value (0, 0 a 255); width (8, 1 a 8) o valor em D0..D(width-1); pinos acima da largura ficam em alta impedância 0..255 define o valor (mascarado pela largura); 2^32 incrementa em um
byteout D0..D7 label string ("S"); width (8, 1 a 8) o valor, bits não conduzidos como 0; -1 quando um bit conduzido é desconhecido nenhum
bitconst Q value (0, 0 ou 1) o valor que ele conduz nenhum; conduz push-pull, como a saída de uma porta lógica
stepclock CLK hz (2); mode string ("step", um de step/run) o nível (0 ou 1), mais 2 durante execução livre 0 para (modo passo a passo), 1 executa livre, 2 dá um pulso (uma subida, depois uma descida meio período depois) enquanto parado
progrom A0..A7 entrada; C0..C7, K0..K7 saída string program (assembly Kestrel, crates/parts/src/kestrel.rs) o endereço sendo lido; -1 enquanto é desconhecido nenhum; a palavra no endereço controla C (byte alto) e K (byte baixo) após 10 ns
terminal D0..D7, WE, CLK string mode ("text", um de text/numbers) bytes escritos desde a energização nenhum; canal do host: cada byte escrito numa borda de subida do CLK com WE em nível alto
sevenseg E, D, COM1, C, DP, G, F, COM2, A, B string common ("cathode", um de cathode/anode); string color ("red", um de red/green/blue/yellow/white) segmentos acesos como bitmask 0..255: bit 0 A, 1 B, 2 C, 3 D, 4 E, 5 F, 6 G, 7 DP nenhum
slideswitch 1, 2, 3 nenhum 0 = comum no pino 1, 1 = comum no pino 3 0 = conecta 2 ao 1, 1 = conecta 2 ao 3
buzzer 1, 2 nenhum 1 quando tocando, 0 quando em silêncio nenhum
74hc00 1A, 1B, 1Y, 2A, 2B, 2Y, GND, 3Y, 3A, 3B, 4Y, 4A, 4B, VCC nenhum saídas como bitmask, bit 0 = 1Y .. bit 3 = 4Y; 0 sem alimentação nenhum
74hc08 mesmo pinout do 74hc00 nenhum o mesmo nenhum
74hc32 mesmo pinout do 74hc00 nenhum o mesmo nenhum
74hc86 mesmo pinout do 74hc00 nenhum o mesmo nenhum
74hc04 1A, 1Y, 2A, 2Y, 3A, 3Y, GND, 4Y, 4A, 5Y, 5A, 6Y, 6A, VCC nenhum saídas como bitmask, bit 0 = 1Y .. bit 5 = 6Y; 0 sem alimentação nenhum
74hc74 1RD, 1D, 1CP, 1SD, 1Q, 1QN, GND, 2QN, 2Q, 2SD, 2CP, 2D, 2RD, VCC nenhum saídas Q como bitmask, bit 0 = 1Q, bit 1 = 2Q; 0 sem alimentação ou X nenhum
74hc595 Q1, Q2, Q3, Q4, Q5, Q6, Q7, GND, Q7S, MR, SHCP, STCP, OE, DS, Q0, VCC nenhum byte em Q0..Q7, bit 0 = Q0; 0 quando OE está alto ou sem alimentação nenhum
ne555 GND, TRIG, OUT, RESET, CTRL, THR, DIS, VCC nenhum 1 quando OUT está alto, 0 quando baixo ou sem alimentação nenhum
tlc555 GND, TRIG, OUT, RESET, CTRL, THR, DIS, VCC nenhum 1 quando OUT está alto, 0 quando baixo ou sem alimentação nenhum
ne556 1DIS, 1THR, 1CTRL, 1RESET, 1OUT, 1TRIG, GND, 2TRIG, 2OUT, 2RESET, 2CTRL, 2THR, 2DIS, VCC nenhum bit 0 = 1OUT, bit 1 = 2OUT alto nenhum
inductor 1, 2 value milihenries (100) corrente em amperes, positiva do pino 1 para o pino 2 nenhum
opamp IN+, IN-, OUT, V+, GND gain (100000) tensão de saída acima do pino GND nenhum
lm358 1OUT, 1IN-, 1IN+, GND, 2IN+, 2IN-, 2OUT, VCC offset millivolts (0) bit 0 = 1OUT, bit 1 = 2OUT acima do meio da alimentação nenhum
lm324 1OUT, 1IN-, 1IN+, VCC, 2IN+, 2IN-, 2OUT, 3OUT, 3IN-, 3IN+, GND, 4IN+, 4IN-, 4OUT offset millivolts (0) bit 0 = 1OUT .. bit 3 = 4OUT acima do meio da alimentação nenhum
tl072 1OUT, 1IN-, 1IN+, VCC-, 2IN+, 2IN-, 2OUT, VCC+ offset millivolts (0) bit 0 = 1OUT, bit 1 = 2OUT acima do meio da alimentação nenhum
lm741 NULL1, IN-, IN+, V-, NULL2, OUT, V+, NC offset millivolts (0) 1 enquanto OUT está acima do meio da alimentação nenhum
ne5532 1OUT, 1IN-, 1IN+, VCC-, 2IN+, 2IN-, 2OUT, VCC+ offset millivolts (0) bit 0 = 1OUT, bit 1 = 2OUT acima do meio da alimentação nenhum
lm833 1OUT, 1IN-, 1IN+, VCC-, 2IN+, 2IN-, 2OUT, VCC+ offset millivolts (0) bit 0 = 1OUT, bit 1 = 2OUT acima do meio da alimentação nenhum
opa2134 1OUT, 1IN-, 1IN+, VCC-, 2IN+, 2IN-, 2OUT, VCC+ offset millivolts (0) bit 0 = 1OUT, bit 1 = 2OUT acima do meio da alimentação nenhum
mcp6002 VOUTA, VINA-, VINA+, VSS, VINB+, VINB-, VOUTB, VDD offset millivolts (0) bit 0 = VOUTA, bit 1 = VOUTB acima do meio da alimentação nenhum
mcp6004 VOUTA, VINA-, VINA+, VDD, VINB+, VINB-, VOUTB, VOUTC, VINC-, VINC+, VSS, VIND+, VIND-, VOUTD offset millivolts (0) bit 0 = VOUTA .. bit 3 = VOUTD acima do meio da alimentação nenhum
lmv358 1OUT, 1IN-, 1IN+, GND, 2IN+, 2IN-, 2OUT, VCC offset millivolts (0) bit 0 = 1OUT, bit 1 = 2OUT acima do meio da alimentação nenhum
tl081 NULL1, IN-, IN+, VCC-, NULL2, OUT, VCC+, NC offset millivolts (0) 1 enquanto OUT está acima do meio da alimentação nenhum
tl084 1OUT, 1IN-, 1IN+, VCC+, 2IN+, 2IN-, 2OUT, 3OUT, 3IN-, 3IN+, VCC-, 4IN+, 4IN-, 4OUT offset millivolts (0) bit 0 = 1OUT .. bit 3 = 4OUT acima do meio da alimentação nenhum
op07 NULL1, IN-, IN+, V-, NC, OUT, V+, NULL2 offset millivolts (0) 1 enquanto OUT está acima do meio da alimentação nenhum
ca3140 NULL1, IN-, IN+, V-, NULL2, OUT, V+, STROBE offset millivolts (0) 1 enquanto OUT está acima do meio da alimentação nenhum
lm393 1OUT, 1IN-, 1IN+, GND, 2IN+, 2IN-, 2OUT, VCC offset millivolts (0) bit 0 = 1OUT, bit 1 = 2OUT liberado (IN+ acima de IN-) nenhum
lm339 1OUT, 2OUT, VCC, 2IN-, 2IN+, 1IN-, 1IN+, 3IN-, 3IN+, 4IN-, 4IN+, GND, 4OUT, 3OUT offset millivolts (0) bit 0 = 1OUT .. bit 3 = 4OUT liberado nenhum
lm311 EMIT, IN+, IN-, VCC-, BAL, STRB, COL, VCC+ offset millivolts (0) 1 enquanto COL estiver liberado (ou sob strobe) nenhum
uln2003a 1B, 2B, 3B, 4B, 5B, 6B, 7B, E, COM, 7C, 6C, 5C, 4C, 3C, 2C, 1C nenhum bits 0..6 = entradas 1B..7B com pelo menos 1,4 V acima de E nenhum
uln2803a 1B, 2B, 3B, 4B, 5B, 6B, 7B, 8B, GND, COM, 8C, 7C, 6C, 5C, 4C, 3C, 2C, 1C nenhum bits 0..7 = entradas 1B..8B com pelo menos 1,4 V acima de GND nenhum
uln2003board IN1, IN2, IN3, IN4, VCC, GND, OUT1, OUT2, OUT3, OUT4 nenhum bits 0..3 = LEDs A..D: OUT1..OUT4 com 1,7 V ou mais abaixo de VCC nenhum
generator OUT, GND string wave ("sine", uma de sine/square/triangle); frequency Hz (1000); amplitude volts de pico (2,5); offset volts (2,5); duty por cento (50, somente square) tensão de saída acima do pino GND nenhum
funcgen OUT, GND string wave ("sine", uma de sine/square/triangle/sawtooth); frequency Hz (1000); amplitude volts de pico (2,5); offset volts (2,5); duty por cento (50, somente square) tensão de saída acima do pino GND, nos terminais nenhum
scope CH1, CH2, GND window segundos (0,02, de 0,0001 a 10); volts de fundo de escala (5) volts do canal 1 acima da garra de terra (1 << 32) | janela em microssegundos, ou (2 << 32) | fundo de escala em milivolts
multimeter V, A, COM string mode ("dcv", uma de dcv/acv/dca/aca/ohms/continuity) a leitura: volts, amperes ou ohms conforme o modo, NaN quando fora de faixa ou aberto nenhum
lm35 VS, VOUT, GND número temperature (22,5) temperatura em graus Celsius décimos de grau mais 1000
aht20 VCC, GND, SCL, SDA (I2C em 0x38) número temperature (22); número humidity (45) temperatura em graus Celsius (1 << 32) | (décimos + 1000) temperatura, (2 << 32) | décimos umidade
bh1750 VCC, GND, SCL, SDA, ADDR (I2C em 0x23, 0x5C com ADDR em nível alto) nenhum a luz em lux a luz em lux, de 0 a 100000
a3144 VCC, GND, OUT (coletor aberto) número operate (210 gauss); número hysteresis (55) código do ímã, mais 100000 enquanto OUT estiver ligado décimos de mm, de 0 a 400, mais 10000 para o polo norte
ss49e VCC, GND, OUT nenhum o campo no sensor em gauss, sul positivo décimos de mm, de 0 a 400 (400 é sem ímã), mais 10000 para o polo norte
photointerrupter SIG, VCC, GND (mais SHAFT com wheel definido) número slots (20), string wheel ("": o id do dcmotor ou encmotor com o qual a roda gira, vazio para o controle deslizante) código da roda (RPM, mais 10000 com o cartão encaixado), mais 100000 enquanto SIG estiver em nível alto, mais 1000000 com a roda em um motor RPM de 0 a 600 (ignorado em um motor), mais 10000 com o cartão encaixado
linearray GND, VCC, S1 a S5 número threshold (0,5) o código da linha, mais 1000 x os canais sobre o preto como bits (o bit 0 é S1) 100 + mm do sensor do meio (40 a 160); 1 uma barra preta atravessada; 0 sem linha
fc51 OUT, GND, VCC número threshold (0,5) código de obstáculo (cm, 80 é sem obstáculo, mais 10000 se for preto), mais 100000 enquanto a lâmpada estiver acesa cm de 1 a 80, mais 10000 para um objeto preto
thermalprinter VH, GND, RX, TX, DTR número baud (19200); bool paper (true) o número de linhas impressas o papel: 1 com papel, 0 sem papel
fingerprint VCC, GND, TX, RX número baud (57600); número enrolled (2); número capacity (162); número password (0) o dedo no vidro, mais 100 depois que uma busca o encontrou, 200 depois que não o encontrou o dedo, de 1 a 9, ou 0 para levantá-lo
ds1302 VCC, GND, CLK, DAT, RST start string ("2026-01-01 12:00:00"); halted bool (false) segundos desde a meia-noite, mais 100000 enquanto pausado (1 << 32) ou segundos desde a meia-noite, ou (2 << 32) ou dias desde 2000-01-01
amg8833 VIN, GND, SCL, SDA, INT (I2C em 0x69) address número (105); background número (22); spot número (34); pixel número (27) o pixel mais quente em C (1 << 32) fundo, (2 << 32) ponto, décimos + 1000; (3 << 32) o pixel do ponto, 64 se não houver
mlx90614 VIN, GND, SCL, SDA (SMBus em 0x5A) object número (36.6); ambient número (22) a temperatura do objeto em C (1 << 32) objeto ou (2 << 32) ambiente, mais décimos de grau + 1000
mpr121 VIN, GND, SCL, SDA, IRQ, ADDR (I2C em 0x5A) address número (90) estado do toque: eletrodo 0 no bit 0 os eletrodos em que há um dedo, como uma máscara
gp2y0a21 VO, GND, VCC distance número (30) a distância em centímetros a distância em centímetros, de 1 a 150
mg996r GND, VCC, PWM min_pulse número (544); max_pulse número (2400); range número (180) ângulo da haste em graus, de 0 ao valor de range nenhum
yfs201 VCC, GND, SIG flow número (0) o fluxo em litros por minuto o fluxo em décimos de litro por minuto, de 0 a 300
adxl335 VCC, X, Y, Z, GND tilt_x número (0); tilt_y número (0) a inclinação em X em graus (1 << 32) ou (2 << 32), mais a inclinação em X ou Y + 90
pulsesensor S, VCC, GND bpm número (72); swing número (0.8) frequência cardíaca em batimentos por minuto (0 sem dedo), mais 1000 enquanto o pico principal passa a frequência cardíaca em batimentos por minuto, de 30 a 220, ou 0 se não houver dedo
coinacceptor DC12V, COIN, GND, COUNTER pulse número (50); nc bool (false) pulsos enviados desde a energização, mais 100000 enquanto COIN está ativo uma moeda que vale essa quantidade de pulsos, de 1 a 50
waterpump V+, V- voltage número (6); flow número (120); resistance número (4); inertia número (50); back_emf número (0.85) o fluxo em litros por hora nenhum
fanmodule INA, INB, VCC, GND voltage número (5); inertia número (250) velocidade da hélice em porcentagem do máximo, negativa na reversão nenhum
laser S, VCC, GND resistor número (100) o brilho percebido do feixe, de 0 a 1 nenhum
trafficlight R, Y, G, GND resistor número (220) LEDs acesos como uma máscara de bits: bit 0 vermelho, bit 1 amarelo, bit 2 verde nenhum
sw420 VCC, GND, DO número threshold (0,5) 0 parado, 1 tremendo, 2 batendo, mais 100000 enquanto a lâmpada está acesa (DO baixo) 0 parado, 1 tremendo até o próximo toque, 2 uma batida
mq3 para mq137 (mq3, mq4, mq5, mq6, mq7, mq8, mq9, mq131, mq135, mq137) VCC, GND, DO, AO gas texto (por sensor, do seu gráfico); r0 ohms; rl ohms; threshold número; warmup segundos (20) o gás na unidade do sensor (ppm; centésimos de mg/L no MQ-3; ppb no MQ-131), mais 100000 enquanto a lâmpada DO está acesa, mais 200000 durante o aquecimento o gás nessa unidade, de 0 até o topo do gráfico
ky037 AO, GND, VCC, DO threshold número (0.505); sensitivity dBV/Pa (-42) como ky038 como ky038
ky004, ky017, ky021, ky031 S, VCC, GND resistor texto ("pull-up" ou "pull-down"); settle ms (ky004 3, ky017 0, ky021 0.5); ky021 close mm (15), release (0.8) ky004 1 pressionado; ky017 1 inclinado; ky021 os mm do ímã; ky031 0 parado, 1 tremendo, 2 batendo os mesmos códigos
sw18010p 1, 2 nenhum 0 parado, 1 tremendo, 2 batendo 0 parado, 1 tremendo até o próximo toque, 2 uma batida
ky024, ky025, ky028 AO, GND, VCC, DO threshold número (0.6, 0.5, 0.45); ky025 close mm (15), release (0.8); ky028 beta K (3950) o código do toque, mais 100000 enquanto a lâmpada DO está acesa (DO alto) ky024 décimos de mm, mais 10000 para o norte; ky025 os mm do ímã, de 0 a 60; ky028 décimos de grau mais 1000
ky035 VCC, GND, S nenhum como ss49e como ss49e
temt6000 SIG, GND, VCC sensitivity uA por lux (0.5) a luz em lux lux, de 0 a 2000
rotation GND, S, VCC value ohms (10000); taper texto como potentiometer como potentiometer
steam S, VCC, GND full fração (0.66) a parte molhada do pente, em porcentagem porcentagem, de 0 a 100
e18d80nk VCC, GND, OUT range cm (40, de 3 a 80); pullup flag (false) os cm do alvo (100 é nada), mais 100000 enquanto detecta cm, de 1 a 100
ttp223 SIG, VCC, GND toggle bool (false); activelow bool (false) bit 0 dedo no sensor, bit 1 SIG alto 1 dedo no sensor, 0 fora
battery V+, V- kind texto ("9v", um de 9v/aa2/aa3/aa4/18650/18650x2); charge número (100) volts entre os terminais nenhum
solar +, - nenhum volts no painel watts por metro quadrado, de 0 a 1200 (1000 é sol pleno)
tp4056 IN+, IN-, BAT+, BAT- nenhum corrente de carga em mA, mais 10000 enquanto a lâmpada de espera está acesa nenhum
regulator IN, GND, OUT string model ("7805", um entre 7805/AMS1117-3.3/MCP1700-3.3) OUT acima de GND, em volts nenhum
tb6612 PWMA, AIN2, AIN1, STBY, BIN1, BIN2, PWMB, GND1, VM, VCC, GND2, AO1, AO2, BO2, BO1, GND3 nenhum modos do canal, A nos bits 0-1 e B nos 2-3: 0 desligado, 1 horário, 2 anti-horário, 3 freio nenhum
l9110 BIA, BIB, GND, VCC, AIA, AIB, OA1, OA2, OB1, OB2 nenhum acionamento do motor, A nos bits 0-1 e B nos 2-3: 0 desligado, 1 para frente, 2 para trás, 3 freio nenhum
encmotor M1, M2, VCC, GND, A, B voltage (6), rpm (200), resistance (6), inertia (120) e back_emf (0.85) do motor comum, mais os números ppr (11) e ratio (30) velocidade da roda em rpm, com sinal nenhum
balancebot VCC, GND, SCL, SDA, STBY, AIN1, AIN2, PWMA, BIN1, BIN2, PWMB, LA, LB, RA, RB mass (800 g), com (70 mm), inertia (17 kg cm^2), height (160 mm), wheel (68 mm), wheel_mass (40 g), voltage (7.4), battery (7.4), rpm (280), stall (4 kg cm), rotor (4 g cm^2), ratio (30), ppr (13), friction (20 mN m), damping (0.5 mN m s), imu (120 mm), noise (1), gyro_bias (0), tilt (2), release (1000 ms) inclinação em graus, positiva para frente 1 levanta o robô, 3 solta, (2 << 32) | (empurrão em mN s + 1000000)
clawcabinet XA1, XA2, XB1, XB2, YA1, YA2, YB1, YB2, VCC, GND, W+, W-, CLAW, XHOME, YHOME, BEAM width (200 mm), depth (160 mm), drop (90 mm), start_x (120 mm), start_y (80 mm), prizes (3), reach (20 mm), grip (130 graus), current (1.7 A), max_steps (1000) profundidade da garra abaixo do topo em mm; o estado completo no canal do instrumento 1 recoloca os prêmios
clawcabinetdc X+, X-, Y+, Y-, VCC, GND, W+, W-, CLAW, XHOME, YHOME, BEAM como clawcabinet, com voltage (6) e rpm (200) dos motores com engrenagem no lugar de current e max_steps como clawcabinet 1 recoloca os prêmios
vendingcabinet M1, M2, M3, M4, VCC, GND, DROP stock (3 por espiral), rpm (110) os lanches no compartimento; o estado completo no canal do instrumento 1 reabastece todas as espirais e esvazia o compartimento
pinballcabinet FL, FR, VCC, GND, KICK1, KICK2, TA, TB, TC, B1, B2, DRAIN, LAUNCH flip_speed (1200 graus por segundo) altura da bola na mesa em mm, -1 enquanto ela volta rolando; o estado completo no canal do instrumento 1 coloca a bola no êmbolo; 0x100 + n segura a tecla n (TA, TB, TC, B1, B2, o feixe do dreno, o êmbolo) e 0x200 + n a solta
barriercabinet VCC, GND, TRIG, ECHO, R, Y, G, ARM, V+ angle (0 graus) ângulo do braço; o estado completo no canal do instrumento 1 manda um carrinho pela pista
sortercabinet VCC, GND, SCL, SDA, SERVO candies (12), period (2000 ms) as balas nos recipientes; o estado completo no canal do instrumento 1 reabastece o funil e esvazia os recipientes; 0x1000000 + 0xRRGGBB coloca em seguida uma bala dessa cor
soapcabinet VCC, GND, OUT, M+, M- threshold (0.5), bottle (30 ml), ml_per_turn (0.5), voltage (6), rpm (200) o sabão bombeado desde que o frasco foi enchido, em ml; o estado completo no canal do instrumento uma mão a cm sob a torneira, de 1 a 80 (80 ninguém), mais 10000 para uma luva preta; 1000000 enche o frasco

A wheel de um sensor fotoelétrico montada em um motor é ligada a ele pela netlist (web/src/sim/wheel-mount.ts): os pinos SHAFT dos dois componentes no mesmo nó, e shaft: true no dcmotor ou encmotor, uma flag interna que o catálogo omite (PropInfo::internal) e que dá esse pino ao motor. Ela carrega a velocidade do eixo de saída, sem sinal, a 1 mV por rpm.

Os chips são alimentados quando a tensão entre seus pinos VCC e GND é de pelo menos 2 V (4,5 V para o NE555); sem alimentação, toda saída fica em alta impedância.

Unidades: resistor.value ohms, capacitor.value microfarads, inductor.value millihenries.

Canal de amostragem do osciloscópio

O osciloscópio carrega suas amostras pela mesma estrada que os pixels de um display percorrem: readHost, coletado uma vez por quadro, com um catálogo host nulo porque esse campo significa "um canal de texto com o qual o monitor serial conversa" e estas são amostras.

readHost(scopeIndex) retorna tudo o que foi amostrado desde a última chamada, como uma única mensagem little-endian, ou nada quando nenhuma amostra foi feita:

byte  0      magic, 0x53
byte  1      channels, always 2
u16   2..4   number of samples that follow
f32   4..8   seconds per sample (the window divided by 256)
f32   8..12  seconds at the first sample
u16  12..14  flags: bit 0 = the time base moved, so throw away every earlier
             sample; bit 1 = samples were dropped before this message
u16  14..16  reserved, zero
f32  16..20  full-scale volts the part is set to
then, per sample: f32 channel 1 volts, f32 channel 2 volts

Uma ponta de prova ligada a nada lê NaN. O componente guarda 1024 amostras para um host que parou de coletar e depois descarta as mais antigas, definindo a flag de descarte.

A base de tempo e a escala completa são propriedades e também podem ser alteradas via poke, porque são as duas coisas que uma pessoa muda enquanto observa um traço, e reconstruir a netlist para mudar uma delas reiniciaria a simulação. Um poke de janela faz efeito imediatamente: o componente limpa o que ainda não enviou, define a flag de reinício na próxima mensagem para que a UI descarte a tela que estava desenhando e continua amostrando na nova taxa sem que o circuito perceba.

Os instrumentos da bancada

funcgen, scope e multimeter são os três instrumentos que você solta no canvas e liga, e são componentes comuns: nenhum caminho privilegiado para o motor, nada que o catálogo não descreva.

  • funcgen é generator com dente de serra e uma impedância de saída real: 50 ohms, estampada como o par de Norton (uma fonte de corrente de v(t)/50 com 50 ohms em paralelo) porque um componente não tem nós internos de onde pendurar um resistor em série. Uma carga divide contra ela, que é a primeira coisa que um gerador de bancada ensina. generator continua ideal e ainda é o componente certo para excitar um nó e esquecer que ele existe.
  • scope são duas pontas de prova de 1 Mohm e um clipe de terra; ele se junta a uma ilha, nunca cria uma.
  • multimeter é 10 Mohm entre V e COM nas faixas de volts, um shunt de 1 ohm entre A e COM nas faixas de corrente (ambos passam um Thevenin no caminho digital rápido e são estampados quando uma ilha os alcança) e, em ohms e continuidade, uma corrente de teste de 30 uA com 100 kohm em paralelo, que cria uma ilha. Ele integra ao longo de uma abertura de 250 ms a 4 kHz e publica uma leitura quatro vezes por segundo: a média em uma faixa DC, o RMS verdadeiro da parte AC em uma faixa AC e, em ohms, a resistência que essa corrente de teste implica, NaN acima de 1 Mohm. Acima de cerca de um quilohertz uma leitura AC fica subamostrada e marca baixo.

Ruído de contato no pushbutton

Um botão tátil real fecha, quica e assenta, então o pushbutton treme a cada aperto e a cada soltura. Sua propriedade bounce escolhe o perfil:

bounce transições por aperto ou soltura assenta em
none 1 na hora
typical 3 a 8 1 a 5 ms
worst até 20 10 a 20 ms

O padrão é typical: escolha none quando o botão não é o ponto do circuito e worst para mostrar por que um sketch precisa fazer debounce. Tudo que está ligado ao botão vê o tremor como bordas comuns (uma entrada de 74HC, um trigger de NE555, um GPIO de placa), porque o botão excita seus nós do mesmo jeito que sempre excitou; nada mais muda no contrato.

Cada rajada começa com uma borda imediata (o contato realmente fecha ao ser apertado) e executa o resto como wakeups na roda de temporização, o último deles caindo exatamente no tempo de acomodação. A contagem é ímpar, então uma rajada sempre termina no estado que foi pedido. Um poke chegando no meio de uma rajada (liberado enquanto ainda treme) cancela o restante e começa uma rajada nova. Os comprimentos dos intervalos vêm de um fluxo aleatório por componente, com semente dada pelo índice do componente na netlist, então dois botões no mesmo circuito tremem de forma diferente, apertos sucessivos diferem, e a mesma netlist recebendo os mesmos pokes produz as mesmas bordas até o picossegundo: uma execução é reprodutível.

A aparência de um componente pode declarar interaction: 'hold' (ponteiro pressionado faz poke 1, solto faz poke 0) ou 'toggle' (um clique faz poke 0 quando a ponta de prova está em pelo menos 0,5, senão 1). O canvas nunca menciona um tipo de componente.

Tudo de que a UI precisa para desenhar um componente está em web/. Tudo de que um componente precisa para se comportar está em crates/parts. Eles se encontram apenas em type, nomes de pinos e props.

5. Loop de execução (lado da UI)

Sim.runForNs(ns) avança o tempo simulado em ns e retorna, com nowNs() informando o novo total. A UI o chama a partir de requestAnimationFrame, mirando tempo simulado = tempo real, com um orçamento por quadro (digamos 12 ms); se o simulador ficar para trás, a UI mostra a razão de velocidade alcançada em vez de congelar. O simulador roda em um Web Worker (web/src/sim/client.ts), então a página continua responsiva enquanto ele trabalha.

probes(), netLevels() e netEdges() são lidos uma vez por quadro, juntos, no snapshot do qual a UI pinta. netEdges() existe porque um nível lido uma vez por quadro mostra apenas onde cada nó terminou: um contato com bounce produz vinte bordas em poucos milissegundos, bem dentro de um quadro de 16 ms, e uma aula que pede por elas precisa poder contá-las. Uma borda é uma mudança de nível limpo (de baixo para desconhecido para alto é uma; de baixo para flutuante para baixo é nenhuma), e uma virada que é desfeita dentro do mesmo instante não é contada. Ler as contagens as zera, então o loop de quadros é o único chamador. netVoltages() é lido na mesma passada, mas só quando algo na página está mostrando volts: o visor Show levels (web/src/ui/levels.ts), que fica desligado por padrão. Um snapshot que não pediu por elas carrega um array vazio, então uma voltagem por nó por quadro não custa nada até estar sendo lida.

6. Modelo elétrico

Todo driver em um nó é uma voltagem com uma impedância de fonte (Drive { voltage, impedance, level }). A voltagem de um nó é a média ponderada por impedância de seus drivers (Millman). Uma saída digital forte tem algumas dezenas de ohms, um pull-up tem o valor do resistor, alta impedância é infinito. O level digital de um nó vem do driver de menor impedância; se drivers de impedância igual discordarem, é Unknown; sem drivers, é Floating. Componentes de dois terminais leem o equivalente Thevenin visto em um pino, excluindo sua própria contribuição, e excitam o outro pino de acordo.

Esse é o caminho rápido, e é o que todo nó sem nada analógico ainda faz.

6a. Ilhas analógicas

Um componente cujo comportamento é uma equação diferencial sobre vários nós ao mesmo tempo (um capacitor, um indutor, um ampop, um gerador de sinal) se declara analógico pela capacidade Component::analog, e o kernel reúne todos os nós que ele toca em uma ilha resolvida como uma matriz por crates/analog: análise nodal modificada, uma LU com pivotamento parcial, um ponto de operação DC na energização com todo capacitor descarregado e todo indutor com corrente zero, e um transiente com modelos companheiros trapezoidais e um passo escolhido pelo erro de truncamento local.

As duas metades se encontram em três lugares e em nenhum outro.

  • Entrando. Todo driver em um nó de ilha que não pertence à ilha é colapsado por Millman em uma tensão atrás de uma resistência e estampado como uma fonte de Thevenin naquele nó. Um pino digital é uma fonte de Thevenin; essa é toda a interface.
  • Saindo. A ilha ocupa um único slot de driver em cada um de seus nós, como qualquer outro pino, e escreve o próprio equivalente de Thevenin da ilha naquele nó (a ilha com o driver de fronteira daquele nó removido), de modo que resolver os dois pela regra comum de Millman reproduz exatamente a tensão de nó resolvida.
  • Tempo. A ilha agenda seu próprio próximo passo na roda de temporização. Uma ilha assentada sem fonte em movimento não agenda nada, então um circuito analógico ocioso custa o mesmo que um digital ocioso.

Um componente com um limiar de entrada analógico (um comparador, os dois pontos de disparo de um 555) chama Ctx::watch(pin, volts, hysteresis); a ilha então refina seu passo sobre o cruzamento em vez de atravessá-lo, de modo que o instante do disparo fica correto a um microssegundo, e não ao tamanho de um passo de integração. Fora de uma ilha, a chamada não custa nada e não muda nada. Uma entrada digital de microcontrolador faz o mesmo através de Ctx::read_input(pin, threshold), que observa o pino no próprio nível de comutação do chip e então o lê: toda placa lê seus pads de entrada assim, então uma borda analógica lenta chega a um componente de 3,3 V e a um de 5 V na tensão em que cada um realmente comutaria, e não no único LOGIC_THRESHOLD do kernel. Um pino de entrada não apresenta carga à ilha além do pull-up ou pull-down que seu firmware habilita; o vazamento de menos de um microampere de uma entrada CMOS real não é modelado.

As ilhas dão passos de no máximo cada 2 ms e de no mínimo cada 100 ns, e seguram o passo a um sessenta e quatro avos de qualquer constante de tempo que esteja se movendo mais rápido, então um traço amostrado entre passos nunca fica mais atrás do que isso. Um resistor entra numa ilha que o alcança, mas nunca cria uma; uma ponta de prova de osciloscópio é 1 Mohm até seu clipe de terra e faz o mesmo.

6b. Ilhas não lineares

Um componente com física de dispositivo nele (um diodo, um LED, um transistor bipolar, um MOSFET) declara AnalogPart::devices junto com seus elementos e os nomeia a partir de um Element::Device { nodes: [Node; 4], dev: u32 }, cujo dev indexa a própria lista de dispositivos daquele componente. Element continua Copy; os dispositivos são Box<dyn Device> na ilha. O kernel desloca os índices de dispositivo de cada componente ao fundir os componentes numa ilha e não sabe mais nada sobre eles: nenhum nome de dispositivo chega ao sim-kernel, e a física vive inteiramente em crates/parts atrás de um trait definido em crates/analog.

Um Device faz três coisas. Ele carrega um modelo companheiro (condutâncias e fontes de corrente equivalentes) a partir das tensões de terminal na iteração atual. Ele limita as tensões que a última solução produziu antes do próximo carregamento, o que para uma junção pn é o pnjlim do SPICE e é a diferença entre um diodo que converge e um que transborda exp. E ele informa seus parâmetros como um simples vetor de números, de modo que Ctx::restamp_device(which, params) pode mover um beta sem reconstruir a ilha, exatamente como Ctx::restamp move uma resistência.

A solução é Newton-Raphson: carregar cada dispositivo, fatorar, resolver, testar cada incógnita contra reltol |x| + abstol (volts numa linha de nó, amperes numa linha de ramo), limitar, repetir, até um teto de Limits::max_iter. Uma ilha sem dispositivos faz exatamente uma passada e produz a matriz que sempre produziu, que os testes do livro didático afirmam dígito por dígito. Um ponto de operação que Newton não alcança a partir de um início frio recorre ao gmin stepping (um vazamento na escala de miliohm em cada nó, reduzido de volta até GMIN), depois ao source stepping, e então relata falha em vez de fingir. Um passo transitório que não converge é cortado pela metade e tenta de novo no mesmo orçamento que o controlador de erro usa; no piso, a iteração permanece e a falha é contada em Solver::stats(), que também carrega iterações, iterações limitadas e passos rejeitados, para que os testes possam afirmar sobre eles e não sobre o tempo de parede.

Os dispositivos da fase 1: um diodo (Shockley com Is, N e um Rs de corpo), um LED (a mesma junção com a queda da cor em 20 mA atrás dela), um transistor bipolar (Ebers-Moll na forma de transporte com Bf, Br, Is e uma tensão de Early, NPN e PNP; desde outubro de 2026 o componente transistor é o modelo Gummel-Poon completo na própria ficha de cada fabricante) e um MOSFET (nível 1 Shichman-Hodges com Vto, beta e lambda, canal N e P). Um componente usa o mesmo dispositivo fora de uma ilha e dentro de uma: um componente de dois terminais resolve o único laço através de si mesmo contra a mesma equação, e um componente de três terminais constrói uma ilha privada de três nós com seu próprio dispositivo nela e consulta o mesmo resolvedor. Há um modelo por dispositivo e nunca dois.

Esses foram os dispositivos da fase 1. Desde então as análises chegaram (o ponto de operação, as varreduras DC e de parâmetros e a resposta em frequência AC, seção 7), toda ficha de dispositivo carrega sua capacitância de junção, e o amplificador operacional é um macromodelo de um polo. No canvas, a temperatura continua fixa em 27 C; um deck SPICE (seção 7e) tem .temp.

O que a implementação faz que as três regras acima não dizem

  • As ilhas são encontradas uma vez, em Kernel::init. O kernel congela sua topologia ali, então uma mudança de fio é uma nova netlist e um novo kernel, que é o que a interface já faz a cada edição. Não há redescoberta incremental e não precisa haver.
  • Um componente é informado se entrou. Component::analog_joined(bool) é chamado uma vez após a descoberta. Um componente que foi estampado não deve também acionar seus pinos, e é aqui que um capacitor para de rodar seu próprio integrador, um resistor para de passar um Thevenin adiante e um potenciômetro para de acionar seu cursor.
  • Um componente pode pedir os valores resolvidos. Component::analog_solved(currents, volts) é chamado após cada solução, para os elementos que aquele componente declarou, quando seu AnalogPart pediu isso com reporting(). A corrente de um indutor é um estado da matriz e não uma função das tensões de nó, então é a única coisa que um componente não consegue ler de volta de seus próprios nós.
  • Valores podem mudar sem reconstrução. Ctx::restamp(&[Element]) entrega ao kernel as estampas do componente como estão agora; o kernel tira os valores delas, deixa os nós em paz e resolve novamente naquele instante segurando cada tensão de capacitor e cada corrente de indutor. O botão de um potenciômetro é para isso. A forma de uma ilha nunca muda; apenas os números dentro dela mudam.
  • Um pino no ar é um nó próprio. Um pino analógico ligado a nada recebe um nó novo com nada além de gmin nele, então um capacitor com uma perna pendurada segura sua carga e não energiza nada.
  • Uma ilha estaciona num horizonte de um segundo. Ela para de agendar passos quando nada que ela contém se moveria mais do que uma tolerância no próximo segundo de tempo simulado. Perguntar se algo vai acontecer no próximo passo é a pergunta errada: a cauda de uma exponencial se move menos que uma tolerância por passo bem antes de ter chegado.
  • O kernel pode informar o quanto está resolvendo. Kernel::island_count, island_of_net e island_nodes existem para os testes que garantem que o caminho rápido cumpra sua promessa. Uma netlist digital não constrói nenhuma ilha, e crates/sim-kernel/tests/kernel.rs verifica isso no circuito de prova de 497 componentes, junto com a contagem de dispatch que esse circuito sempre custou.

Ambos os potenciômetros entram numa ilha do mesmo jeito que um resistor: uma trilha são dois resistores, R x f da extremidade baixa até o cursor e R x (1 - f) do cursor até a extremidade alta, e fora de uma ilha esses dois são combinados numa fonte de Thevenin por pino.

7. Análises

Chamadas que não avançam o tempo simulado. Todo o resto na superfície passa por runForNs; estas executam uma análise e devolvem uma resposta, que é um formato diferente para o contrato, e é por isso que esta seção existe.

7a. operatingPoint(): string

{
  "tNs": 0,
  "levels": [1, 0, 0],
  "volts": [5.0, 2.5, 0.0],
  "analogNets": [false, true, false],
  "probes": [5.0, 0.00025, 0.00025, 0.0],
  "parts": [
    { "index": 1, "id": "r1", "type": "resistor",
      "elements": [ { "kind": "resistor", "amps": 0.00025, "volts": 2.5 } ] }
  ],
  "error": ""
}

levels, volts e analogNets têm uma entrada por nó na ordem de nets[]; probes tem uma por componente na ordem de parts[]. Uma tensão que não é um número (um nó flutuante) volta como null, nunca como um número.

Ele informa a solução que o motor mantém agora e nunca resolve de novo. Com tNs igual a zero, antes de qualquer coisa ter rodado, esse é o ponto de operação de energização: cada capacitor descarregado, cada indutor com corrente zero. Esse é um circuito que acabou de ser ligado e não é o .op do SPICE, onde um capacitor é um circuito aberto. Para a resposta em CC estabilizada, rode o circuito até ele se estabilizar e pegue o ponto de operação nesse momento. tNs está no resultado para que uma leitura possa dizer qual dos dois está sendo mostrado.

analogNets[i] é verdadeiro quando o nó i foi resolvido pela matriz e falso quando foi resolvido pelo modelo por driver. São tipos diferentes de resposta e uma leitura precisa poder dizer isso.

parts contém apenas os componentes estampados numa ilha analógica, com uma entrada por elemento que estamparam, na ordem de estampagem. amps é positivo fluindo do primeiro terminal do elemento para o segundo e volts é a tensão entre esses dois, na mesma ordem. Um componente sem entrada não tem corrente de ramo na matriz; isso não é o mesmo que não ter corrente, e probes costuma ser a resposta aí: a ponta de prova de um resistor é a corrente dele, tenha ele acabado numa matriz ou não (o catálogo em probe diz o que a ponta de prova de cada componente significa).

7b. sweep(specJson: string): string

{ "part": "v1", "prop": "voltage", "from": 0, "to": 5, "step": 0.25 }
{ "part": "p1", "poke": true, "from": 0, "to": 1023, "step": 64 }

settleNs pode ser adicionado a qualquer um; ele roda cada ponto por esse tempo além da energização antes de lê-lo, e qualquer valor acima de zero significa que o ponto deixa de ser uma resposta em CC.

{
  "source": { "part": "v1", "prop": "voltage", "discrete": false, "continued": false },
  "settleNs": 0,
  "parts": [ { "index": 1, "id": "r1", "type": "resistor", "kind": "resistor", "elements": 1 } ],
  "points": [
    { "value": 0, "levels": [0,0,0], "volts": [0,0,0], "currents": [0], "probes": [0,0,0,0], "error": "" }
  ],
  "error": ""
}

currents é paralelo a parts e carrega o primeiro elemento de cada componente analógico. Uma análise que não pôde rodar volta com error definido e points vazio; ela nunca lança exceção.

Dois caminhos, porque há dois tipos de coisa ajustável neste motor.

  • prop reconstrói o circuito a cada ponto a partir da netlist com aquele único número alterado e o energiza, então todo ponto é um ponto de operação em CC de partida fria e continued é falso. Uma propriedade que não é um número é recusada em palavras, e o mesmo vale para uma propriedade que o componente não tem.
  • poke: true executa o código de poke do componente no circuito vivo (o eixo de um potenciômetro), o que reestampa e resolve de novo no lugar, então continued é verdadeiro e discrete é verdadeiro, porque um eixo é uma contagem inteira e não um contínuo. O componente é devolvido ao estado em que a varredura o encontrou.

O máximo de pontos que uma varredura aceita é 1001. Acima disso ela é recusada com a contagem na mensagem em vez de rodar.

7c. setMaxStepNs(ns, fixed) e stepLimitNs()

Limits.dt_max como configuração. ns é o maior passo que qualquer ilha analógica pode dar; fixed fixa também o piso nesse valor, então o controlador de erro tem exatamente um passo a escolher. Zero ou menos limpa isso e devolve cada ilha ao teto próprio de 2 ms do kernel.

Duas coisas ainda encurtam um passo forçado e ambas são deliberadas: uma descontinuidade de fonte é pousada em cima em vez de integrada através, e um limiar lógico observado dentro de um passo é refinado até o cruzamento. Nada nunca alonga um passo, então um passo forçado é uma promessa de "pelo menos essa resolução".

Um componente pode pedir a mesma coisa para a própria ilha com Ctx::limit_step(dt, fixed), e o pedido mais fino numa ilha vence. A propriedade step do componente scope é essa chamada: zero, o padrão, deixa o controlador em paz.

7d. acSweep(specJson: string): string

{ "source": "gen1", "probe": 4, "fStart": 10, "fStop": 100000, "pointsPerDecade": 20 }

input pode ser adicionado: o índice do nó contra o qual o ganho é tomado. Se for deixado de fora, é o nó que o próprio elemento da fonte alimenta, que é o que uma pessoa quer dizer com "a entrada" quando escolheu um gerador.

{
  "source": { "part": "gen1", "type": "generator", "net": 0, "drive": "vsource" },
  "input": 0,
  "probe": 1,
  "tNs": 0,
  "freq": [10, 11.22, 12.59],
  "magDb": [-0.0004, -0.0005, -0.0006],
  "phaseDeg": [-0.576, -0.646, -0.725],
  "inputMag": [1, 1, 1],
  "outputMag": [0.99995, 0.99994, 0.99992],
  "error": ""
}

Os cinco vetores são paralelos e têm uma entrada por frequência. magDb e phaseDeg são a razão entre o fasor de saída e o fasor de entrada (20 log10 |Vout / Vin| e arg(Vout / Vin) em graus), que é a única coisa aqui que é uma função de transferência. inputMag e outputMag são as magnitudes brutas dos fasores na unidade que o estímulo tiver, e source.drive diz qual: vsource é um volt através da fonte, isource um ampere nela, thevenin um volt em circuito aberto atrás da sua resistência. Um gerador de funções é um par de Norton, então seu drive é isource e seu inputMag é uma impedância em ohms em vez de um volt; a razão não é afetada, e é justamente esse o objetivo de informar a razão.

freq é fStart * 10^(k / pointsPerDecade) até e incluindo fStop, que é a mesma grade que .ac dec percorre, então uma varredura aqui e uma varredura num simulador de referência com os mesmos três números se comparam ponto a ponto. fStart precisa ser maior que zero: zero hertz é CC, que é o ponto de operação e não um ponto de uma varredura logarítmica. O máximo de pontos que uma varredura aceita é 1001, o mesmo limite de sweep.

Ela é tomada em torno do ponto de operação que o motor mantém agora, exatamente como operatingPoint o informa, e não resolve nada de novo. Com tNs igual a zero esse é o bias de energização; depois que o tempo rodou, é o estado naquele instante, e tNs diz qual. Cada dispositivo não linear é linearizado na iteração em que Newton o deixou, e cada amplificador operacional no modo em que o ponto de operação o colocou: um amplificador que saturou é estampado saturado, então seu ganho de pequeno sinal é zero.

Desde a fase 1 do Analog 3, cada cartão de dispositivo carrega sua capacitância de junção, e o carimbo de AC é j w C no mesmo dQ/dv que o transiente integra, então um transistor tem um canto de alta frequência próprio e um estágio emissor comum mostra o efeito Miller. O que o modelo não tem está em crates/analog/src/ac.rs e repetido em docs/help/editor/analysis.md: um BJT não tem tempo de trânsito reverso TR, a capacitância gate-dreno de um MOSFET é constante e por isso não tem platô de Miller, o Darlington TIP120 não tem capacitância nenhuma; não há análise de ruído nem análise de distorção, porque um circuito linearizado não tem nenhum dos dois; e o ampop ainda é o linear limitado pelos trilhos, com ganho plano até frequência infinita.

Uma análise que não pôde rodar volta com error definido e os arrays vazios; ela nunca lança exceção. As três coisas que dão errado dizem qual são: o componente nomeado não tem uma fonte que uma análise de AC possa excitar, um nó não está na mesma ilha analógica que a fonte, ou o intervalo não é um intervalo.

7e. spiceRun(deck: string, filesJson: string): string

Uma função livre do módulo, não um método de Sim: ela roda um deck SPICE em crates/spice e não tem nada a ver com nenhum circuito carregado. filesJson é [{ "name": "models.lib", "text": "..." }], os arquivos que o deck pode incluir com .include ou .lib (casados pelo nome exato, depois só pelo nome do arquivo), ou uma string vazia. A resposta:

{ "ok": true, "title": "RC step",
  "diagnostics": [{ "severity": "warning", "line": 4, "col": 1, "message": "..." }],
  "results": [{ "kind": "tran", "notes": ["412 accepted steps"], "error": null,
                "vectors": [{ "name": "time", "unit": "s", "data": [0, 1e-5] }] }],
  "deck": "the flat deck, written back out" }

ok false means the deck did not read; diagnostics then lists every error with its line and column and results is empty. kind is op, tran, ac, dc, tf, noise or meas, one result per analysis card per .step point per .temp, in that nesting, then the .meas values. AC vectors come as pairs, re(v(out)) and im(v(out)), beside frequency; a DC sweep has sweep (and sweep2 for the outer of a nested one). A number that is not finite is null. The editor calls it through the simulation worker (SimClient.spiceRun) and draws it with src/ui/spice-panel.ts.

Perguntas

Isto é SPICE?

Para netlists, sim: Rodar um deck SPICE, no menu do editor, roda .op, .tran, .ac, .dc, .tf, .noise e .meas num motor SPICE verificado contra o ngspice em 42 circuitos de referência, sem modelos BSIM de MOSFET, XSPICE ou análise de distorção. No canvas, os cantos analógicos de um circuito são resolvidos como uma matriz por análise nodal, do mesmo jeito que o SPICE faz, e todo o resto roda no caminho digital orientado a eventos, que é o que permite que algumas centenas de componentes rodem em tempo real num notebook.

O que ele não me diz?

No canvas ao vivo: ruído, temperatura, distorção ou função de transferência, e nenhum componente tem potência máxima, então nada queima. O canvas dá o ponto de operação DC, varreduras e uma resposta em frequência, e um deck SPICE acrescenta ruído, .tf e .temp. Um deck não roda modelos BSIM de MOSFET, dispositivos XSPICE, Monte Carlo nem análise de distorção.

Quão rápido ele é de verdade?

O kernel mantém algumas centenas de componentes em tempo real, e os núcleos de CPU rodam aproximadamente na velocidade dos chips reais num notebook comum.