siglent-sdg-mcp 1.0.0

package/build/tools/sweep.js

@@ -0,0 +1,221 @@
+import { z } from "zod";
+import { connection } from "../connection.js";
+export function registerSweepTools(server) {
+    server.tool("get_sweep", "Get the sweep parameters of a channel, including state, time, start/stop frequencies, sweep mode, direction, trigger source, carrier settings, and marker.", {
+        channel: z.enum(["C1", "C2"]).describe("Channel to query"),
+    }, { readOnlyHint: true }, async ({ channel }) => {
+        try {
+            const response = await connection.query(`${channel}:SWWV?`);
+            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_sweep", "Configure sweep on a channel. State must be set to ON before other parameters. Builds a single SWWV command with all specified parameters.", {
+        channel: z.enum(["C1", "C2"]).describe("Channel to configure"),
+        state: z
+            .enum(["ON", "OFF"])
+            .optional()
+            .describe("Sweep state. Must be ON before setting other params."),
+        time: z
+            .number()
+            .optional()
+            .describe("Sweep time in seconds"),
+        start: z
+            .number()
+            .optional()
+            .describe("Start frequency in Hz"),
+        stop: z
+            .number()
+            .optional()
+            .describe("Stop frequency in Hz"),
+        center: z
+            .number()
+            .optional()
+            .describe("Center frequency in Hz"),
+        span: z
+            .number()
+            .optional()
+            .describe("Frequency span in Hz"),
+        sweep_mode: z
+            .enum(["LINE", "LOG", "STEP"])
+            .optional()
+            .describe("Sweep mode: LINE (linear), LOG (logarithmic), or STEP"),
+        direction: z
+            .enum(["UP", "DOWN", "UP_DOWN"])
+            .optional()
+            .describe("Sweep direction"),
+        trigger_source: z
+            .enum(["EXT", "INT", "MAN"])
+            .optional()
+            .describe("Trigger source: EXT (external), INT (internal), MAN (manual)"),
+        trigger_out: z
+            .enum(["ON", "OFF"])
+            .optional()
+            .describe("Trigger output state"),
+        trigger_edge: z
+            .enum(["RISE", "FALL"])
+            .optional()
+            .describe("Trigger edge (only for EXT or MAN trigger source)"),
+        start_hold_time: z
+            .number()
+            .optional()
+            .describe("Start hold time in seconds (0-300)"),
+        end_hold_time: z
+            .number()
+            .optional()
+            .describe("End hold time in seconds (0-300)"),
+        return_time: z
+            .number()
+            .optional()
+            .describe("Return time in seconds (0-300)"),
+        symmetry: z
+            .number()
+            .optional()
+            .describe("Symmetry in % (0-100) when direction is UP_DOWN"),
+        marker_state: z
+            .enum(["ON", "OFF"])
+            .optional()
+            .describe("Frequency marker state"),
+        marker_frequency: z
+            .number()
+            .optional()
+            .describe("Marker frequency in Hz"),
+        manual_trigger: z
+            .boolean()
+            .optional()
+            .describe("Send a manual trigger (only when trigger source is MAN)"),
+        carrier_waveform: z
+            .enum(["SINE", "SQUARE", "RAMP", "ARB"])
+            .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, time, start, stop, center, span, sweep_mode, direction, trigger_source, trigger_out, trigger_edge, start_hold_time, end_hold_time, return_time, symmetry, marker_state, marker_frequency, manual_trigger, carrier_waveform, carrier_frequency, carrier_amplitude, carrier_offset, carrier_phase, }) => {
+        try {
+            const sent = [];
+            // State must be set first and separately
+            if (state) {
+                const cmd = `${channel}:SWWV STATE,${state}`;
+                await connection.sendCommand(cmd);
+                sent.push(cmd);
+            }
+            // Build remaining parameters as a single command
+            const parts = [];
+            if (time !== undefined)
+                parts.push(`TIME,${time}`);
+            if (start !== undefined)
+                parts.push(`START,${start}`);
+            if (stop !== undefined)
+                parts.push(`STOP,${stop}`);
+            if (center !== undefined)
+                parts.push(`CENTER,${center}`);
+            if (span !== undefined)
+                parts.push(`SPAN,${span}`);
+            if (sweep_mode)
+                parts.push(`SWMD,${sweep_mode}`);
+            if (direction)
+                parts.push(`DIR,${direction}`);
+            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 (start_hold_time !== undefined)
+                parts.push(`STARTTIME,${start_hold_time}`);
+            if (end_hold_time !== undefined)
+                parts.push(`ENDTIME,${end_hold_time}`);
+            if (return_time !== undefined)
+                parts.push(`BACKTIME,${return_time}`);
+            if (symmetry !== undefined)
+                parts.push(`SYM,${symmetry}`);
+            if (marker_state)
+                parts.push(`MARK_STATE,${marker_state}`);
+            if (marker_frequency !== undefined)
+                parts.push(`MARK_FREQ,${marker_frequency}`);
+            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 (parts.length > 0) {
+                const cmd = `${channel}:SWWV ${parts.join(",")}`;
+                await connection.sendCommand(cmd);
+                sent.push(cmd);
+            }
+            // Manual trigger is sent separately
+            if (manual_trigger) {
+                const cmd = `${channel}:SWWV 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: `Sweep configured:\n${sent.join("\n")}`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=sweep.js.map

package/build/tools/utility.d.ts

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

package/build/tools/utility.js

@@ -0,0 +1,126 @@
+import { z } from "zod";
+import { connection } from "../connection.js";
+export function registerUtilityTools(server) {
+    server.tool("reset", "Reset the waveform generator to factory default settings (*RST).", {}, { readOnlyHint: false }, async () => {
+        try {
+            await connection.sendCommand("*RST");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Device reset to factory defaults.",
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("copy_channel", "Copy all parameters from one channel to another.", {
+        source: z.enum(["C1", "C2"]).describe("Source channel to copy from"),
+        destination: z.enum(["C1", "C2"]).describe("Destination channel to copy to"),
+    }, { readOnlyHint: false }, async ({ source, destination }) => {
+        try {
+            if (source === destination) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Error: Source and destination channels must be different.",
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            await connection.sendCommand(`PACP ${destination},${source}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Parameters copied from ${source} to ${destination}.`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("configure_sync", "Configure the sync output signal for a channel.", {
+        channel: z.enum(["C1", "C2"]).describe("Channel to configure"),
+        state: z.enum(["ON", "OFF"]).describe("Sync output state"),
+        type: z
+            .enum(["CH1", "CH2", "MOD_CH1", "MOD_CH2"])
+            .optional()
+            .describe("Sync source type"),
+    }, { readOnlyHint: false }, async ({ channel, state, type }) => {
+        try {
+            let cmd = `${channel}:SYNC ${state}`;
+            if (type) {
+                cmd += `,TYPE,${type}`;
+            }
+            await connection.sendCommand(cmd);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Sync configured: ${cmd}`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("equal_phase", "Synchronize the phase of both channels (EQPHASE). Aligns the phase relationship between C1 and C2.", {}, { readOnlyHint: false }, async () => {
+        try {
+            await connection.sendCommand("EQPHASE");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Phase synchronized between channels.",
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=utility.js.map

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "siglent-sdg-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for Siglent SDG waveform generator control via SCPI over TCP sockets",
+  "type": "module",
+  "main": "build/index.js",
+  "bin": {
+    "siglent-sdg-mcp": "./build/index.js"
+  },
+  "files": [
+    "build/**/*.js",
+    "build/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "start": "node build/index.js",
+    "dev": "tsc && node build/index.js",
+    "inspector": "npx @modelcontextprotocol/inspector node build/index.js",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "siglent",
+    "waveform-generator",
+    "scpi"
+  ],
+  "author": "Magnus Johansson",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/magnusjohansson/siglent-sdg-mcp.git"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}