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,.dccom varreduras aninhadas,.tf,.noisee.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,.pze.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 opartIndexusado porprobes()epoke(). - A ordem de
nets[j]define onetIndexusado pornetLevels()enetVoltages(). - 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 emcreate. - 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égeneratorcom dente de serra e uma impedância de saída real: 50 ohms, estampada como o par de Norton (uma fonte de corrente dev(t)/50com 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.generatorcontinua ideal e ainda é o componente certo para excitar um nó e esquecer que ele existe.scopesã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 entreVeCOMnas faixas de volts, um shunt de 1 ohm entreAeCOMnas 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,NaNacima 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 seuAnalogPartpediu isso comreporting(). 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_neteisland_nodesexistem para os testes que garantem que o caminho rápido cumpra sua promessa. Uma netlist digital não constrói nenhuma ilha, ecrates/sim-kernel/tests/kernel.rsverifica 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.
propreconstró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 econtinuedé 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: trueexecuta 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ãocontinuedé verdadeiro ediscreteé 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.