# io.github.ethan-hub26/embedcalc-mcp (npm · embedcalc-mcp)

Embedded calculators, codegen & schematic review: CRC, timing, struct, IEEE-754, KiCad.

- Trust score: 61/100 (medium)
- Change this week: +19
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- npm · `embedcalc-mcp`: 61/100 (this document), [markdown](https://verifymcp.io/servers/ethan-hub26-embedcalc-mcp/embedcalc-mcp.md), [page](https://verifymcp.io/servers/ethan-hub26-embedcalc-mcp/embedcalc-mcp)

## Channel facts

- Registry: `npm`
- Package: `embedcalc-mcp`
- Version: `0.5.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Supply Chain Security**: 87/100
  - No malware found by supply-chain analysis.
  - Only part of the dependency tree could be resolved (95 of 99), so this covers what we could see, not the whole tree.
  - No install/post-install scripts declared.
  - Only part of the dependency tree could be resolved (95 of 99), so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 16 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 54/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 7690 tokens (~233/item across 33 items; 33 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 99% of tool parameters carry a description.
  - Structured output schemas are declared (88% of tools); any adoption earns full credit.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### Claude

```bash
claude mcp add ethan-hub26-embedcalc-mcp -- npx -y embedcalc-mcp
```

### Codex

```bash
codex mcp add ethan-hub26-embedcalc-mcp -- npx -y embedcalc-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ethan-hub26-embedcalc-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "embedcalc-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ethan-hub26-embedcalc-mcp --command npx --arg -y --arg embedcalc-mcp
```

### Hermes

```yaml
mcp_servers:
  ethan-hub26-embedcalc-mcp:
    command: "npx"
    args: ["-y", "embedcalc-mcp"]
```

### Other

```json
{
  "mcpServers": {
    "ethan-hub26-embedcalc-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "embedcalc-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-02 (score 61, +30)

- [security regression] Provenance: unverified → fail
- [security improvement] Install scripts: unverified → pass
- [security improvement] Known CVEs: unverified → partial
- [security improvement] Malware scan: unverified → pass
- [functional improvement] Maintenance: unverified → pass
- [functional improvement] Dependency health: unverified → partial
- [functional improvement] License: unverified → pass
- [functional] Licence: MIT

### 2026-08-01 (score 31, −13)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 44, −30)

- [security regression] Known CVEs: partial → unverified
- [security regression] Malware scan: pass → unverified
- [functional regression] Dependency health: partial → unverified

### 2026-07-29 (score 74, +32)

- [security regression] Provenance: unverified → fail
- [security improvement] Known CVEs: unverified → partial
- [security improvement] Install scripts: unverified → pass
- [functional improvement] Schema quality: unverified → good
- [functional improvement] Maintenance: unverified → pass
- [functional improvement] Dependency health: unverified → partial
- [functional improvement] License: unverified → pass
- [functional] Licence: MIT

### 2026-07-27 (score 42)

First indexed and scored.

## MCP tools (33)

### `embedcalc_crc_to_c` (~549 tokens)

CRC → C Code Generator

Generate a complete, compilable C implementation (256-entry lookup table + compute function) for any CRC-8/16/32, plus its standard check value.

Use a preset for common CRCs, or specify the Rocksoft model parameters (width/poly/init/reflect-in/reflect-out/xor-out) for a custom CRC. The generated code embeds check("123456789") so the result can be verified on target.

Args:
  \- preset (optional): one of CRC-8, CRC-8/MAXIM, CRC-16/CCITT, CRC-16/ARC, CRC-16/MODBUS, CRC-32, CRC-32/BZIP2. Overrides all other args.
  \- bits (8|16|32), poly_hex (e.g. '0x1021'): required for a custom CRC.
  \- init_hex, reflect_in, reflect_out, xor_out_hex: optional custom parameters (defaults: 0x0, false, false, 0x0).

Returns (structured): { check_hex, config, c_code }. The text content is the C source itself.

Examples:
  \- "MODBUS RTU CRC in C" -> preset='CRC-16/MODBUS'
  \- "CRC-16 poly 0x1021 init 0xFFFF, no reflection" -> bits=16, poly_hex='0x1021', init_hex='0xFFFF'
Check values are exact (e.g. CRC-16/CCITT -> 0x29B1, CRC-32 -> 0xCBF43926); do not estimate CRCs — call this tool.

Input parameters:

- `bits` (number): CRC width in bits (8, 16, or 32). Required when no preset is given.
- `init_hex` (string): Initial CRC register value in hex (default 0x0).
- `poly_hex` (string): Generator polynomial in normal (non-reflected) hex form, e.g. '0x1021'. Required when no preset is given.
- `preset` (string): Standard CRC preset. If given, all other parameters are ignored. One of: CRC-8, CRC-8/MAXIM, CRC-16/CCITT, CRC-16/ARC, CRC-16/MODBUS, CRC-32, CRC-32/BZIP2
- `reflect_in` (boolean): Reflect each input byte (LSB-first processing). Default false.
- `reflect_out` (boolean): Reflect the final CRC before XOR-out. Default false.
- `xor_out_hex` (string): Final XOR value in hex (default 0x0).

Output parameters:

- `c_code` (string): Complete, compilable C source: 256-entry lookup table + crcN_compute() function
- `check_hex` (string): CRC of the ASCII string "123456789" — the standard check value for verifying the parameters
- `config` (object)

### `embedcalc_regmap_to_c` (~263 tokens)

Register Map → C Generator

Generate C shift/mask #defines and a bit-field typedef struct for a hardware register from an LSB-first field list.

Args:
  \- register_name (string): e.g. 'CTRL'. Sanitized to [A-Z0-9_].
  \- fields (array of {name, width}): fields from bit 0 (LSB) upward, e.g. [{name:'EN',width:1},{name:'MODE',width:2},{name:'DIV',width:5}]. Total width must fit in 32 bits.

Returns (structured): { c_code, total_bits, fields: [{name, width, shift, mask_hex}] }. Text content is the C source (defines + typedef struct with uint32_t bit-fields).

Example: EN:1, MODE:2, DIV:5 -> CTRL_EN_SHIFT 0u / CTRL_EN_MASK 0x1u, CTRL_MODE_MASK 0x6u, CTRL_DIV_MASK 0xF8u. Do not compute shifts/masks by hand — call this tool.

Input parameters:

- `fields` (array, required): Fields from LSB upward; total width <= 32 bits
- `register_name` (string, required): Register name, e.g. 'CTRL'

Output parameters:

- `c_code` (string)
- `fields` (array)
- `total_bits` (number)

### `embedcalc_bitfield_macro` (~164 tokens)

Bit Field Value → C Macro

Decompose a 32-bit register value into set bits and generate a C macro of OR'd (1U << n) terms, plus decimal/binary/popcount views.

Args:
  \- value_hex (string): 32-bit value, e.g. '0x8001'.
  \- macro_name (string, optional): default 'REG_VAL'.

Returns (structured): { dec, hex, bin, ones_count, c_macro }.
Example: '0x8001' -> #define REG_VAL ((1U << 0) | (1U << 15)), 2 bits set.

Input parameters:

- `macro_name` (string): C macro name (default REG_VAL)
- `value_hex` (string, required): 32-bit register value in hex

Output parameters:

- `bin` (string)
- `c_macro` (string)
- `dec` (string)
- `hex` (string)
- `ones_count` (number)

### `embedcalc_can_bit_timing` (~530 tokens)

CAN Bit Timing Calculator

Compute exact CAN bit timing (BRP, segments, SJW, register values) for STM32 bxCAN, STM32 FDCAN (nominal/arbitration phase), and MCP2515 from clock, bitrate, and target sample point.

Searches all valid prescaler/segment combinations and returns, per controller, the configuration whose sample point is closest to the target (ties: more TQ per bit, then smaller BRP). Register values are ready to write: bxCAN CAN_BTR, FDCAN FDCAN_NBTP, MCP2515 CNF1/CNF2/CNF3 (BTLMODE=1). All values follow the controller datasheets; BRP/TS values are 1-based (register encoding = value - 1 is already applied inside the hex words).

Args:
  \- clock_hz (int): controller input clock in Hz. bxCAN: APB1; FDCAN: kernel clock; MCP2515: crystal Fosc (MCP2515 uses TQ = 2*BRP/Fosc).
  \- bitrate_bps (int): nominal bitrate in bit/s (classic CAN: up to 1000000).
  \- sample_point_percent (50-95, default 87.5): CiA 301 recommends 87.5.

Returns (structured): { bxcan, fdcan, mcp2515 } — each a timing object or null when the clock/bitrate ratio has no exact integer divider for that controller (a null means: change the clock or bitrate, do not approximate).

Examples:
  \- "500 kbit/s on STM32F103 (APB1 36 MHz)" -> clock_hz=36000000, bitrate_bps=500000
  \- "1 Mbit/s, 16 MHz MCP2515, sample point 75%" -> clock_hz=16000000, bitrate_bps=1000000, sample_point_percent=75
Do not guess CAN timing registers — call this tool.

Input parameters:

- `bitrate_bps` (integer, required): Target nominal bitrate in bit/s, e.g. 500000 for 500 kbit/s.
- `clock_hz` (integer, required): CAN controller input clock in Hz (bxCAN: APB1 clock; FDCAN: kernel clock; MCP2515: crystal Fosc). E.g. 36000000 for 36 MHz.
- `sample_point_percent` (number): Target sample point in percent. CiA 301 recommends 87.5 (the default).

Output parameters:

- `bxcan`: STM32 bxCAN solution, or null if no exact divider exists
- `fdcan`: STM32 FDCAN nominal (arbitration phase) solution, or null
- `mcp2515`: MCP2515 solution (BTLMODE=1, SAM=0), or null

### `embedcalc_uart_baud` (~323 tokens)

UART Baud Rate / BRR Calculator

Compute the STM32 USART BRR register (mantissa + fraction), the actual achieved baud rate, and the baud error for a given peripheral clock — plus frame size/character time for the given format.

Args:
  \- clock_hz (int): USART peripheral clock in Hz (e.g. 72000000).
  \- baud (int): target baud rate (e.g. 115200).
  \- oversampling (8|16, default 16): USART OVER8 setting.
  \- data_bits (5-9, default 8), parity ('none'|'even'|'odd', default 'none'), stop_bits (1|1.5|2, default 1).

Returns (structured): { mantissa, fraction, brr_hex, actual_baud, error_percent, frame_bits, char_time_us }.
Rule of thumb: |error| < 2% total link budget; keep your side < 0.5% when possible.
Example: 72 MHz, 115200, over16 -> BRR=0x0271 (mantissa 39, fraction 1), 0.00% error.

Input parameters:

- `baud` (integer, required): Target baud rate in bit/s
- `clock_hz` (integer, required): USART peripheral clock in Hz
- `data_bits` (integer): Data bits per frame
- `oversampling` (number): Oversampling (OVER8): 16 or 8
- `parity` (string): Parity
- `stop_bits` (number): Stop bits

Output parameters:

- `actual_baud` (number)
- `brr_hex` (string): USART_BRR register value
- `char_time_us` (number): Time per character at actual baud
- `error_percent` (number)
- `fraction` (number)
- `frame_bits` (number): start + data + parity + stop bits
- `mantissa` (number)

### `embedcalc_i2c_timing` (~373 tokens)

I2C Timing & Pull-Up Calculator

Compute I2C pull-up resistor range (Rp min from sink current, Rp max from rise time vs bus capacitance), SCL high/low budget, and an STM32 I2C TIMINGR register estimate.

Args:
  \- mode: 'ls' (10k), 'sm' (100k), 'fm' (400k), 'fmp' (1M, 20mA sink), 'hs' (3.4M).
  \- vdd (V, default 3.3), bus_capacitance_pf (default 100).
  \- stm32_clock_mhz (default 16): I2CCLK kernel clock for the TIMINGR estimate.

Returns (structured): rp_min_ohm / rp_max_ohm, scl high/low vs spec minimums, rise/fall limits, stm32 { presc, scll, sclh, sdadel, scldel, timingr_hex }.
The TIMINGR value is an estimate per RM formulas — verify on scope for production.
Example: Fast-mode, 3.3V, 100pF -> Rp between ~967Ω and ~3.5kΩ (use 2.2k).

Input parameters:

- `bus_capacitance_pf` (number): Total bus capacitance in pF (spec max 400 pF)
- `mode` (string): Bus speed mode: ls=10kHz, sm=100kHz, fm=400kHz, fmp=1MHz, hs=3.4MHz
- `stm32_clock_mhz` (number): STM32 I2C kernel clock (I2CCLK) in MHz for TIMINGR estimate
- `vdd` (number): Bus supply voltage in volts

Output parameters:

- `rp_max_ohm` (number)
- `rp_min_ohm` (number)
- `scl_high_min_spec_us` (number)
- `scl_high_us` (number)
- `scl_low_min_spec_us` (number)
- `scl_low_us` (number)
- `stm32` (object)
- `t_fall_max_ns` (number)
- `t_rise_max_ns` (number)
- `target_freq_hz` (number)

### `embedcalc_spi_timing` (~123 tokens)

SPI Timing Calculator

SPI clock/frame timing: bit period, frame time, raw throughput.
Args: sck_hz (SPI clock in Hz), bits_per_frame (default 8).
Returns (structured): { bit_period_ns, frame_time_us, throughput_mbps }.
Example: 10 MHz, 8 bits -> 100 ns/bit, 0.8 µs/frame, 10 Mbit/s.

Input parameters:

- `bits_per_frame` (integer): Bits per frame/transfer
- `sck_hz` (integer, required): SCK clock frequency in Hz

Output parameters:

- `bit_period_ns` (number)
- `frame_time_us` (number)
- `throughput_mbps` (number)

### `embedcalc_i2s_clocks` (~181 tokens)

I2S Clock Calculator

I2S bit clock (BCLK/SCK) from audio format: BCLK = Fs x bits x channels.
Args: sample_rate_hz (e.g. 48000), bits_per_sample (e.g. 16/24/32), channels (default 2).
Returns (structured): { bclk_hz, bclk_period_ns, lrclk_hz }.
Example: 48 kHz, 24-bit, stereo -> BCLK 2.304 MHz (434.03 ns), LRCLK 48 kHz.

Input parameters:

- `bits_per_sample` (integer, required): Bits per sample per channel (16/24/32)
- `channels` (integer): Channel count (2 = stereo)
- `sample_rate_hz` (number, required): Sample rate Fs in Hz (44100, 48000, ...)

Output parameters:

- `bclk_hz` (number)
- `bclk_period_ns` (number)
- `lrclk_hz` (number)

### `embedcalc_lin_timing` (~164 tokens)

LIN Bus Timing Calculator

LIN bus timing: bit time, break field duration (13 bits), and worst-case frame time per LIN 2.x nominal (header 34 + response 10*(n+1) bits with 1.4x budget = (43+10n)/baud).
Args: baud (typ. 9600/19200), data_bytes (1-8).
Returns (structured): { bit_time_us, break_time_us, frame_time_us }.
Example: 19200 baud, 8 bytes -> bit 52.08 µs, break 677 µs, frame 6406 µs.

Input parameters:

- `baud` (integer): LIN baud rate (max 20 kbit/s)
- `data_bytes` (integer): Response data bytes

Output parameters:

- `bit_time_us` (number)
- `break_time_us` (number)
- `frame_time_us` (number)

### `embedcalc_rs485_bus` (~207 tokens)

RS-485 Bus Calculator

RS-485 cable length limit (rule of thumb: length_m x bitrate_bps <= 10^8, capped 1200 m) and fail-safe bias resistors for >= 200 mV idle differential across 60 Ω (two 120 Ω terminators).
Args: baud_bps, vcc (default 5), bias_ohm (optional — defaults to the computed maximum).
Returns (structured): { max_cable_m, max_bias_ohm, bias_used_ohm, idle_vdiff_v, meets_200mv }.
Example: 100 kbit/s -> 1000 m; Vcc=5 -> bias <= 720 Ω per side for 0.2 V idle.

Input parameters:

- `baud_bps` (integer, required): Signaling rate in bit/s
- `bias_ohm` (number): Chosen bias resistor per side in Ω (default: computed maximum)
- `vcc` (number): Bias supply voltage

Output parameters:

- `bias_used_ohm` (number)
- `idle_vdiff_v` (number)
- `max_bias_ohm` (number): Maximum bias resistor per side for 200 mV idle differential
- `max_cable_m` (number)
- `meets_200mv` (boolean)

### `embedcalc_modbus_rtu_timing` (~158 tokens)

Modbus RTU Timing Calculator

Modbus RTU inter-character (t1.5) and inter-frame (t3.5) silence times. Per spec: 11 bits/char; above 19200 baud fixed t1.5=750 µs and t3.5=1750 µs.
Args: baud.
Returns (structured): { char_time_us, t15_us, t35_us }.
Example: 9600 -> char 1145.8 µs, t1.5 1718.8 µs, t3.5 4010.4 µs; 115200 -> 750/1750 µs fixed.

Input parameters:

- `baud` (integer, required): Baud rate in bit/s

Output parameters:

- `char_time_us` (number)
- `t15_us` (number)
- `t35_us` (number)

### `embedcalc_ring_buffer_size` (~158 tokens)

Ring Buffer / DMA Size Calculator

Size a ring buffer (or DMA buffer) from data rate, worst-case consumer latency, and a safety factor, rounded up to a power of two.
Args: data_rate_bytes_per_sec, latency_ms (worst-case time before the consumer drains), safety_factor (default 2).
Returns (structured): { bytes_needed, recommended_pow2 }.
Example: 102400 B/s, 10 ms, ×2 -> 2048 bytes -> use 2048 (2^11).

Input parameters:

- `data_rate_bytes_per_sec` (number, required): Incoming data rate in bytes/second
- `latency_ms` (number, required): Worst-case consumer latency in milliseconds
- `safety_factor` (number): Headroom multiplier (default 2)

Output parameters:

- `bytes_needed` (number)
- `recommended_pow2` (number): Next power of two >= bytes_needed (fast masking index math)

### `embedcalc_qformat_convert` (~249 tokens)

Q-Format Fixed-Point Converter

Convert between float and signed Qm.n fixed point (1 sign + m integer + n fractional bits; e.g. Q0.15 = 16-bit "Q15").

Args:
  \- m (int >= 0), n (int >= 0): format; m+n+1 <= 32.
  \- value (float) OR raw_int (stored integer): provide exactly one.

Returns (structured): { format, total_bits, scale, range_min, range_max, raw_int, hex, bin, actual, error, clamped }. hex/bin are two's complement in the format's bit width.
Examples: 0.5 in Q0.15 -> 16384 = 0x4000; raw 0x8000 (-32768) in Q0.15 -> -1.0. Do not round by hand — quantization error matters.

Input parameters:

- `m` (integer, required): Integer bits (excluding sign)
- `n` (integer, required): Fractional bits
- `raw_int` (integer): Stored fixed-point integer to decode (provide this OR value)
- `value` (number): Float value to encode (provide this OR raw_int)

Output parameters:

- `actual` (number): Value actually represented after quantization
- `bin` (string)
- `clamped` (boolean)
- `error` (number): |input - actual| (0 when decoding raw_int)
- `format` (string)
- `hex` (string)
- `range_max` (number)
- `range_min` (number)
- `raw_int` (number)
- `scale` (number): 2^n
- `total_bits` (number)

### `embedcalc_ieee754_convert` (~270 tokens)

IEEE 754 Float Converter

Encode/decode IEEE 754 single (32-bit) or double (64-bit) precision: decimal <-> hex <-> binary, with sign/exponent/fraction breakdown and classification.

Args:
  \- format (32|64, default 32).
  \- Provide exactly one of: decimal (number), hex (string like '0x3F800000'), bin (bit string).

Returns (structured): { sign, exponent_raw, exponent_unbiased, fraction, hex, bin, decimal (string — may be 'NaN'/'Infinity'), class ('normal'|'subnormal'|'zero'|'infinity'|'nan') }.
Examples: 1.0 float -> 0x3F800000; 0.1 double -> 0x3FB999999999999A (not exact!). Do not eyeball float bit patterns — call this tool.

Input parameters:

- `bin` (string): Binary bit pattern to decode (32 or 64 chars, spaces allowed)
- `decimal` (number): Decimal value to encode (one of decimal/hex/bin)
- `format` (number): 32 = float, 64 = double
- `hex` (string): Hex bit pattern to decode, e.g. '0x3F800000'

Output parameters:

- `bin` (string)
- `class` (string)
- `decimal` (string): Decimal value as string (may be 'NaN', 'Infinity', '-Infinity')
- `exponent_raw` (number)
- `exponent_unbiased` (number|null): exponent - bias; null for zero/subnormal/special
- `fraction` (number)
- `hex` (string)
- `sign` (number)

### `embedcalc_number_base_convert` (~154 tokens)

Number Base Converter (32-bit)

Convert a number between decimal/hex/binary/octal with 32-bit two's complement semantics (negative decimals wrap; MSB-set values get a signed reading).

Args: value (string) — decimal ('-1', '42'), hex ('0xFF'), binary ('0b1010'), or octal ('0o17').
Returns (structured): { unsigned, signed, hex, bin (4-bit groups), oct, ones_count }.
Example: '-1' -> 0xFFFFFFFF, unsigned 4294967295, 32 ones.

Input parameters:

- `value` (string, required): Number in any base: decimal, 0x hex, 0b binary, 0o octal

Output parameters:

- `bin` (string)
- `hex` (string)
- `oct` (string)
- `ones_count` (number)
- `signed` (string)
- `unsigned` (string)

### `embedcalc_endian_swap` (~177 tokens)

Endianness / Byte Swap Converter

Show a hex byte sequence in all endianness orderings: big (ABCD), little (DCBA), mid-little/byte-swapped halfwords (BADC), mid-big/halfword-swapped (CDAB).

Args: hex (string) — e.g. '0x12345678' or 'DEADBEEF'; odd nibble counts get a leading zero.
Returns (structured): { big, little, mid_little_badc, mid_big_cdab (null when < 4 bytes), bytes }.
Example: 12345678 -> little 78563412, BADC 34127856, CDAB 56781234. Useful for Modbus register order and mixed-endian protocol debugging.

Input parameters:

- `hex` (string, required): Hex byte sequence (with or without 0x)

Output parameters:

- `big` (string)
- `bytes` (array): Original bytes, big-endian order
- `little` (string)
- `mid_big_cdab` (string|null)
- `mid_little_badc` (string|null)

### `embedcalc_struct_layout` (~229 tokens)

C Struct Memory Layout Calculator

Compute the memory layout of a C struct/union — member offsets, inserted padding, bit-field packing, total size, and alignment — for a 32-bit MCU model (ARM Cortex-M style: pointers 4 bytes; double/int64 size 8 with 4-byte alignment, matching embedcalc.com).

Args: code (string) — C member declarations or a full struct, e.g. 'char a; int b;' or 'struct s { uint8_t a; uint32_t b; };'. Supports nested struct/union, arrays, pointers, and bit-fields.

Returns (structured): { total_size, alignment, padding_bytes, rows: [{offset, size, type, name, kind, depth}] }. Nested block rows show offsets relative to their parent block.
Example: 'char a; int b;' -> total 8 bytes, 3 bytes padding after 'a'. Do not guess struct sizes/offsets — padding rules are exactly what LLMs get wrong.

Input parameters:

- `code` (string, required): C struct member declarations (or full struct/union definition)

Output parameters:

- `alignment` (number)
- `padding_bytes` (number)
- `rows` (array)
- `total_size` (number)

### `embedcalc_eseries_nearest` (~188 tokens)

E-Series Nearest Standard Value

Snap a computed resistor/capacitor/inductor value to the nearest purchasable E-series standard value (E6/E12/E24/E96) with the resulting error.

Args: value (any unit — ohms, farads, henries), series ('E24' default; E96 for 1% resistors).
Returns (structured): { standard, error_percent, series }.
Example: 4.67e-6 H, E24 -> 4.7e-6 (+0.64%). LLMs frequently pick non-existent "standard" values — always snap computed values with this tool before choosing a part.

Input parameters:

- `series` (string): E-series (E24=5%, E96=1% resistors)
- `value` (number, required): Computed value in base units (ohms/farads/henries)

Output parameters:

- `error_percent` (number)
- `series` (string)
- `standard` (number)

### `embedcalc_resistor_code` (~224 tokens)

Resistor Color Code / SMD Code Decoder

Decode a through-hole resistor color code (4 or 5 bands) or an SMD resistor marking into ohms + tolerance.

Args (one of):
  \- bands: array of 4 or 5 color names in order (black, brown, red, orange, yellow, green, blue, violet, grey, white, gold, silver, none).
  \- smd_code: 3-digit ('472'=4.7k), 4-digit ('4702'=47k), R-notation ('4R7'=4.7Ω), or EIA-96 ('01C'=10k ±1%).

Returns (structured): { ohms, tolerance_percent, min_ohms, max_ohms }.
Example: ['brown','black','red','gold'] -> 1000 Ω ±5%.

Input parameters:

- `bands` (array): Color band names in order (4 or 5 bands)
- `smd_code` (string): SMD marking, e.g. '472', '4R7', '01C'

Output parameters:

- `max_ohms` (number|null)
- `min_ohms` (number|null)
- `ohms` (number)
- `tolerance_percent` (number|null)

### `embedcalc_crystal_load_caps` (~173 tokens)

Crystal Load Capacitor Calculator

Compute the two external load capacitors for a crystal from its specified load capacitance: CL = C/2 + Cstray -> C = 2·(CL − Cstray).

Args: load_capacitance_pf (from crystal datasheet, e.g. 18), stray_pf (PCB+pin stray, typ. 3-5).
Returns (structured): { cap_each_pf }.
Example: CL=18pF, stray=5pF -> 26 pF each side. Wrong load caps = frequency pulling; don't guess.

Input parameters:

- `load_capacitance_pf` (number, required): Crystal's specified CL in pF
- `stray_pf` (number): Stray capacitance (PCB traces + MCU pins) in pF, typ. 3-5

Output parameters:

- `cap_each_pf` (number)

### `embedcalc_lm317` (~269 tokens)

LM317 Resistor Calculator

LM317 adjustable regulator: Vout = Vref·(1 + R2/R1) + Iadj·R2. Compute R2 for a target Vout, or Vout from R1/R2.

Args: r1_ohm (default 240), and exactly one of target_vout (-> solves R2) or r2_ohm (-> computes Vout). vref default 1.25 V, iadj_ua default 50 µA (datasheet typical).
Returns (structured): { vout, r1_ohm, r2_ohm }.
Example: target 5.0 V, R1=240, Iadj=0 -> R2=720 Ω. Snap R2 with embedcalc_eseries_nearest afterwards.

Input parameters:

- `iadj_ua` (number): Adjust pin current in µA (50 typ)
- `r1_ohm` (number): R1 (Vref across it), datasheet recommends 240 Ω
- `r2_ohm` (number): R2 value (computes Vout)
- `target_vout` (number): Desired output voltage (solves R2)
- `vref` (number): Reference voltage (1.25 V typ)

Output parameters:

- `r1_ohm` (number)
- `r2_ohm` (number)
- `vout` (number)

### `embedcalc_attenuator_pad` (~167 tokens)

Resistive Attenuator Pad (T / Pi)

Design T-pad and Pi-pad resistive attenuators for a given attenuation and system impedance.

Args: attenuation_db, impedance_ohm (default 50).
Returns (structured): { t_series_ohm, t_shunt_ohm, pi_shunt_ohm, pi_series_ohm }.
Example: 3 dB @ 50 Ω -> T: 8.55 Ω series ×2 + 141.9 Ω shunt; Pi: 292.4 Ω shunt ×2 + 17.61 Ω series. Snap values with embedcalc_eseries_nearest.

Input parameters:

- `attenuation_db` (number, required): Attenuation in dB
- `impedance_ohm` (number): System impedance (50/75 Ω)

Output parameters:

- `pi_series_ohm` (number): Pi-pad: center series resistor
- `pi_shunt_ohm` (number): Pi-pad: each of the two shunt resistors
- `t_series_ohm` (number): T-pad: each of the two series resistors
- `t_shunt_ohm` (number): T-pad: center shunt resistor

### `embedcalc_junction_temp` (~177 tokens)

Junction Temperature / Max Power

Thermal check: Tj = Ta + P·θJA, and max dissipable power for a Tj limit.

Args: ambient_c, power_w, theta_ja (°C/W from datasheet), tj_max_c (default 150).
Returns (structured): { tj_c, p_max_w, margin_c, ok }.
Example: Ta=25, P=2W, θJA=50 -> Tj=125°C, Pmax=2.5W @ Tj_max 150.

Input parameters:

- `ambient_c` (number, required): Ambient temperature in °C
- `power_w` (number, required): Dissipated power in W
- `theta_ja` (number, required): Junction-to-ambient thermal resistance °C/W
- `tj_max_c` (number): Maximum junction temperature rating in °C

Output parameters:

- `margin_c` (number): tj_max - tj (negative = over limit)
- `ok` (boolean)
- `p_max_w` (number)
- `tj_c` (number)

### `embedcalc_microstrip_impedance` (~229 tokens)

Microstrip Impedance (IPC-2141)

Surface microstrip characteristic impedance: Z0 = (87/√(εr+1.41))·ln(5.98h/(0.8w+t)). Valid roughly for 0.1 < w/h < 2.0 and εr < 15.

Args (all in mm): trace_width_mm, dielectric_height_mm, trace_thickness_mm (1oz ≈ 0.035), er (FR-4 ≈ 4.2-4.6).
Returns (structured): { z0_ohm }.
Example: w=3.0, h=1.6, t=0.035, εr=4.5 -> ≈49 Ω.

Input parameters:

- `dielectric_height_mm` (number, required): Dielectric height h in mm
- `er` (number): Dielectric constant (FR-4 ≈ 4.5)
- `trace_thickness_mm` (number): Copper thickness t in mm (1 oz = 0.035)
- `trace_width_mm` (number, required): Trace width w in mm

Output parameters:

- `z0_ohm` (number)

### `embedcalc_pcb_trace_width` (~222 tokens)

PCB Trace Width for Current (IPC-2221)

Minimum trace width to carry a current with a given temperature rise, per IPC-2221 (I = k·ΔT^0.44·A^0.725; k=0.048 external / 0.024 internal).

Args: current_a, temp_rise_c (default 10), copper_oz (default 1), layer ('external'|'internal').
Returns (structured): { width_mil, width_mm, cross_section_sq_mil }.
Example: 1 A, 10 °C rise, 1 oz external -> ≈11.8 mil (0.30 mm). Internal layers need ~2x the width. Do not guess trace widths — this curve is not linear.

Input parameters:

- `copper_oz` (number): Copper weight in oz (1 oz = 35 µm)
- `current_a` (number, required): Continuous current in amps
- `layer` (string): Trace layer
- `temp_rise_c` (number): Allowed temperature rise in °C (typ. 10)

Output parameters:

- `cross_section_sq_mil` (number)
- `width_mil` (number)
- `width_mm` (number)

### `embedcalc_awg_wire` (~233 tokens)

AWG Wire Gauge & Voltage Drop

AWG wire properties (ASTM B258) and round-trip voltage drop for a copper pair: diameter, area, loop resistance (2× length, go & return), drop %, and a PASS/WARNING/FAIL verdict (<3% / 3-5% / >5%).

Args: awg (e.g. 20), supply_v, current_a, length_m (one-way), temp_c (default 20).
Returns (structured): { diameter_mm, area_mm2, loop_resistance_ohm, voltage_drop_v, drop_percent, verdict }.
Example: AWG20, 5 V, 2 A, 1 m -> 0.067 Ω loop, 2.7% drop, PASS.

Input parameters:

- `awg` (number, required): Wire gauge AWG number
- `current_a` (number, required): Load current in A
- `length_m` (number, required): One-way cable length in m (loop = 2×)
- `supply_v` (number, required): Supply voltage in V
- `temp_c` (number): Conductor temperature in °C

Output parameters:

- `area_mm2` (number)
- `diameter_mm` (number)
- `drop_percent` (number)
- `loop_resistance_ohm` (number)
- `verdict` (string)
- `voltage_drop_v` (number)

### `embedcalc_ne555` (~233 tokens)

NE555 Timer Calculator

NE555 timing. Astable: f = 1/(0.693·(Ra+2Rb)·C), duty = (Ra+Rb)/(Ra+2Rb) (always >50%). Monostable: t = 1.1·Ra·C.

Args: mode ('astable'|'monostable'), ra_ohm, rb_ohm (astable only), c_farad (e.g. 10e-6).
Returns (structured): astable -> { freq_hz, duty_percent, t_high_s, t_low_s }; monostable -> { pulse_s }.
Example: astable 1k/10k/10µF -> 6.87 Hz, 52.4%.

Input parameters:

- `c_farad` (number, required): Timing capacitor in farads (10µF = 10e-6)
- `mode` (string, required): Oscillator or one-shot
- `ra_ohm` (number, required): Ra in ohms
- `rb_ohm` (number): Rb in ohms (astable only)

Output parameters:

- `duty_percent` (number|null)
- `freq_hz` (number|null)
- `pulse_s` (number|null)
- `t_high_s` (number|null)
- `t_low_s` (number|null)

### `embedcalc_dcdc_converter` (~279 tokens)

Buck / Boost / Buck-Boost Converter Calculator

DC-DC converter design (CCM): duty cycle, minimum inductance, minimum output capacitance, input current, and peak switch current for buck, boost, or inverting buck-boost.

Args: topology ('buck'|'boost'|'buckboost'), vin, vout, iout_a, freq_khz (default 100), ripple_current_pct (of Iout, default 30), ripple_voltage_mv (default 50).
Returns (structured): { duty_percent, l_min_uh, c_min_uf, iin_a, i_peak_a }.
Example: buck 12->5 V, 1 A, 100 kHz -> D=41.7%, L≥97.2 µH, C≥7.5 µF. Snap L/C with embedcalc_eseries_nearest.

Input parameters:

- `freq_khz` (number): Switching frequency kHz
- `iout_a` (number, required): Output current A
- `ripple_current_pct` (number): Inductor ripple current as % of Iout
- `ripple_voltage_mv` (number): Allowed output ripple voltage mV
- `topology` (string, required): Converter topology (buckboost = inverting)
- `vin` (number, required): Input voltage V
- `vout` (number, required): Output voltage V (magnitude for inverting)

Output parameters:

- `c_min_uf` (number)
- `duty_percent` (number)
- `i_peak_a` (number)
- `iin_a` (number)
- `l_min_uh` (number)

### `embedcalc_find_component` (~539 tokens)

Find Real Component (MPN + buy link)

Find real, in-stock components matching an electrical value via parametric distributor search — returns manufacturer part numbers and buy links ONLY (no price or stock data, by design).

Args:
  \- type: resistor | capacitor | inductor | ldo | mosfet | bjt.
  \- value (number): resistor: resistance in ohms; capacitor: capacitance in farads (e.g. 1e-7 = 100 nF); inductor: inductance in henries (e.g. 1e-5 = 10 µH); ldo: fixed output voltage in volts; mosfet: minimum Vds rating in volts (N-channel); bjt: minimum Vce rating in volts (NPN).
  \- Optional filters: tolerance_pct (R/C/L: keep this tolerance or tighter), min_power_w (resistor), min_voltage_v (capacitor rating), min_current_a (ldo/mosfet/bjt), max_rds_on_ohm (mosfet), min_hfe (bjt).
  \- max_results (default 5).

Returns (structured): { matched_value, parts: [{ mpn, manufacturer, description, buy_url }] }. For prices, follow the buy link — pricing is intentionally not returned.

Examples:
  \- "220 ohm 1% resistor" -> type='resistor', value=220, tolerance_pct=1
  \- "100 nF cap rated 16V+" -> type='capacitor', value=1e-7, min_voltage_v=16
  \- "3.3V LDO, 500 mA" -> type='ldo', value=3.3, min_current_a=0.5
Requires internet access (queries embedcalc.com).

Input parameters:

- `max_rds_on_ohm` (number): Maximum Rds(on) in ohms (mosfet)
- `max_results` (integer): Maximum parts to return
- `min_current_a` (number): Minimum current in amps (ldo output / mosfet Id / bjt Ic)
- `min_hfe` (number): Minimum hFE / current gain (bjt)
- `min_power_w` (number): Minimum power rating in watts (resistor)
- `min_voltage_v` (number): Minimum voltage rating in volts (capacitor)
- `tolerance_pct` (number): Max tolerance in % (resistor/capacitor/inductor)
- `type` (string, required): Component type
- `value` (number, required): Primary value — meaning depends on type (ohms / farads / henries / volts)

Output parameters:

- `matched_value` (string): The parametric value string the search matched
- `parts` (array)

### `embedcalc_review_schematic` (~198 tokens)

Review Schematic

표준 회로 스키마를 받아 임베디드 보드 룰(디커플링, 리셋, I2C 풀업, 전원, 패밀리별 요구사항)을 결정론적으로 검토합니다.

이미지 회로도라면 먼저 embedcalc_get_extraction_guide로 스키마 형식을 받아 채운 뒤 이 툴에 넘기세요.
KiCad 넷리스트라면 embedcalc_parse_kicad의 출력에 mcu.family만 추가해 넘기면 됩니다.

반환: { violations[], checked[], skipped[], interfacesDetected[] }. skipped는 데이터 부족으로 검사하지 못한 룰이며, 이를 통해 커버리지를 확인하세요. interfacesDetected는 넷 이름으로 자동 감지된 인터페이스 팩(usb/can/rs485/swd/crystal 등) 목록입니다.

Input parameters:

- `schematic` (object, required)

### `embedcalc_parse_kicad` (~160 tokens)

Parse KiCad Netlist

KiCad "netlist export"(.net, S-expression) 파일을 표준 회로 스키마로 변환합니다.

부품 type은 ref 접두(U→ic, C→cap, R→res …)로 추론되며, mcu.family는 비어 있습니다.
패밀리 룰을 원하면 반환된 스키마에 mcu.family(stm32f4|stm32f1|esp32|numicro)를 추가해 embedcalc_review_schematic에 넘기세요.

입력: path (넷리스트 파일 절대경로). 반환: 표준 회로 스키마.

Input parameters:

- `path` (string, required): KiCad netlist export 파일 경로(.net)

### `embedcalc_get_extraction_guide` (~50 tokens)

Get Image Extraction Guide

회로도 이미지를 표준 회로 스키마로 추출하는 지침과 스키마 템플릿을 반환합니다. 이미지 검토의 첫 단계.

### `embedcalc_list_schematic_rules` (~77 tokens)

List Schematic Rules

회로 검토 룰 카탈로그를 반환합니다. family를 주면 해당 패밀리 룰(stm32f4|stm32f1|esp32|numicro)도 포함.

Input parameters:

- `family` (string): stm32f4 | stm32f1 | esp32 | numicro

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/ethan-hub26-embedcalc-mcp/embedcalc-mcp#diagnostics

## Score history

- 2026-08-03: 61
- 2026-08-02: 61
- 2026-08-01: 31
- 2026-07-30: 44
- 2026-07-29: 74
- 2026-07-28: 42
- 2026-07-27: 42

## Links

- npm package: https://www.npmjs.com/package/embedcalc-mcp
- Socket report: https://socket.dev/npm/package/embedcalc-mcp
- Repository: https://github.com/ethan-hub26/embedcalc-mcp
- Website: https://www.embedcalc.com/mcp/
- Changelog RSS feed: https://verifymcp.io/servers/ethan-hub26-embedcalc-mcp/embedcalc-mcp/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/ethan-hub26-embedcalc-mcp/embedcalc-mcp/changelog.json
- HTML version of this page: https://verifymcp.io/servers/ethan-hub26-embedcalc-mcp/embedcalc-mcp