Spaces:

blanchon
/

RobotHub-Frontend

Running

File size: 27,192 Bytes

6ce4ca6

<!doctype html>
<html lang="en">
	<head>
		<meta charset="UTF-8" />
		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
		<title>Feetech Servo Test</title>
		<style>
			body {
				font-family: sans-serif;
				line-height: 1.6;
				padding: 20px;
			}
			.container {
				max-width: 800px;
				margin: auto;
			}
			.section {
				border: 1px solid #ccc;
				padding: 15px;
				margin-bottom: 20px;
				border-radius: 5px;
			}
			h2 {
				margin-top: 0;
			}
			label {
				display: inline-block;
				min-width: 100px;
				margin-bottom: 5px;
			}
			input[type="number"],
			input[type="text"] {
				width: 100px;
				padding: 5px;
				margin-right: 10px;
				margin-bottom: 10px;
			}
			button {
				padding: 8px 15px;
				margin-right: 10px;
				cursor: pointer;
			}
			pre {
				background-color: #f4f4f4;
				padding: 10px;
				border: 1px solid #ddd;
				border-radius: 3px;
				white-space: pre-wrap;
				word-wrap: break-word;
			}
			.status {
				font-weight: bold;
			}
			.success {
				color: green;
			}
			.error {
				color: red;
			}
			.log-area {
				margin-top: 10px;
			}
		</style>
	</head>
	<body>
		<div class="container">
			<h1>Feetech Servo Test Page</h1>

			<details class="section">
				<summary>Key Concepts</summary>
				<p>Understanding these parameters is crucial for controlling Feetech servos:</p>
				<ul>
					<li>
						<strong>Mode:</strong> Determines the servo's primary function.
						<ul>
							<li>
								<code>Mode 0</code>: Position/Servo Mode. The servo moves to and holds a specific
								angular position.
							</li>
							<li>
								<code>Mode 1</code>: Wheel/Speed Mode. The servo rotates continuously at a specified
								speed and direction, like a motor.
							</li>
						</ul>
						Changing the mode requires unlocking, writing the mode value (0 or 1), and locking the
						configuration.
					</li>
					<li>
						<strong>Position:</strong> In Position Mode (Mode 0), this value represents the target
						or current angular position of the servo's output shaft.
						<ul>
							<li>
								Range: Typically <code>0</code> to <code>4095</code> (representing a 12-bit
								resolution).
							</li>
							<li>
								Meaning: Corresponds to the servo's rotational range (e.g., 0-360 degrees or 0-270
								degrees, depending on the specific servo model). <code>0</code> is one end of the
								range, <code>4095</code> is the other.
							</li>
						</ul>
					</li>
					<li>
						<strong>Speed (Wheel Mode):</strong> In Wheel Mode (Mode 1), this value controls the
						rotational speed and direction.
						<ul>
							<li>
								Range: Typically <code>-2500</code> to <code>+2500</code>. (Note: Some documentation
								might mention -1023 to +1023, but the SDK example uses a wider range).
							</li>
							<li>
								Meaning: <code>0</code> stops the wheel. Positive values rotate in one direction
								(e.g., clockwise), negative values rotate in the opposite direction (e.g.,
								counter-clockwise). The magnitude determines the speed (larger absolute value means
								faster rotation).
							</li>
							<li>Control Address: <code>ADDR_SCS_GOAL_SPEED</code> (Register 46/47).</li>
						</ul>
					</li>
					<li>
						<strong>Acceleration:</strong> Controls how quickly the servo changes speed to reach its
						target position (in Position Mode) or target speed (in Wheel Mode).
						<ul>
							<li>Range: Typically <code>0</code> to <code>254</code>.</li>
							<li>
								Meaning: Defines the rate of change of speed. The unit is 100 steps/s².
								<code>0</code> usually means instantaneous acceleration (or minimal delay). Higher
								values result in slower, smoother acceleration and deceleration. For example, a
								value of <code>10</code> means the speed changes by 10 * 100 = 1000 steps per
								second, per second. This helps reduce jerky movements and mechanical stress.
							</li>
							<li>Control Address: <code>ADDR_SCS_GOAL_ACC</code> (Register 41).</li>
						</ul>
					</li>
					<li>
						<strong>Baud Rate:</strong> The speed of communication between the controller and the
						servo. It must match on both ends. Servos often support multiple baud rates, selectable
						via an index:
						<ul>
							<li>Index 0: 1,000,000 bps</li>
							<li>Index 1: 500,000 bps</li>
							<li>Index 2: 250,000 bps</li>
							<li>Index 3: 128,000 bps</li>
							<li>Index 4: 115,200 bps</li>
							<li>Index 5: 76,800 bps</li>
							<li>Index 6: 57,600 bps</li>
							<li>Index 7: 38,400 bps</li>
						</ul>
					</li>
				</ul>
			</details>

			<div class="section">
				<h2>Connection</h2>
				<button id="connectBtn">Connect</button>
				<button id="disconnectBtn">Disconnect</button>
				<p>Status: <span id="connectionStatus" class="status error">Disconnected</span></p>
				<label for="baudRate">Baud Rate:</label>
				<input type="number" id="baudRate" value="1000000" />
				<label for="protocolEnd">Protocol End (0=STS/SMS, 1=SCS):</label>
				<input type="number" id="protocolEnd" value="0" min="0" max="1" />
			</div>

			<div class="section">
				<h2>Scan Servos</h2>
				<label for="scanStartId">Start ID:</label>
				<input type="number" id="scanStartId" value="1" min="1" max="252" />
				<label for="scanEndId">End ID:</label>
				<input type="number" id="scanEndId" value="15" min="1" max="252" />
				<button id="scanServosBtn">Scan</button>
				<p>Scan Results:</p>
				<pre id="scanResultsOutput" style="max-height: 200px; overflow-y: auto"></pre>
				<!-- Added element for results -->
			</div>

			<div class="section">
				<h2>Single Servo Control</h2>
				<label for="servoId">Servo ID:</label>
				<input type="number" id="servoId" value="1" min="1" max="252" /><br />

				<label for="idWrite">Change servo ID:</label>
				<input type="number" id="idWrite" value="1" min="1" max="252" />
				<button id="writeIdBtn">Write</button><br />

				<label for="baudRead">Read Baud Rate:</label>
				<button id="readBaudBtn">Read</button>
				<span id="readBaudResult"></span><br />

				<label for="baudWrite">Write Baud Rate Index:</label>
				<input type="number" id="baudWrite" value="6" min="0" max="7" />
				<!-- Assuming index 0-7 -->
				<button id="writeBaudBtn">Write</button><br />

				<label for="positionRead">Read Position:</label>
				<button id="readPosBtn">Read</button>
				<span id="readPosResult"></span><br />

				<label for="positionWrite">Write Position:</label>
				<input type="number" id="positionWrite" value="1000" min="0" max="4095" />
				<button id="writePosBtn">Write</button><br />

				<label for="torqueEnable">Torque:</label>
				<button id="torqueEnableBtn">Enable</button>
				<button id="torqueDisableBtn">Disable</button><br />

				<label for="accelerationWrite">Write Acceleration:</label>
				<input type="number" id="accelerationWrite" value="50" min="0" max="254" />
				<button id="writeAccBtn">Write</button><br />

				<label for="wheelMode">Wheel Mode:</label>
				<button id="setWheelModeBtn">Set Wheel Mode</button>
				<button id="removeWheelModeBtn">Set Position Mode</button><br />

				<label for="wheelSpeedWrite">Write Wheel Speed:</label>
				<input type="number" id="wheelSpeedWrite" value="0" min="-2500" max="2500" />
				<button id="writeWheelSpeedBtn">Write Speed</button>
			</div>

			<div class="section">
				<h2>Sync Operations</h2>
				<label for="syncReadIds">Sync Read IDs (csv):</label>
				<input type="text" id="syncReadIds" value="1,2,3" style="width: 150px" />
				<button id="syncReadBtn">Sync Read Positions</button><br />

				<label for="syncWriteData">Sync Write (id:pos,...):</label>
				<input type="text" id="syncWriteData" value="1:1500,2:2500" style="width: 200px" />
				<button id="syncWriteBtn">Sync Write Positions</button><br />

				<label for="syncWriteSpeedData">Sync Write Speed (id:speed,...):</label>
				<input type="text" id="syncWriteSpeedData" value="1:500,2:-1000" style="width: 200px" />
				<button id="syncWriteSpeedBtn">Sync Write Speeds</button>
				<!-- New Button -->
			</div>

			<div class="section">
				<h2>Log Output</h2>
				<pre id="logOutput"></pre>
			</div>
		</div>

		<script type="module">
			// Import the scsServoSDK object from index.mjs
			import { scsServoSDK } from "./index.mjs";
			// No longer need COMM_SUCCESS etc. here as errors are thrown

			const connectBtn = document.getElementById("connectBtn");
			const disconnectBtn = document.getElementById("disconnectBtn");
			const connectionStatus = document.getElementById("connectionStatus");
			const baudRateInput = document.getElementById("baudRate");
			const protocolEndInput = document.getElementById("protocolEnd");

			const servoIdInput = document.getElementById("servoId");
			const readIdBtn = document.getElementById("readIdBtn"); // New
			const readIdResult = document.getElementById("readIdResult"); // New
			const idWriteInput = document.getElementById("idWrite"); // New
			const writeIdBtn = document.getElementById("writeIdBtn"); // New
			const readBaudBtn = document.getElementById("readBaudBtn"); // New
			const readBaudResult = document.getElementById("readBaudResult"); // New
			const baudWriteInput = document.getElementById("baudWrite"); // New
			const writeBaudBtn = document.getElementById("writeBaudBtn"); // New
			const readPosBtn = document.getElementById("readPosBtn");
			const readPosResult = document.getElementById("readPosResult");
			const positionWriteInput = document.getElementById("positionWrite");
			const writePosBtn = document.getElementById("writePosBtn");
			const torqueEnableBtn = document.getElementById("torqueEnableBtn");
			const torqueDisableBtn = document.getElementById("torqueDisableBtn");
			const accelerationWriteInput = document.getElementById("accelerationWrite");
			const writeAccBtn = document.getElementById("writeAccBtn");
			const setWheelModeBtn = document.getElementById("setWheelModeBtn");
			const removeWheelModeBtn = document.getElementById("removeWheelModeBtn"); // Get reference to the new button
			const wheelSpeedWriteInput = document.getElementById("wheelSpeedWrite");
			const writeWheelSpeedBtn = document.getElementById("writeWheelSpeedBtn");

			const syncReadIdsInput = document.getElementById("syncReadIds");
			const syncReadBtn = document.getElementById("syncReadBtn");
			const syncWriteDataInput = document.getElementById("syncWriteData");
			const syncWriteBtn = document.getElementById("syncWriteBtn");
			const syncWriteSpeedDataInput = document.getElementById("syncWriteSpeedData"); // New Input
			const syncWriteSpeedBtn = document.getElementById("syncWriteSpeedBtn"); // New Button
			const scanServosBtn = document.getElementById("scanServosBtn"); // Get reference to the scan button
			const scanStartIdInput = document.getElementById("scanStartId"); // Get reference to start ID input
			const scanEndIdInput = document.getElementById("scanEndId"); // Get reference to end ID input
			const scanResultsOutput = document.getElementById("scanResultsOutput"); // Get reference to the new results area

			const logOutput = document.getElementById("logOutput");

			let isConnected = false;

			function log(message) {
				console.log(message);
				const timestamp = new Date().toLocaleTimeString();
				logOutput.textContent = `[${timestamp}] ${message}\n` + logOutput.textContent;
				// Limit log size
				const lines = logOutput.textContent.split("\n"); // Use '\n' instead of literal newline
				if (lines.length > 50) {
					logOutput.textContent = lines.slice(0, 50).join("\n"); // Use '\n' instead of literal newline
				}
			}

			function updateConnectionStatus(connected, message) {
				isConnected = connected;
				connectionStatus.textContent = message || (connected ? "Connected" : "Disconnected");
				connectionStatus.className = `status ${connected ? "success" : "error"}`;
				log(`Connection status: ${connectionStatus.textContent}`);
			}

			connectBtn.onclick = async () => {
				log("Attempting to connect...");
				try {
					const baudRate = parseInt(baudRateInput.value, 10);
					const protocolEnd = parseInt(protocolEndInput.value, 10);
					// Use scsServoSDK - throws on error
					await scsServoSDK.connect({ baudRate, protocolEnd });
					updateConnectionStatus(true, "Connected");
				} catch (err) {
					updateConnectionStatus(false, `Connection error: ${err.message}`);
					console.error(err);
				}
			};

			disconnectBtn.onclick = async () => {
				log("Attempting to disconnect...");
				try {
					// Use scsServoSDK - throws on error
					await scsServoSDK.disconnect();
					updateConnectionStatus(false, "Disconnected"); // Success means disconnected
				} catch (err) {
					// Assuming disconnect might fail if already disconnected or other issues
					updateConnectionStatus(false, `Disconnection error: ${err.message}`);
					console.error(err);
				}
			};

			writeIdBtn.onclick = async () => {
				// New handler
				if (!isConnected) {
					log("Error: Not connected");
					return;
				}
				const currentId = parseInt(servoIdInput.value, 10);
				const newId = parseInt(idWriteInput.value, 10);
				if (isNaN(newId) || newId < 1 || newId > 252) {
					log(`Error: Invalid new ID ${newId}. Must be between 1 and 252.`);
					return;
				}
				log(`Writing new ID ${newId} to servo ${currentId}...`);
				try {
					// Use scsServoSDK - throws on error
					await scsServoSDK.setServoId(currentId, newId);
					log(`Successfully wrote new ID ${newId} to servo (was ${currentId}).`);
					// IMPORTANT: Update the main ID input to reflect the change
					servoIdInput.value = newId;
					log(`Servo ID input field updated to ${newId}.`);
				} catch (err) {
					log(`Error writing ID for servo ${currentId}: ${err.message}`);
					console.error(err);
				}
			};

			readBaudBtn.onclick = async () => {
				// New handler
				if (!isConnected) {
					log("Error: Not connected");
					return;
				}
				const id = parseInt(servoIdInput.value, 10);
				log(`Reading Baud Rate Index for servo ${id}...`);
				readBaudResult.textContent = "Reading...";
				try {
					// Use scsServoSDK - returns value directly or throws
					const baudRateIndex = await scsServoSDK.readBaudRate(id);
					readBaudResult.textContent = `Baud Index: ${baudRateIndex}`;
					log(`Servo ${id} Baud Rate Index: ${baudRateIndex}`);
				} catch (err) {
					readBaudResult.textContent = `Error: ${err.message}`;
					log(`Error reading Baud Rate Index for servo ${id}: ${err.message}`);
					console.error(err);
				}
			};

			writeBaudBtn.onclick = async () => {
				// New handler
				if (!isConnected) {
					log("Error: Not connected");
					return;
				}
				const id = parseInt(servoIdInput.value, 10);
				const newBaudIndex = parseInt(baudWriteInput.value, 10);
				if (isNaN(newBaudIndex) || newBaudIndex < 0 || newBaudIndex > 7) {
					// Adjust max index if needed
					log(`Error: Invalid new Baud Rate Index ${newBaudIndex}. Check valid range.`);
					return;
				}
				log(`Writing new Baud Rate Index ${newBaudIndex} to servo ${id}...`);
				try {
					// Use scsServoSDK - throws on error
					await scsServoSDK.setBaudRate(id, newBaudIndex);
					log(`Successfully wrote new Baud Rate Index ${newBaudIndex} to servo ${id}.`);
					log(
						`IMPORTANT: You may need to disconnect and reconnect with the new baud rate if it differs from the current connection baud rate.`
					);
				} catch (err) {
					log(`Error writing Baud Rate Index for servo ${id}: ${err.message}`);
					console.error(err);
				}
			};

			readPosBtn.onclick = async () => {
				if (!isConnected) {
					log("Error: Not connected");
					return;
				}
				const id = parseInt(servoIdInput.value, 10);
				log(`Reading position for servo ${id}...`);
				readPosResult.textContent = "Reading...";
				try {
					// Use scsServoSDK - returns value directly or throws
					const position = await scsServoSDK.readPosition(id);
					readPosResult.textContent = `Position: ${position}`;
					log(`Servo ${id} position: ${position}`);
				} catch (err) {
					readPosResult.textContent = `Error: ${err.message}`;
					log(`Error reading position for servo ${id}: ${err.message}`);
					console.error(err);
				}
			};

			writePosBtn.onclick = async () => {
				if (!isConnected) {
					log("Error: Not connected");
					return;
				}
				const id = parseInt(servoIdInput.value, 10);
				const pos = parseInt(positionWriteInput.value, 10);
				log(`Writing position ${pos} to servo ${id}...`);
				try {
					// Use scsServoSDK - throws on error
					await scsServoSDK.writePosition(id, pos);
					log(`Successfully wrote position ${pos} to servo ${id}.`);
				} catch (err) {
					log(`Error writing position for servo ${id}: ${err.message}`);
					console.error(err);
				}
			};

			torqueEnableBtn.onclick = async () => {
				if (!isConnected) {
					log("Error: Not connected");
					return;
				}
				const id = parseInt(servoIdInput.value, 10);
				log(`Enabling torque for servo ${id}...`);
				try {
					// Use scsServoSDK - throws on error
					await scsServoSDK.writeTorqueEnable(id, true);
					log(`Successfully enabled torque for servo ${id}.`);
				} catch (err) {
					log(`Error enabling torque for servo ${id}: ${err.message}`);
					console.error(err);
				}
			};

			torqueDisableBtn.onclick = async () => {
				if (!isConnected) {
					log("Error: Not connected");
					return;
				}
				const id = parseInt(servoIdInput.value, 10);
				log(`Disabling torque for servo ${id}...`);
				try {
					// Use scsServoSDK - throws on error
					await scsServoSDK.writeTorqueEnable(id, false);
					log(`Successfully disabled torque for servo ${id}.`);
				} catch (err) {
					log(`Error disabling torque for servo ${id}: ${err.message}`);
					console.error(err);
				}
			};

			writeAccBtn.onclick = async () => {
				if (!isConnected) {
					log("Error: Not connected");
					return;
				}
				const id = parseInt(servoIdInput.value, 10);
				const acc = parseInt(accelerationWriteInput.value, 10);
				log(`Writing acceleration ${acc} to servo ${id}...`);
				try {
					// Use scsServoSDK - throws on error
					await scsServoSDK.writeAcceleration(id, acc);
					log(`Successfully wrote acceleration ${acc} to servo ${id}.`);
				} catch (err) {
					log(`Error writing acceleration for servo ${id}: ${err.message}`);
					console.error(err);
				}
			};

			setWheelModeBtn.onclick = async () => {
				if (!isConnected) {
					log("Error: Not connected");
					return;
				}
				const id = parseInt(servoIdInput.value, 10);
				log(`Setting servo ${id} to wheel mode...`);
				try {
					// Use scsServoSDK - throws on error
					await scsServoSDK.setWheelMode(id);
					log(`Successfully set servo ${id} to wheel mode.`);
				} catch (err) {
					log(`Error setting wheel mode for servo ${id}: ${err.message}`);
					console.error(err);
				}
			};

			// Add event listener for the new button
			removeWheelModeBtn.onclick = async () => {
				if (!isConnected) {
					log("Error: Not connected");
					return;
				}
				const id = parseInt(servoIdInput.value, 10);
				log(`Setting servo ${id} back to position mode...`);
				try {
					// Use scsServoSDK - throws on error
					await scsServoSDK.setPositionMode(id);
					log(`Successfully set servo ${id} back to position mode.`);
				} catch (err) {
					log(`Error setting position mode for servo ${id}: ${err.message}`);
					console.error(err);
				}
			};

			writeWheelSpeedBtn.onclick = async () => {
				if (!isConnected) {
					log("Error: Not connected");
					return;
				}
				const id = parseInt(servoIdInput.value, 10);
				const speed = parseInt(wheelSpeedWriteInput.value, 10);
				log(`Writing wheel speed ${speed} to servo ${id}...`);
				try {
					// Use scsServoSDK - throws on error
					await scsServoSDK.writeWheelSpeed(id, speed);
					log(`Successfully wrote wheel speed ${speed} to servo ${id}.`);
				} catch (err) {
					log(`Error writing wheel speed for servo ${id}: ${err.message}`);
					console.error(err);
				}
			};

			syncReadBtn.onclick = async () => {
				if (!isConnected) {
					log("Error: Not connected");
					return;
				}
				const idsString = syncReadIdsInput.value;
				const ids = idsString
					.split(",")
					.map((s) => parseInt(s.trim(), 10))
					.filter((id) => !isNaN(id) && id > 0 && id < 253);
				if (ids.length === 0) {
					log("Sync Read: No valid servo IDs provided.");
					return;
				}
				log(`Sync reading positions for servos: ${ids.join(", ")}...`);
				try {
					// Use scsServoSDK - returns Map or throws
					const positions = await scsServoSDK.syncReadPositions(ids);
					let logMsg = "Sync Read Successful:\n";
					positions.forEach((pos, id) => {
						logMsg += `  Servo ${id}: Position=${pos}\n`;
					});
					log(logMsg.trim());
				} catch (err) {
					log(`Sync Read Failed: ${err.message}`);
					console.error(err);
				}
			};

			syncWriteBtn.onclick = async () => {
				if (!isConnected) {
					log("Error: Not connected");
					return;
				}
				const dataString = syncWriteDataInput.value;
				const positionMap = new Map();
				const pairs = dataString.split(",");
				let validData = false;

				pairs.forEach((pair) => {
					const parts = pair.split(":");
					if (parts.length === 2) {
						const id = parseInt(parts[0].trim(), 10);
						const pos = parseInt(parts[1].trim(), 10);
						// Position validation (0-4095)
						if (!isNaN(id) && id > 0 && id < 253 && !isNaN(pos) && pos >= 0 && pos <= 4095) {
							positionMap.set(id, pos);
							validData = true;
						} else {
							log(
								`Sync Write Position: Invalid data pair "${pair}". ID (1-252), Pos (0-4095). Skipping.`
							);
						}
					} else {
						log(`Sync Write Position: Invalid format "${pair}". Skipping.`);
					}
				});

				if (!validData) {
					log("Sync Write Position: No valid servo position data provided.");
					return;
				}

				log(
					`Sync writing positions: ${Array.from(positionMap.entries())
						.map(([id, pos]) => `${id}:${pos}`)
						.join(", ")}...`
				);
				try {
					// Use scsServoSDK - throws on error
					await scsServoSDK.syncWritePositions(positionMap);
					log(`Sync write position command sent successfully.`);
				} catch (err) {
					log(`Sync Write Position Failed: ${err.message}`);
					console.error(err);
				}
			};

			// New handler for Sync Write Speed
			syncWriteSpeedBtn.onclick = async () => {
				if (!isConnected) {
					log("Error: Not connected");
					return;
				}
				const dataString = syncWriteSpeedDataInput.value;
				const speedMap = new Map();
				const pairs = dataString.split(",");
				let validData = false;

				pairs.forEach((pair) => {
					const parts = pair.split(":");
					if (parts.length === 2) {
						const id = parseInt(parts[0].trim(), 10);
						const speed = parseInt(parts[1].trim(), 10);
						// Speed validation (-10000 to 10000)
						if (
							!isNaN(id) &&
							id > 0 &&
							id < 253 &&
							!isNaN(speed) &&
							speed >= -10000 &&
							speed <= 10000
						) {
							speedMap.set(id, speed);
							validData = true;
						} else {
							log(
								`Sync Write Speed: Invalid data pair "${pair}". ID (1-252), Speed (-10000 to 10000). Skipping.`
							);
						}
					} else {
						log(`Sync Write Speed: Invalid format "${pair}". Skipping.`);
					}
				});

				if (!validData) {
					log("Sync Write Speed: No valid servo speed data provided.");
					return;
				}

				log(
					`Sync writing speeds: ${Array.from(speedMap.entries())
						.map(([id, speed]) => `${id}:${speed}`)
						.join(", ")}...`
				);
				try {
					// Use scsServoSDK - throws on error
					await scsServoSDK.syncWriteWheelSpeed(speedMap);
					log(`Sync write speed command sent successfully.`);
				} catch (err) {
					log(`Sync Write Speed Failed: ${err.message}`);
					console.error(err);
				}
			};

			scanServosBtn.onclick = async () => {
				if (!isConnected) {
					log("Error: Not connected");
					return;
				}

				const startId = parseInt(scanStartIdInput.value, 10);
				const endId = parseInt(scanEndIdInput.value, 10);

				if (isNaN(startId) || isNaN(endId) || startId < 1 || endId > 252 || startId > endId) {
					const errorMsg =
						"Error: Invalid scan ID range. Please enter values between 1 and 252, with Start ID <= End ID.";
					log(errorMsg);
					scanResultsOutput.textContent = errorMsg; // Show error in results area too
					return;
				}

				const startMsg = `Starting servo scan (IDs ${startId}-${endId})...`;
				log(startMsg);
				scanResultsOutput.textContent = startMsg + "\n"; // Clear and start results area
				scanServosBtn.disabled = true; // Disable button during scan

				let foundCount = 0;

				for (let id = startId; id <= endId; id++) {
					let resultMsg = `Scanning ID ${id}... `;
					try {
						// Attempt to read position. If it succeeds, the servo exists.
						// If it throws, the servo likely doesn't exist or there's another issue.
						const position = await scsServoSDK.readPosition(id);
						foundCount++;

						// Servo found, now try to read mode and baud rate
						let mode = "ReadError";
						let baudRateIndex = "ReadError";
						try {
							mode = await scsServoSDK.readMode(id);
						} catch (modeErr) {
							log(`  Servo ${id}: Error reading mode: ${modeErr.message}`);
						}
						try {
							baudRateIndex = await scsServoSDK.readBaudRate(id);
						} catch (baudErr) {
							log(`  Servo ${id}: Error reading baud rate: ${baudErr.message}`);
						}

						resultMsg += `FOUND: Pos=${position}, Mode=${mode}, BaudIdx=${baudRateIndex}`;
						log(
							`  Servo ${id} FOUND: Position=${position}, Mode=${mode}, BaudIndex=${baudRateIndex}`
						);
					} catch (err) {
						// Check if the error message indicates a timeout or non-response, which is expected for non-existent IDs
						// This check might need refinement based on the exact error messages thrown by readPosition
						if (
							err.message.includes("timeout") ||
							err.message.includes("No response") ||
							err.message.includes("failed: RX")
						) {
							resultMsg += `No response`;
							// log(`  Servo ${id}: No response`); // Optional: reduce log noise
						} else {
							// Log other unexpected errors
							resultMsg += `Error: ${err.message}`;
							log(`  Servo ${id}: Error during scan: ${err.message}`);
							console.error(`Error scanning servo ${id}:`, err);
						}
					}
					scanResultsOutput.textContent += resultMsg + "\n"; // Append result to the results area
					scanResultsOutput.scrollTop = scanResultsOutput.scrollHeight; // Auto-scroll
					// Optional small delay between scans if needed
					// await new Promise(resolve => setTimeout(resolve, 10));
				}

				const finishMsg = `Servo scan finished. Found ${foundCount} servo(s).`;
				log(finishMsg);
				scanResultsOutput.textContent += finishMsg + "\n"; // Add finish message to results area
				scanResultsOutput.scrollTop = scanResultsOutput.scrollHeight; // Auto-scroll
				scanServosBtn.disabled = false; // Re-enable button
			};

			// Initial log
			log("Test page loaded. Please connect to a servo controller.");
</script>
	</body>
</html>