siglent-sdg-mcp 1.0.0

package/build/tools/burst.js

@@ -0,0 +1,191 @@
+import { z } from "zod";
+import { connection } from "../connection.js";
+export function registerBurstTools(server) {
+    server.tool("get_burst", "Get the burst wave parameters of a channel, including state, period, trigger source, burst mode (gate/ncycle), cycle count, carrier settings, and delay.", {
+        channel: z.enum(["C1", "C2"]).describe("Channel to query"),
+    }, { readOnlyHint: true }, async ({ channel }) => {
+        try {
+            const response = await connection.query(`${channel}:BTWV?`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: response,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("configure_burst", "Configure burst mode on a channel. State must be set to ON before other parameters. Builds a single BTWV command with all specified parameters.", {
+        channel: z.enum(["C1", "C2"]).describe("Channel to configure"),
+        state: z
+            .enum(["ON", "OFF"])
+            .optional()
+            .describe("Burst state. Must be ON before setting other params."),
+        period: z
+            .number()
+            .optional()
+            .describe("Burst period in seconds"),
+        start_phase: z
+            .number()
+            .optional()
+            .describe("Start phase in degrees (0-360)"),
+        burst_mode: z
+            .enum(["GATE", "NCYC"])
+            .optional()
+            .describe("Burst mode: GATE or NCYC (N-cycle)"),
+        trigger_source: z
+            .enum(["EXT", "INT", "MAN"])
+            .optional()
+            .describe("Trigger source"),
+        trigger_out: z
+            .enum(["RISE", "FALL", "OFF"])
+            .optional()
+            .describe("Trigger output mode (when NCYC and INT/MAN)"),
+        trigger_edge: z
+            .enum(["RISE", "FALL"])
+            .optional()
+            .describe("Trigger edge (when EXT or MAN)"),
+        cycles: z
+            .string()
+            .optional()
+            .describe("Number of burst cycles (integer, or 'INF' for infinite)"),
+        delay: z
+            .number()
+            .optional()
+            .describe("Trigger delay in seconds (when NCYC mode)"),
+        gate_polarity: z
+            .enum(["NEG", "POS"])
+            .optional()
+            .describe("Gate polarity (when GATE mode)"),
+        manual_trigger: z
+            .boolean()
+            .optional()
+            .describe("Send a manual trigger (only when trigger source is MAN)"),
+        carrier_waveform: z
+            .enum(["SINE", "SQUARE", "RAMP", "ARB", "PULSE", "NOISE"])
+            .optional()
+            .describe("Carrier waveform type"),
+        carrier_frequency: z
+            .number()
+            .optional()
+            .describe("Carrier frequency in Hz"),
+        carrier_amplitude: z
+            .number()
+            .optional()
+            .describe("Carrier amplitude in Vpp"),
+        carrier_offset: z
+            .number()
+            .optional()
+            .describe("Carrier DC offset in volts"),
+        carrier_phase: z
+            .number()
+            .optional()
+            .describe("Carrier phase in degrees (0-360)"),
+        carrier_duty: z
+            .number()
+            .optional()
+            .describe("Carrier duty cycle in % (for SQUARE or PULSE)"),
+        carrier_symmetry: z
+            .number()
+            .optional()
+            .describe("Carrier symmetry in % (for RAMP)"),
+    }, { readOnlyHint: false }, async ({ channel, state, period, start_phase, burst_mode, trigger_source, trigger_out, trigger_edge, cycles, delay, gate_polarity, manual_trigger, carrier_waveform, carrier_frequency, carrier_amplitude, carrier_offset, carrier_phase, carrier_duty, carrier_symmetry, }) => {
+        try {
+            const sent = [];
+            // State must be set first and separately
+            if (state) {
+                const cmd = `${channel}:BTWV STATE,${state}`;
+                await connection.sendCommand(cmd);
+                sent.push(cmd);
+            }
+            // Build remaining parameters
+            const parts = [];
+            if (period !== undefined)
+                parts.push(`PRD,${period}`);
+            if (start_phase !== undefined)
+                parts.push(`STPS,${start_phase}`);
+            if (burst_mode)
+                parts.push(`GATE_NCYC,${burst_mode}`);
+            if (trigger_source)
+                parts.push(`TRSR,${trigger_source}`);
+            if (trigger_out)
+                parts.push(`TRMD,${trigger_out}`);
+            if (trigger_edge)
+                parts.push(`EDGE,${trigger_edge}`);
+            if (cycles !== undefined)
+                parts.push(`TIME,${cycles}`);
+            if (delay !== undefined)
+                parts.push(`DLAY,${delay}`);
+            if (gate_polarity)
+                parts.push(`PLRT,${gate_polarity}`);
+            if (carrier_waveform)
+                parts.push(`CARR,WVTP,${carrier_waveform}`);
+            if (carrier_frequency !== undefined)
+                parts.push(`CARR,FRQ,${carrier_frequency}`);
+            if (carrier_amplitude !== undefined)
+                parts.push(`CARR,AMP,${carrier_amplitude}`);
+            if (carrier_offset !== undefined)
+                parts.push(`CARR,OFST,${carrier_offset}`);
+            if (carrier_phase !== undefined)
+                parts.push(`CARR,PHSE,${carrier_phase}`);
+            if (carrier_duty !== undefined)
+                parts.push(`CARR,DUTY,${carrier_duty}`);
+            if (carrier_symmetry !== undefined)
+                parts.push(`CARR,SYM,${carrier_symmetry}`);
+            if (parts.length > 0) {
+                const cmd = `${channel}:BTWV ${parts.join(",")}`;
+                await connection.sendCommand(cmd);
+                sent.push(cmd);
+            }
+            // Manual trigger sent separately
+            if (manual_trigger) {
+                const cmd = `${channel}:BTWV MTRIG`;
+                await connection.sendCommand(cmd);
+                sent.push(cmd);
+            }
+            if (sent.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Error: At least one parameter must be specified.",
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Burst configured:\n${sent.join("\n")}`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=burst.js.map

package/build/tools/connection.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerConnectionTools(server: McpServer): void;

package/build/tools/connection.js

@@ -0,0 +1,90 @@
+import { z } from "zod";
+import { connection } from "../connection.js";
+export function registerConnectionTools(server) {
+    server.tool("connect", "Connect to a Siglent SDG waveform generator over TCP. Returns device identification on success.", {
+        host: z
+            .string()
+            .optional()
+            .describe("IP address of the waveform generator (defaults to SIGLENT_SDG_IP or SIGLENT_IP env var)"),
+        port: z
+            .number()
+            .optional()
+            .describe("TCP port (defaults to 5025)"),
+    }, { readOnlyHint: false, openWorldHint: true }, async ({ host, port }) => {
+        const targetHost = host || process.env.SIGLENT_SDG_IP || process.env.SIGLENT_IP;
+        if (!targetHost) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: No host specified. Provide a 'host' parameter or set the SIGLENT_SDG_IP environment variable.",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        try {
+            const idn = await connection.connect(targetHost, port);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Connected to ${targetHost}:${port || 5025}\nDevice: ${idn}`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Connection failed: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("disconnect", "Disconnect from the waveform generator.", {}, { readOnlyHint: false }, async () => {
+        const info = connection.getConnectionInfo();
+        connection.disconnect();
+        return {
+            content: [
+                { type: "text", text: `Disconnected from ${info}` },
+            ],
+        };
+    });
+    server.tool("identify", "Query the waveform generator identification (*IDN?). Returns manufacturer, model, serial number, and firmware version.", {}, { readOnlyHint: true }, async () => {
+        try {
+            const idn = await connection.query("*IDN?");
+            const parts = idn.split(",");
+            const result = {
+                manufacturer: parts[0]?.trim() || "Unknown",
+                model: parts[1]?.trim() || "Unknown",
+                serial: parts[2]?.trim() || "Unknown",
+                firmware: parts[3]?.trim() || "Unknown",
+            };
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=connection.js.map

package/build/tools/modulation.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerModulationTools(server: McpServer): void;

package/build/tools/modulation.js

@@ -0,0 +1,200 @@
+import { z } from "zod";
+import { connection } from "../connection.js";
+export function registerModulationTools(server) {
+    server.tool("get_modulation", "Get the modulation parameters of a channel. Returns all modulation settings including type, source, frequency, depth/deviation, and carrier parameters.", {
+        channel: z.enum(["C1", "C2"]).describe("Channel to query"),
+    }, { readOnlyHint: true }, async ({ channel }) => {
+        try {
+            const response = await connection.query(`${channel}:MDWV?`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: response,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("configure_modulation", "Configure modulation on a channel. Set state first (ON), then type and parameters. Commands are sent sequentially: state, then type, then type-specific parameters, then carrier parameters.", {
+        channel: z.enum(["C1", "C2"]).describe("Channel to configure"),
+        state: z
+            .enum(["ON", "OFF"])
+            .optional()
+            .describe("Modulation state. Must be ON before setting other params."),
+        type: z
+            .enum(["AM", "DSBAM", "FM", "PM", "PWM", "ASK", "FSK", "PSK"])
+            .optional()
+            .describe("Modulation type"),
+        source: z
+            .enum(["INT", "EXT", "CH1", "CH2"])
+            .optional()
+            .describe("Modulation source (availability depends on type)"),
+        mod_wave: z
+            .enum(["SINE", "SQUARE", "TRIANGLE", "UPRAMP", "DNRAMP", "NOISE", "ARB"])
+            .optional()
+            .describe("Modulating waveform shape (only when source is INT)"),
+        frequency: z
+            .number()
+            .optional()
+            .describe("Modulation frequency in Hz (AM/FM/PM/PWM) or key frequency (ASK/FSK/PSK)"),
+        depth: z
+            .number()
+            .optional()
+            .describe("AM modulation depth in % (0-120)"),
+        deviation: z
+            .number()
+            .optional()
+            .describe("FM frequency deviation in Hz, or PM phase deviation in degrees (0-360), or PWM duty deviation in %"),
+        hop_frequency: z
+            .number()
+            .optional()
+            .describe("FSK hop frequency in Hz"),
+        polarity: z
+            .enum(["POS", "NEG"])
+            .optional()
+            .describe("PSK polarity"),
+        carrier_waveform: z
+            .enum(["SINE", "SQUARE", "RAMP", "ARB", "PULSE"])
+            .optional()
+            .describe("Carrier waveform type"),
+        carrier_frequency: z
+            .number()
+            .optional()
+            .describe("Carrier frequency in Hz"),
+        carrier_amplitude: z
+            .number()
+            .optional()
+            .describe("Carrier amplitude in Vpp"),
+        carrier_offset: z
+            .number()
+            .optional()
+            .describe("Carrier DC offset in volts"),
+        carrier_phase: z
+            .number()
+            .optional()
+            .describe("Carrier phase in degrees (0-360)"),
+    }, { readOnlyHint: false }, async ({ channel, state, type, source, mod_wave, frequency, depth, deviation, hop_frequency, polarity, carrier_waveform, carrier_frequency, carrier_amplitude, carrier_offset, carrier_phase, }) => {
+        try {
+            const sent = [];
+            // 1. Set state first
+            if (state) {
+                const cmd = `${channel}:MDWV STATE,${state}`;
+                await connection.sendCommand(cmd);
+                sent.push(cmd);
+            }
+            // 2. Set modulation type
+            if (type) {
+                const cmd = `${channel}:MDWV ${type}`;
+                await connection.sendCommand(cmd);
+                sent.push(cmd);
+            }
+            // 3. Set type-specific parameters
+            const modType = type || "AM"; // Use provided type or default for param prefix
+            if (source) {
+                const cmd = `${channel}:MDWV ${modType},SRC,${source}`;
+                await connection.sendCommand(cmd);
+                sent.push(cmd);
+            }
+            if (mod_wave) {
+                const cmd = `${channel}:MDWV ${modType},MDSP,${mod_wave}`;
+                await connection.sendCommand(cmd);
+                sent.push(cmd);
+            }
+            if (frequency !== undefined) {
+                const freqParam = ["ASK", "FSK", "PSK"].includes(modType) ? "KFRQ" : "FRQ";
+                const cmd = `${channel}:MDWV ${modType},${freqParam},${frequency}`;
+                await connection.sendCommand(cmd);
+                sent.push(cmd);
+            }
+            if (depth !== undefined) {
+                const cmd = `${channel}:MDWV ${modType},DEPTH,${depth}`;
+                await connection.sendCommand(cmd);
+                sent.push(cmd);
+            }
+            if (deviation !== undefined) {
+                const cmd = `${channel}:MDWV ${modType},DEVI,${deviation}`;
+                await connection.sendCommand(cmd);
+                sent.push(cmd);
+            }
+            if (hop_frequency !== undefined) {
+                const cmd = `${channel}:MDWV FSK,HFRQ,${hop_frequency}`;
+                await connection.sendCommand(cmd);
+                sent.push(cmd);
+            }
+            if (polarity) {
+                const cmd = `${channel}:MDWV PSK,PLRT,${polarity}`;
+                await connection.sendCommand(cmd);
+                sent.push(cmd);
+            }
+            // 4. Set carrier parameters
+            if (carrier_waveform) {
+                const cmd = `${channel}:MDWV CARR,WVTP,${carrier_waveform}`;
+                await connection.sendCommand(cmd);
+                sent.push(cmd);
+            }
+            if (carrier_frequency !== undefined) {
+                const cmd = `${channel}:MDWV CARR,FRQ,${carrier_frequency}`;
+                await connection.sendCommand(cmd);
+                sent.push(cmd);
+            }
+            if (carrier_amplitude !== undefined) {
+                const cmd = `${channel}:MDWV CARR,AMP,${carrier_amplitude}`;
+                await connection.sendCommand(cmd);
+                sent.push(cmd);
+            }
+            if (carrier_offset !== undefined) {
+                const cmd = `${channel}:MDWV CARR,OFST,${carrier_offset}`;
+                await connection.sendCommand(cmd);
+                sent.push(cmd);
+            }
+            if (carrier_phase !== undefined) {
+                const cmd = `${channel}:MDWV CARR,PHSE,${carrier_phase}`;
+                await connection.sendCommand(cmd);
+                sent.push(cmd);
+            }
+            if (sent.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Error: At least one parameter must be specified.",
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Modulation configured:\n${sent.join("\n")}`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=modulation.js.map

package/build/tools/output.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerOutputTools(server: McpServer): void;

package/build/tools/output.js

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { connection } from "../connection.js";
+export function registerOutputTools(server) {
+    server.tool("get_output", "Get the output state of a channel, including on/off status, load impedance, and polarity.", {
+        channel: z.enum(["C1", "C2"]).describe("Channel to query"),
+    }, { readOnlyHint: true }, async ({ channel }) => {
+        try {
+            const response = await connection.query(`${channel}:OUTP?`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: response,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("configure_output", "Configure the output of a channel. Can turn output on/off, set load impedance, and set polarity.", {
+        channel: z.enum(["C1", "C2"]).describe("Channel to configure"),
+        state: z
+            .enum(["ON", "OFF"])
+            .optional()
+            .describe("Output state: ON or OFF"),
+        load: z
+            .string()
+            .optional()
+            .describe("Load impedance in ohms (50-100000) or 'HZ' for high impedance"),
+        polarity: z
+            .enum(["NOR", "INVT"])
+            .optional()
+            .describe("Output polarity: NOR (normal) or INVT (inverted)"),
+    }, { readOnlyHint: false }, async ({ channel, state, load, polarity }) => {
+        try {
+            const parts = [];
+            if (state)
+                parts.push(state);
+            if (load)
+                parts.push(`LOAD,${load}`);
+            if (polarity)
+                parts.push(`PLRT,${polarity}`);
+            if (parts.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Error: At least one parameter (state, load, polarity) must be specified.",
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            await connection.sendCommand(`${channel}:OUTP ${parts.join(",")}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Output configured: ${channel}:OUTP ${parts.join(",")}`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=output.js.map

package/build/tools/scpi.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerScpiTools(server: McpServer): void;

package/build/tools/scpi.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { connection } from "../connection.js";
+export function registerScpiTools(server) {
+    server.tool("scpi_query", "Send an arbitrary SCPI query to the waveform generator and return the response. Use this as an escape hatch for commands not covered by other tools. Note: CHDR is set to OFF, so responses contain only values (no headers).", {
+        command: z
+            .string()
+            .describe("SCPI query command to send (e.g. '*IDN?', 'C1:BSWV?', 'C1:OUTP?')"),
+        timeout_ms: z
+            .number()
+            .optional()
+            .describe("Timeout in milliseconds (default 5000)"),
+    }, { readOnlyHint: true }, async ({ command, timeout_ms }) => {
+        try {
+            const response = await connection.query(command, timeout_ms || undefined);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: response,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("scpi_command", "Send an arbitrary SCPI command to the waveform generator (no response expected). Use this as an escape hatch for commands not covered by other tools.", {
+        command: z
+            .string()
+            .describe("SCPI command to send (e.g. '*RST', 'C1:OUTP ON', 'C1:BSWV WVTP,SINE')"),
+    }, { readOnlyHint: false }, async ({ command }) => {
+        try {
+            await connection.sendCommand(command);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Command sent: ${command}`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=scpi.js.map

package/build/tools/sweep.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerSweepTools(server: McpServer): void;