Serial API

https://github.com/wicg/serial
Admin
Serial API is a web platform specification that enables web pages to request access to and...
Tokens:11,306
Snippets:172
Trust Score:9.2
Update:2 months ago
Show doc for...
Tokens:
Raw
### SerialPort.open()

Source: https://github.com/wicg/serial/blob/main/index.html

Opens the serial port with the specified options.

```APIDOC
## SerialPort.open()

### Description
Opens the serial port for communication using the provided SerialOptions.

### Parameters
- **options** (SerialOptions) - Required - Configuration options for the serial port connection.

### Response
- **Promise<undefined>** - Resolves when the port is successfully opened.
```

--------------------------------

### SerialOptions Dictionary

Source: https://github.com/wicg/serial/blob/main/index.html

Configuration dictionary for defining serial port connection parameters.

```webidl
        dictionary SerialOptions {
          [EnforceRange] required unsigned long baudRate;
          [EnforceRange] octet dataBits = 8;
          [EnforceRange] octet stopBits = 1;
          ParityType parity = "none";
          [EnforceRange] unsigned long bufferSize = 255;
          FlowControlType flowControl = "none";
        };
          
```

--------------------------------

### Run HTML5 Tidy on the specification

Source: https://github.com/wicg/serial/blob/main/CONTRIBUTING.md

Execute this command to clean up the HTML structure of the specification before submitting a pull request.

```Bash
tidy -config tidyconfig.txt -o index.html index.html
```

--------------------------------

### navigator.serial.requestPort()

Source: https://github.com/wicg/serial/blob/main/index.html

Prompts the user to select a serial device for the website to access. This method requires transient user activation, such as a button click.

```APIDOC
## navigator.serial.requestPort()

### Description
Requests permission from the user to access a serial device. The user is presented with a device picker, and the method returns a Promise that resolves with a SerialPort object or rejects if no device is selected.

### Parameters
- **options** (SerialPortRequestOptions) - Optional - An object containing filters to restrict the list of selectable devices.

### Example
```javascript
const port = await navigator.serial.requestPort({ filters: [{ usbVendorId: 0x2341 }] });
```
```

--------------------------------

### Use Transform Streams for Text

Source: https://github.com/wicg/serial/blob/main/EXPLAINER.md

Simplify text handling using TextEncoderStream and TextDecoderStream with pipeTo.

```javascript
const encoder = new TextEncoderStream();
const writableStreamClosed = encoder.readable.pipeTo(port.writable);
const writer = encoder.writable.getWriter();
writer.write("AT");

const decoder = new TextDecoderStream();
const readableStreamClosed = port.readable.pipeTo(decoder.writable);
const reader = decoder.readable.getReader();
const { value, done } = await reader.read();
console.log(value);
// Expected output: OK
```

--------------------------------

### Manage serial ports with getPorts and events

Source: https://github.com/wicg/serial/blob/main/index.html

Retrieves available serial ports on page load and listens for device connection and disconnection events.

```JavaScript
        // Check to see what ports are available when the page loads.
        document.addEventListener('DOMContentLoaded', async () => {
          let ports = await navigator.serial.getPorts();
          // Populate the UI with options for the user to select or
          // automatically connect to devices.
        });

        navigator.serial.addEventListener('connect', e => {
          // Add |e.target| to the UI or automatically connect.
        });

        navigator.serial.addEventListener('disconnect', e => {
          // Remove |e.target| to the UI. If the device was open the
          // disconnection can also be observed as a stream error.
        });
```

--------------------------------

### navigator.serial.getPorts()

Source: https://github.com/wicg/serial/blob/main/index.html

Retrieves a list of serial ports that the website has already been granted permission to access.

```APIDOC
## navigator.serial.getPorts()

### Description
Returns a Promise that resolves with an array of SerialPort objects representing the devices the origin has previously been granted permission to access.

### Example
```javascript
const ports = await navigator.serial.getPorts();
```
```

--------------------------------

### Monitor Serial Device Connection Events

Source: https://github.com/wicg/serial/blob/main/EXPLAINER.md

Handle device availability on page load and listen for connect/disconnect events to update the UI dynamically.

```javascript
// Check to see what ports are available when the page loads.
document.addEventListener('DOMContentLoaded', async () => {
  let ports = await navigator.serial.getPorts();
  // Populate the UI with options for the user to select or automatically
  // connect to devices.
});

navigator.serial.addEventListener('connect', e => {
  // Add |e.target| to the UI or automatically connect.
});

navigator.serial.addEventListener('disconnect', e => {
  // Remove |e.target| from the UI. If the device was open the disconnection can
  // also be observed as a stream error.
});
```

--------------------------------

### SerialPort.getInfo()

Source: https://github.com/wicg/serial/blob/main/index.html

Returns an object containing information about the serial port, such as USB vendor and product IDs or Bluetooth service class IDs.

```APIDOC
## SerialPort.getInfo()

### Description
Returns a SerialPortInfo dictionary containing metadata about the serial port device.

### Response
#### Success Response
- **usbVendorId** (unsigned short) - The 16-bit vendor ID of the USB device, or undefined.
- **usbProductId** (unsigned short) - The 16-bit product ID of the USB device, or undefined.
- **bluetoothServiceClassId** (BluetoothServiceUUID) - The service class UUID for Bluetooth devices, or undefined.
```

--------------------------------

### Handle serial connection via button click

Source: https://github.com/wicg/serial/blob/main/index.html

Attaches an event listener to a button to initiate the serial port request flow, including error handling for user dismissal.

```javascript
        const connectButton = document.getElementById("connect");
        connectButton.addEventListener('click', () => {
          try {
            const port = await navigator.serial.requestPort();
            // Continue connecting to the device attached to |port|.
          } catch (e) {
            // The prompt has been dismissed without selecting a device.
          }
        });
```

--------------------------------

### Close a SerialPort safely

Source: https://github.com/wicg/serial/blob/main/index.html

Demonstrates the recommended pattern for reading from a serial port and closing it by canceling the reader and setting a control flag.

```javascript
        let keepReading = true;
        let reader;

        async function readUntilClosed() {
          while (port.readable && keepReading) {
            reader = port.readable.getReader();
            try {
              while (true) {
                const { value, done } = await reader.read();
                if (done) {
                  // |reader| has been canceled.
                  break;
                }
                // Do something with |value|...
              }
            } catch (error) {
              // Handle |error|...
            } finally {
              reader.releaseLock();
            }
          }

          await port.close();
        }

        const closed = readUntilClosed();

        // Sometime later...
        keepReading = false;
        reader.cancel();
        await closed;
```

--------------------------------

### Open Serial Port

Source: https://github.com/wicg/serial/blob/main/EXPLAINER.md

Open a connection to a serial port with a required baud rate.

```javascript
await port.open({ baudRate: /* pick your baud rate */ });
```

--------------------------------

### Extend Navigator interface for Serial

Source: https://github.com/wicg/serial/blob/main/index.html

Defines the serial attribute on the Navigator interface to enable serial communication in window contexts.

```webidl
    [Exposed=Window, SecureContext]
    partial interface Navigator {
      [SameObject] readonly attribute Serial serial;
    };
```

--------------------------------

### navigator.serial.getPorts()

Source: https://github.com/wicg/serial/blob/main/index.html

Retrieves a list of serial ports that the user has previously granted the site permission to access.

```APIDOC
## navigator.serial.getPorts()

### Description
Returns a Promise that resolves with an array of SerialPort objects representing the ports the site has been granted permission to access.

### Method
Async Method

### Response
- **Promise<Array<SerialPort>>** - A promise that resolves to a sequence of SerialPort objects.
```

--------------------------------

### Define Serial interface

Source: https://github.com/wicg/serial/blob/main/index.html

Outlines the Serial interface, including event handlers for connection changes and methods for port management.

```webidl
    [Exposed=(DedicatedWorker, Window), SecureContext]
    interface Serial : EventTarget {
      attribute EventHandler onconnect;
      attribute EventHandler ondisconnect;
      Promise<sequence<SerialPort>> getPorts();
      [Exposed=Window] Promise<SerialPort> requestPort(optional SerialPortRequestOptions options = {});
    };
```

--------------------------------

### requestPort(options)

Source: https://github.com/wicg/serial/blob/main/index.html

Requests permission from the user to access a serial port, optionally filtered by USB vendor/product IDs or Bluetooth service class IDs.

```APIDOC
## requestPort(options)

### Description
Prompts the user to select a serial port from a list of available ports. The method returns a Promise that resolves with a SerialPort object representing the chosen port.

### Parameters
- **options** (SerialPortRequestOptions) - Optional - An object containing filters to limit the ports shown to the user.

### SerialPortRequestOptions
- **filters** (sequence<SerialPortFilter>) - Optional - A list of filters to match available ports.
- **allowedBluetoothServiceClassIds** (sequence<BluetoothServiceUUID>) - Optional - A list of Bluetooth service class IDs to include in the selection list.

### Response
- **Promise<SerialPort>** - Resolves with the selected SerialPort object, or rejects with a SecurityError or NotFoundError.
```

--------------------------------

### Connect button HTML

Source: https://github.com/wicg/serial/blob/main/index.html

A simple button element used to trigger the serial port request process.

```html
        <button id="connect">Connect</button>
```

--------------------------------

### Read and Write Data

Source: https://github.com/wicg/serial/blob/main/EXPLAINER.md

Use TextEncoder and TextDecoder to send and receive ASCII data via streams.

```javascript
const encoder = new TextEncoder();
const writer = port.writable.getWriter();
writer.write(encoder.encode("AT"));

const decoder = new TextDecoder();
const reader = port.readable.getReader();
const { value, done } = await reader.read();
console.log(decoder.decode(value));
// Expected output: OK
```

--------------------------------

### Define SerialPortRequestOptions dictionary

Source: https://github.com/wicg/serial/blob/main/index.html

The dictionary structure used to specify filters and allowed Bluetooth service class IDs when requesting serial port access.

```webidl
dictionary SerialPortRequestOptions {
  sequence<SerialPortFilter> filters;
  sequence<BluetoothServiceUUID> allowedBluetoothServiceClassIds;
};
```

--------------------------------

### setSignals()

Source: https://github.com/wicg/serial/blob/main/index.html

The setSignals() method allows users to explicitly set the state of serial port signals such as Data Terminal Ready (DTR), Request To Send (RTS), and break.

```APIDOC
## setSignals(signals)

### Description
Sets the state of specified serial port signals. This is useful for device detection and flow control, such as toggling DTR to enter a programming mode on micro-controllers.

### Parameters
#### Request Body
- **signals** (SerialOutputSignals) - Required - An object containing the signals to set.

### SerialOutputSignals Dictionary
- **dataTerminalReady** (boolean) - Optional - Sets the Data Terminal Ready (DTR) signal.
- **requestToSend** (boolean) - Optional - Sets the Request To Send (RTS) signal.
- **break** (boolean) - Optional - Sets the break signal.

### Request Example
```javascript
await port.setSignals({ dataTerminalReady: false, requestToSend: true });
```

### Response
- **Promise<void>** - Resolves when the signals have been updated, or rejects with an InvalidStateError if the port is not open, or a NetworkError if the OS fails to update the signals.
```

--------------------------------

### Toggle DTR signal for micro-controller programming

Source: https://github.com/wicg/serial/blob/main/index.html

Use this pattern to toggle the Data Terminal Ready signal, often required to trigger programming modes on micro-controllers.

```javascript
        await port.setSignals({ dataTerminalReady: false });
        await new Promise(resolve => setTimeout(resolve, 200));
        await port.setSignals({ dataTerminalReady: true });
```

--------------------------------

### Extend WorkerNavigator interface for Serial

Source: https://github.com/wicg/serial/blob/main/index.html

Defines the serial attribute on the WorkerNavigator interface to enable serial communication in dedicated workers.

```webidl
    [Exposed=DedicatedWorker, SecureContext]
    partial interface WorkerNavigator {
      [SameObject] readonly attribute Serial serial;
    };
```

--------------------------------

### SerialPort.getSignals()

Source: https://github.com/wicg/serial/blob/main/index.html

Retrieves the current status of the control signals (DCD, CTS, RI, DSR) from the connected serial device.

```APIDOC
## SerialPort.getSignals()

### Description
Returns a Promise that resolves with a SerialInputSignals object containing the status of the control signals asserted by the device.

### Returns
- **Promise<SerialInputSignals>** - A promise that resolves with the signal states.

### SerialInputSignals Dictionary
- **dataCarrierDetect** (boolean) - Data Carrier Detect (DCD) signal status.
- **clearToSend** (boolean) - Clear To Send (CTS) signal status.
- **ringIndicator** (boolean) - Ring Indicator (RI) signal status.
- **dataSetReady** (boolean) - Data Set Ready (DSR) signal status.
```

--------------------------------

### Define SerialOutputSignals dictionary

Source: https://github.com/wicg/serial/blob/main/index.html

The dictionary structure used to specify which serial output signals to modify.

```webidl
        dictionary SerialOutputSignals {
          boolean dataTerminalReady;
          boolean requestToSend;
          boolean break;
        };
```

--------------------------------

### Read Data Continuously

Source: https://github.com/wicg/serial/blob/main/EXPLAINER.md

Read data from the serial port using a loop.

```javascript
const reader = port.readable.getReader();
while (true) {
  const { value, done } = await reader.read();
  if (done) {
    // |reader| has been canceled.
    break;
  }
  // Do something with |value|...
}
reader.releaseLock();
```

--------------------------------

### Close serial port with TransformStream

Source: https://github.com/wicg/serial/blob/main/index.html

Handles port closure when using a TransformStream by awaiting the pipeTo promise to ensure the pipe chain is fully closed.

```javascript
        const encoder = new TextEncoderStream();
        const writableStreamClosed = encoder.readable.pipeTo(port.writable);
        const writer = encoder.writable.getWriter();
        writer.write("A long message that will take...");
        writer.close();
        await writableStreamClosed;
        await port.close();
```

--------------------------------

### Define SerialInputSignals dictionary

Source: https://github.com/wicg/serial/blob/main/index.html

Defines the structure for serial input signals including DCD, CTS, RI, and DSR.

```webidl
      dictionary SerialInputSignals {
        required boolean dataCarrierDetect;
        required boolean clearToSend;
        required boolean ringIndicator;
        required boolean dataSetReady;
      };
```

--------------------------------

### Define SerialPortFilter dictionary

Source: https://github.com/wicg/serial/blob/main/index.html

Defines the structure for filtering serial ports based on USB or Bluetooth identifiers.

```WebIDL
        dictionary SerialPortFilter {
          unsigned short usbVendorId;
          unsigned short usbProductId;
          BluetoothServiceUUID bluetoothServiceClassId;
        };
```

--------------------------------

### SerialPort.readable

Source: https://github.com/wicg/serial/blob/main/index.html

Provides a ReadableStream for receiving data from the serial port.

```APIDOC
## SerialPort.readable

### Description
Provides a ReadableStream that allows an application to receive data from the serial port. Data is read in chunks using a ReadableStreamDefaultReader.

### Usage
- Access the stream via `port.readable`.
- Use `getReader()` to obtain a reader for the stream.
- Read data chunks using `reader.read()`.
- Release the lock using `reader.releaseLock()` when finished or to interrupt reading.
```

--------------------------------

### Handle Read Errors

Source: https://github.com/wicg/serial/blob/main/EXPLAINER.md

Handle non-fatal read errors by re-initializing the reader when the stream errors.

```javascript
while (port.readable) {
  const reader = port.readable.getReader();
  while (true) {
    let value, done;
    try {
      ({ value, done } = await reader.read());
    } catch (error) {
      // Handle |error|...
      break;
    }
    if (done) {
      // |reader| has been canceled.
      break;
    }
    // Do something with |value|...
  }
  reader.releaseLock();
}
```

--------------------------------

### Close serial port after writing

Source: https://github.com/wicg/serial/blob/main/index.html

Ensures all buffered data is transmitted before closing the port by awaiting the writer's close promise.

```javascript
        const encoder = new TextEncoder();
        const writer = port.writable.getWriter();
        writer.write(encoder.encode("A long message that will take..."));
        await writer.close();
        await port.close();
```

--------------------------------

### Request Serial Port Access

Source: https://github.com/wicg/serial/blob/main/EXPLAINER.md

Request access to a serial device using optional filters to limit selectable devices.

```javascript
const filter = {
  usbVendorId: 0x2341 // Arduino SA
};

try {
  const port = await navigator.serial.requestPort({filters: [filter]});
  // Continue connecting to |port|.
} catch (e) {
  // Permission to access a device was denied implicitly or explicitly by the user.
}
```

--------------------------------

### SerialPort.close()

Source: https://github.com/wicg/serial/blob/main/index.html

Closes the serial port.

```APIDOC
## SerialPort.close()

### Description
Closes the serial port and releases associated resources.

### Response
- **Promise<undefined>** - Resolves when the port is closed.
```

--------------------------------

### SerialPortInfo Dictionary Definition

Source: https://github.com/wicg/serial/blob/main/index.html

Defines the structure for retrieving device-specific information such as USB vendor/product IDs or Bluetooth service UUIDs.

```webidl
      dictionary SerialPortInfo {
        unsigned short usbVendorId;
        unsigned short usbProductId;
        BluetoothServiceUUID bluetoothServiceClassId;
      };
```

--------------------------------

### SerialPort Interface IDL Definition

Source: https://github.com/wicg/serial/blob/main/index.html

Defines the structure of the SerialPort interface, including event handlers, connection state, and stream access.

```webidl
    [Exposed=(DedicatedWorker,Window), SecureContext]
    interface SerialPort : EventTarget {
      attribute EventHandler onconnect;
      attribute EventHandler ondisconnect;
      readonly attribute boolean connected;
      readonly attribute ReadableStream? readable;
      readonly attribute WritableStream? writable;

      SerialPortInfo getInfo();

      Promise<undefined> open(SerialOptions options);
      Promise<undefined> setSignals(optional SerialOutputSignals signals = {});
      Promise<SerialInputSignals> getSignals();
      Promise<undefined> close();
      Promise<undefined> forget();
    };
```

--------------------------------

### Cancel Stream and Close Port

Source: https://github.com/wicg/serial/blob/main/EXPLAINER.md

Cancel the reader to break the loop and allow the port to close.

```javascript
await reader.cancel();
await port.close();
```

--------------------------------

### SerialPortFilter Dictionary

Source: https://github.com/wicg/serial/blob/main/index.html

A dictionary used to filter serial ports based on USB or Bluetooth identifiers.

```APIDOC
## SerialPortFilter

### Description
Defines criteria for filtering serial ports during device selection.

### Parameters
- **usbVendorId** (unsigned short) - Optional - The USB Vendor ID to match.
- **usbProductId** (unsigned short) - Optional - The USB Product ID to match.
- **bluetoothServiceClassId** (BluetoothServiceUUID) - Optional - The Bluetooth service class ID to match.
```

--------------------------------

### SerialPort.connected

Source: https://github.com/wicg/serial/blob/main/index.html

Returns a boolean indicating whether the serial port is currently connected.

```APIDOC
## SerialPort.connected

### Description
Returns a boolean value indicating if the serial port is currently connected.

### Returns
- **connected** (boolean) - True if the port is connected, false otherwise.
```

--------------------------------

### Check Bluetooth Serial Port Connection Status

Source: https://github.com/wicg/serial/blob/main/EXPLAINER_BLUETOOTH.md

Use the SerialPort.connected attribute to verify if a Bluetooth serial port is logically connected before attempting to open it.

```javascript
let ports = await navigator.serial.getPorts();
for (let port of ports) {
  if (port.connected) {
    await port.open({baudRate: 115200});
  } else {
    // Prompt the user to make sure the Bluetooth device is connectable to the system.
    // Once the user thinks the device is ready to connect, the user can press a
    // a button which runs `port.open` to trigger a connection attempt.
  }
}
```

--------------------------------

### Read from serial port with timeout

Source: https://github.com/wicg/serial/blob/main/index.html

Implements a timeout mechanism using releaseLock to interrupt a pending read operation if no data arrives within the specified duration.

```javascript
        async function readWithTimeout(port, timeout) {
          const reader = port.readable.getReader();
          const timer = setTimeout(() => {
            reader.releaseLock();
          }, timeout);
          const result = await reader.read();
          clearTimeout(timer);
          reader.releaseLock();
          return result;
        }
```

--------------------------------

### Request serial port without filter

Source: https://github.com/wicg/serial/blob/main/index.html

Requests access to a serial port without filtering, allowing the user to select from all available devices.

```javascript
        const port = await navigator.serial.requestPort();
```

--------------------------------

### Write data to a serial port

Source: https://github.com/wicg/serial/blob/main/index.html

Uses a TextEncoder to convert a string to a Uint8Array and writes it to the port's writable stream.

```javascript
        const encoder = new TextEncoder();
        const writer = port.writable.getWriter();
        await writer.write(encoder.encode("PING"));
        writer.releaseLock();
```

--------------------------------

### SerialPort.writable

Source: https://github.com/wicg/serial/blob/main/index.html

The writable attribute provides a WritableStream that can be used to send data to the serial port. Users can obtain a writer via getWriter() to transmit data chunks.

```APIDOC
## SerialPort.writable

### Description
The writable attribute returns a WritableStream that allows the application to write data to the serial port. It is recommended to use a WritableStreamDefaultWriter to manage the stream and handle back pressure.

### Usage
```javascript
const encoder = new TextEncoder();
const writer = port.writable.getWriter();
await writer.write(encoder.encode("PING"));
writer.releaseLock();
```

### Notes
- The write() method returns a Promise that resolves when the data has been written.
- Awaiting the write() Promise helps implement back pressure, preventing the application from overwhelming the transmit buffer.
```

--------------------------------

### Toggle Serial Port Signals

Source: https://github.com/wicg/serial/blob/main/EXPLAINER.md

Explicitly set hardware signals like Data Terminal Ready (DTR) to control device modes such as Arduino programming mode.

```javascript
await port.setSignal({ dataTerminalReady: false });
await new Promise(resolve => setTimeout(200, resolve));
await port.setSignal({ dataTerminalReady: true });
```

--------------------------------

### Transform serial data with LineBreakTransformer

Source: https://github.com/wicg/serial/blob/main/index.html

Implements a custom TransformStream to convert raw Uint8Array chunks into lines of text based on newline delimiters.

```javascript
        class LineBreakTransformer {
          constructor() {
            this.container = '';
          }

          transform(chunk, controller) {
            this.container += chunk;
            const lines = this.container.split('\r\n');
            this.container = lines.pop();
            lines.forEach(line => controller.enqueue(line));
          }

          flush(controller) {
            controller.enqueue(this.container);
          }
        }

        const decoder = new TextDecoderStream();
        const streamClosed = port.readable.pipeTo(decoder.writable);
        const lineReader = decoder.readable
            .pipeThrough(new TransformStream(new LineBreakTransformer()))
            .getReader();
```

--------------------------------

### FlowControlType Enum

Source: https://github.com/wicg/serial/blob/main/index.html

Defines the available flow control modes for serial communication.

```webidl
          enum FlowControlType {
            "none",
            "hardware"
          };
            
```

--------------------------------

### ParityType Enum

Source: https://github.com/wicg/serial/blob/main/index.html

Defines the available parity modes for serial communication.

```webidl
          enum ParityType {
            "none",
            "even",
            "odd"
          };
            
```

--------------------------------

### Read data from a serial port

Source: https://github.com/wicg/serial/blob/main/index.html

Uses a nested loop structure to continuously read data chunks from a serial port, handling errors and stream locks.

```javascript
        while (port.readable) {
          const reader = port.readable.getReader();
          try {
            while (true) {
              const { value, done } = await reader.read();
              if (done) {
                // |reader| has been canceled.
                break;
              }
              // Do something with |value|...
            }
          } catch (error) {
            // Handle |error|...
          } finally {
            reader.releaseLock();
          }
        }
```

--------------------------------

### Revoke Serial Port Permission

Source: https://github.com/wicg/serial/blob/main/index.html

Use this method to voluntarily revoke access to a previously requested serial port.

```javascript
        // Request a serial port.
        const port = await navigator.serial.requestPort();

        // Then later... revoke permission to the serial port.
        await port.forget();
```

--------------------------------

### SerialPort.forget()

Source: https://github.com/wicg/serial/blob/main/index.html

Revokes permission to access the serial port.

```APIDOC
## SerialPort.forget()

### Description
Revokes the site's permission to access this serial port.

### Response
- **Promise<undefined>** - Resolves when the permission is revoked.
```

--------------------------------

### Close Serial Port Streams

Source: https://github.com/wicg/serial/blob/main/EXPLAINER.md

Properly close a serial port when using transform streams by awaiting stream closure promises and handling cancellation errors.

```javascript
writer.close();
await writableStreamClosed;
reader.cancel();
await readableStreamClosed.catch(reason => {});
await port.close();
```

--------------------------------

### Close Serial Port

Source: https://github.com/wicg/serial/blob/main/EXPLAINER.md

Release stream locks before closing the port.

```javascript
writer.releaseLock();
reader.releaseLock();
await port.close();
```

--------------------------------

### Close a serial port stream

Source: https://github.com/wicg/serial/blob/main/index.html

Cancels the reader, waits for the stream to close, and then closes the serial port.

```javascript
        lineReader.cancel();
        await streamClosed;
        await port.close();
```
Tokens:
Raw