如何解决Node.js SerialPort包Promise导致的Arduino端口检测问题

Hey there! I see the issue you're running into—your current tryPort function isn't properly wrapping the asynchronous SerialPort logic in a Promise, so await tryPort(...) isn't actually waiting for the response from the Arduino. Let's break down how to fix this.

The Core Problem #

Right now, tryPort doesn't return a Promise that resolves when you get the "c" response. The return port inside the data callback doesn't propagate up to the await in your loop, because that callback runs asynchronously outside the Promise context. Also, your loop is just assigning connection to each port's result in sequence, but without waiting for a valid response, it ends up overwriting the value before you get a chance to check.

A Working Solution #

Let's refactor tryPort to be a proper Promise-based function that resolves only when it gets the expected "c" response, or rejects if there's an error, timeout, or no valid response. We'll also add a timeout to prevent hanging on unresponsive ports.

Here's the revised code:

const SerialPort = require('serialport');
const Readline = require('@serialport/parser-readline');

async function tryPort(path) {
  return new Promise((resolve, reject) => {
    const port = new SerialPort(path, { baudRate: 9600, autoOpen: false }); // Disable auto-open to handle it manually
    const parser = port.pipe(new Readline({ delimiter: '\n' }));
    const timeoutId = setTimeout(() => {
      port.close();
      reject(new Error(`Port ${path} timed out waiting for response`));
    }, 2000); // 2-second timeout to avoid hanging

    // Handle port open event (Arduino might reboot when port opens, so we wait for this before writing)
    port.open((err) => {
      if (err) {
        clearTimeout(timeoutId);
        reject(err);
        return;
      }

      // Write the "c" command once the port is open
      port.write('c', (err) => {
        if (err) {
          clearTimeout(timeoutId);
          port.close();
          reject(err);
        }
      });
    });

    // Listen for incoming data
    parser.on('data', (data) => {
      const trimmedData = data.trim(); // Clean up any whitespace/newlines
      if (trimmedData === 'c') {
        clearTimeout(timeoutId);
        resolve(port); // Resolve with the working port
      } else {
        // Not the response we want—close the port and reject
        clearTimeout(timeoutId);
        port.close();
        reject(new Error(`Port ${path} returned unexpected data: ${trimmedData}`));
      }
    });

    // Handle port errors
    port.on('error', (err) => {
      clearTimeout(timeoutId);
      reject(err);
    });

    // Handle port close (in case it closes unexpectedly)
    port.on('close', () => {
      clearTimeout(timeoutId);
      reject(new Error(`Port ${path} closed unexpectedly`));
    });
  });
}

async function connect() {
  let connection;
  const ports = await SerialPort.list();

  // Try ports one by one until we find a working one
  for (const portInfo of ports) {
    try {
      console.log(`Testing port ${portInfo.path}...`);
      connection = await tryPort(portInfo.path);
      console.log(`Successfully connected to ${portInfo.path}`);
      break; // Stop testing once we find a valid port
    } catch (err) {
      console.log(`Port ${portInfo.path} failed: ${err.message}`);
    }
  }

  if (!connection) {
    console.log("No port with valid 'c' response found");
  } else {
    // Use the connection here—e.g., listen for more data, send to remote server
    connection.on('data', (data) => {
      console.log(`Received from Arduino: ${data}`);
      // Add your HTTP/Socket logic here to send data to remote server
    });
  }
}

connect();

Key Improvements #

• Proper Promise Wrapping: tryPort now returns a Promise that resolves only when it gets the correct "c" response, making await work as expected.
• Timeout Handling: Each port test times out after 2 seconds, so we don't hang on unresponsive devices.
• Manual Port Opening: We disable autoOpen to wait for the port to fully open before sending the "c" command—this avoids issues where Arduino reboots when the port is opened.
• Sequential Port Testing: We loop through ports one by one and stop at the first valid one, which is more efficient than testing all ports at once.
• Clean Resource Management: We always close ports and clear timeouts on error/timeout to avoid resource leaks.

Additional Tips #

• If you want to test multiple ports in parallel (faster but more complex), you could use Promise.allSettled to run all tryPort calls at once, then filter the results for successful connections.
• Arduino boards often reset when the serial port is opened—you might need to add a small delay (e.g., 1000ms) after opening the port before sending the "c" command if you're getting no response. You can add this inside the port.open callback with setTimeout(() => port.write('c'), 1000);.

内容的提问来源于stack exchange，提问作者G.Baldjiev