Web Serial API

The Serial API provides a way for websites to read and write from a serial device through script. Such an API would bridge the web and the physical world, by allowing documents to communicate with devices such as microcontrollers, 3D printers, and other serial devices. There is also a companion explainer document.

{{Serial}} interface

    [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() method

When the user first visits a site it will not have permission to access any serial devices. A site must first call {{Serial/requestPort()}}. This call gives the browser the opportunity to prompt the user for which device the site should be allowed to control. If the site is designed to work with a particular device which is always connected via USB the site can provide a filter restricting the devices the user can select to only those that would be compatible. For example, a site which programs Arduino-powered robots could specify a like the following to limit the set of selectable ports to only USB devices with Arduino's USB vendor ID,

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

If on the other hand the site expects to be used with a wide variety of devices or devices connected through a USB to serial converter it may specify no filter at all and rely on the user to select the appropriate device,

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

Asking the user to choose a port requires showing a prompt to the user and so the site must have [=transient activation=] from something like the user clicking a button.

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

        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.
          }
        });

The user may choose not to select a device, in which case the {{Promise}} will be rejected with a "{{NotFoundError}}" {{DOMException}} that the site must handle.

The {{Serial/requestPort()}} method steps are:

Let |promise:Promise| be [=a new promise=].
If [=this=]'s [=relevant global object=]'s [=associated Document=] is not [=allowed to use=] the [=policy-controlled feature=] named `"serial"`, [=reject=] |promise| with a "{{SecurityError}}" {{DOMException}} and return |promise|.
If the [=relevant global object=] of [=this=] does not have [=transient activation=], [=reject=] |promise| with a "{{SecurityError}}" {{DOMException}} and return |promise|.
If |options|["{{SerialPortRequestOptions/filters}}"] is present, then for each |filter:SerialPortFilter| in |options|["{{SerialPortRequestOptions/filters}}"] run the following steps:
1. If |filter|["{{SerialPortFilter/usbVendorId}}"] is not present, [=reject=] |promise| with a {{TypeError}} and return |promise|.
  This check implements the combined rule that a {{SerialPortFilter}} cannot be empty and if {{SerialPortFilter/usbProductId}} is specified then {{SerialPortFilter/usbVendorId}} must also be specified.
Run the following steps [=in parallel=]:
1. Prompt the user to grant the site access to a serial port by presenting them with a list of available ports that [=match any filter=] in |options|["{{SerialPortRequestOptions/filters}}"] if present and all available ports otherwise.
2. If the user does not choose a port, [=queue a global task=] on the [=relevant global object=] of [=this=] using the [=serial port task source=] to [=reject=] |promise| with an {{"AbortError"}} {{DOMException}} and abort these steps.
3. Let |port:SerialPort| be a {{SerialPort}} representing the port chosen by the user.
4. [=Queue a global task=] on the [=relevant global object=] of [=this=] using the [=serial port task source=] to [=resolve=] |promise| with |port|.
Return |promise|.

SerialPortRequestOptions dictionary

        dictionary SerialPortRequestOptions {
          sequence<SerialPortFilter> filters;
        };

filters member: Filters for serial ports

SerialPortFilter dictionary

        dictionary SerialPortFilter {
          unsigned short usbVendorId;
          unsigned short usbProductId;
        };

usbVendorId member: USB Vendor ID
usbProductId member: USB Product ID

A serial port matches the filter |filter:SerialPortFilter| if these steps return `true`:

If |filter|["{{SerialPortFilter/usbVendorId}}"] is not present, return `true`.
If the serial port is not part of a USB device, return `false`.
If the USB device's vendor ID is not equal to |filter|["{{SerialPortFilter/usbVendorId}}"], return `false`.
If |filter|["{{SerialPortFilter/usbProductId}}"] is not present, return `true`.
If the USB device's product ID is not equal to |filter|["{{SerialPortFilter/usbProductId}}"], return `false`.
Otherwise, return `true`.

A serial port matches any filter in a sequence of {{SerialPortFilter}} if these steps return `true`:

For each |filter| in the sequence, run these sub-steps:
1. If the serial port does not [=match the filter=] |filter|, return false.
Return true.

getPorts() method

If a serial port is provided by a USB device then that device may be connected or disconnected from the system. Once a site has permission to access a port it can receive these events and query for the set of connected devices it currently has access to.

        // 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.port| to the UI or automatically connect.
        });

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

The {{Serial/getPorts()}} method steps are:

Let |promise:Promise| be [=a new promise=].
If [=this=]'s [=relevant global object=]'s [=associated Document=] is not [=allowed to use=] the [=policy-controlled feature=] named `"serial"`, [=reject=] |promise| with a "{{SecurityError}}" {{DOMException}} and return |promise|.
Run the following steps [=in parallel=]:
1. Let |availablePorts| be the sequence of available serial ports on the system which the user has allowed the site to access as the result of a previous call to {{Serial/requestPort()}}.
2. Let |ports| be the sequence of the {{SerialPort}}s representing the ports in |availablePorts|.
3. [=Queue a global task=] on the [=relevant global object=] of [=this=] using the [=serial port task source=] to [=resolve=] |promise| with |ports|.
Return |promise|.

onconnect attribute

{{Serial/onconnect}} is an [=event handler IDL attribute=] for the connect event type.

ondisconnect attribute

{{Serial/ondisconnect}} is an [=event handler IDL attribute=] for the disconnect event type.

SerialPort interface

    [Exposed=(DedicatedWorker,Window), SecureContext]
    interface SerialPort : EventTarget {
      attribute EventHandler onconnect;
      attribute EventHandler ondisconnect;
      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();
    };

Methods on this interface typically complete asynchronously, queuing work on the serial port task source.

The [=get the parent=] algorithm for {{SerialPort}} returns the same {{Serial}} instance that is returned by the {{SerialPort}}'s [=relevant global object=]'s {{Navigator}} object's {{Navigator/serial}} getter.

Instances of {{SerialPort}} are created with the internal slots described in the following table:

Internal slot	Initial value	Description (non-normative)
[[\state]]	`"closed"`	Tracks the active state of the {{SerialPort}}
[[\bufferSize]]	undefined	The amount of data to buffer for transmit and receive
[[\readable]]	`null`	A {{ReadableStream}} that receives data from the port
[[\readFatal]]	`false`	A flag indicating that the port has encountered a fatal read error
[[\writable]]	`null`	A {{WritableStream}} that transmits data to the port
[[\writeFatal]]	`false`	A flag indicating that the port has encountered a fatal write error
[[\pendingClosePromise]]	`null`	A {{Promise}} used to wait for {{SerialPort/readable}} and {{SerialPort/writable}} to close

onconnect attribute

{{SerialPort/onconnect}} is an [=event handler IDL attribute=] for the {{connect}} event type.

When a serial port becomes available on the system that the user has allowed the site to access as the result of a previous call to {{Serial/requestPort()}}, run the following steps:

Let |port:SerialPort| be a {{SerialPort}} representing the port.
[=Fire an event=] named {{connect}} at |port| with its {{Event/bubbles}} attribute initialized to `true`.

ondisconnect attribute

{{SerialPort/ondisconnect}} is an [=event handler IDL attribute=] for the {{disconnect}} event type.

When a serial port becomes unavailable on the system that the user has allowed the site to access as the result of a previous call to {{Serial/requestPort()}}, run the following steps:

Let |port:SerialPort| be a {{SerialPort}} representing the port.
[=Fire an event=] named {{disconnect}} at |port| with its {{Event/bubbles}} attribute initialized to `true`.

getInfo() method

The {{SerialPort/getInfo()}} method steps are:

Let |info:SerialPortInfo| be a [=new=] {{SerialPortInfo}} dictionary.
If the port is part of a USB device, perform the following steps:
1. Set |info|["{{SerialPortInfo/usbVendorId}}"] to the vendor ID of the device.
2. Set |info|["{{SerialPortInfo/usbProductId}}"] to the product ID of the device.
Return |info|.

SerialPortInfo dictionary

      dictionary SerialPortInfo {
        unsigned short usbVendorId;
        unsigned short usbProductId;
      };

usbVendorId member: If the port is part of a USB device this member will be the 16-bit vendor ID of that device. Otherwise it will be `undefined`.
usbProductId member: If the port is part of a USB device this member will be the 16-bit product ID of that device. Otherwise it will be `undefined`.

open() method

Before communicating on a serial port it must be opened. Opening the port allows the site to specify the necessary parameters which control how data is transmitted and received. Developers should check the documentation for the device they are connecting to for the appropriate parameters.

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

Once {{SerialPort/open()}} has resolved the {{SerialPort/readable}} and {{SerialPort/writable}} attributes can be accessed to get the {{ReadableStream}} and {{WritableStream}} instances for receiving data from and sending data to the connected device.

The {{SerialPort/open()}} method steps are:

Let |promise| be [=a new promise=].
If [=this=].{{[[state]]}} is not `"closed"`, reject |promise| with an "{{InvalidStateError}}" {{DOMException}} and return |promise|.
If |options|["{{SerialOptions/dataBits}}"] is not 7 or 8, reject |promise| with {{TypeError}} and return |promise|.
If |options|["{{SerialOptions/stopBits}}"] is not 1 or 2, reject |promise| with {{TypeError}} and return |promise|.
If |options|["{{SerialOptions/bufferSize}}"] is 0, reject |promise| with {{TypeError}} and return |promise|.
Optionally, if |options|["{{SerialOptions/bufferSize}}"] is larger than the implementation is able to support, reject |promise| with a {{TypeError}} and return |promise|.
Set [=this=].{{[[state]]}} to `"opening"`.
Perform the following steps [=in parallel=].
1. Invoke the operating system to open the serial port using the connection parameters (or their defaults) specified in |options|.
2. If this fails for any reason, [=queue a global task=] on the [=relevant global object=] of [=this=] using the [=serial port task source=] to [=reject=] |promise| with a "{{NetworkError}}" {{DOMException}} and abort these steps.
3. Set [=this=].{{[[state]]}} to `"opened"`.
4. Set [=this=].{{[[bufferSize]]}} to |options|["{{SerialOptions/bufferSize}}"].
5. [=Queue a global task=] on the [=relevant global object=] of [=this=] using the [=serial port task source=] to [=resolve=] |promise| with `undefined`.
Return |promise|.

SerialOptions dictionary

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

baudRate member: A positive, non-zero value indicating the baud rate at which serial communication should be established.
{{SerialOptions/baudRate}} is the only required member of this dictionary. While there are common default for other connection parameters it is important for developers to consider and consult with the documentation for devices they intend to connect to determine the correct values. While some values are common there is no standard baud rate. Requiring this parameter reduces the potential for confusion if an arbitrary default were chosen by this specification.
dataBits member: The number of data bits per frame. Either 7 or 8.
stopBits member: The number of stop bits at the end of a frame. Either 1 or 2.
parity member: The parity mode.
bufferSize member: A positive, non-zero value indicating the size of the read and write buffers that should be created.
flowControl member: The flow control mode.

ParityType enum

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

none: No parity bit is sent for each data word.
even: Data word plus parity bit has even parity.
odd: Data word plus parity bit has odd parity.

FlowControlType enum

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

none: No flow control is enabled.
hardware: Hardware flow control using the RTS and CTS signals is enabled.

readable attribute

An application receiving data from a serial port will typically use a nested pair of loops like this,

        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();
          }
        }

The inner loop will read chunks of data from the port until an error is encountered, at which point the code in the "catch" block will be executed. The outer loop handles recoverable errors such as parity check failures by opening a new reader. Fatal errors will cause {{SerialPort/readable}} to become `null` and the loop to end.

As long as the serial port is open it can continue to produce data and the amount of data in each of the chunks returned by {{ReadableStreamDefaultReader/read()}} will be essentially arbitrary based on the timing of when it is called. It is up to the device and the code communicating with it to decide what constitutes a complete message. For example, a device might communicate with the host using ASCII-formatted text where each message ends with a newline (or the sequence `"\r\n"`). A pipeline of {{TransformStream}}s can be used to automatically convert the {{Uint8Array}} chunks provided by {{SerialPort/readable}} into {{DOMString}}s containing an entire line of text each.

        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 lineReader = port.readable
            .pipeThrough(new TextDecoderStream())
            .pipeThrough(new TransformStream(new LineBreakTransformer()))
            .getReader();

Some other ways of encoding message boundaries are to prefix each message with its length or to wait a defined length of time before transmitting the next message. Implementing a {{TransformStream}} for these types of message boundaries is left as an exercise for the reader.

The {{SerialPort/readable}} getter steps are:

If [=this=].{{[[readable]]}} is not `null`, return [=this=].{{[[readable]]}}.
If [=this=].{{[[state]]}} is not `"opened"`, return `null`.
If [=this=].{{[[readFatal]]}} is `true`, return `null`.
Let |stream| be a [=new=] {{ReadableStream}}.
Let |pullAlgorithm| be the following steps:
1. Let |desiredSize| be the desired size of [=this=].{{[[readable]]}}'s internal queue.
2. Run the following steps [=in parallel=]:
  1. Invoke the operating system to read up to |desiredSize| bytes from the port, putting the result in the [=byte sequence=] |bytes|.
  2. [=Queue a global task=] on the [=relevant global object=] of [=this=] using the [=serial port task source=] to run the following steps:
    1. If no errors were encountered run the following steps:
      1. Let |buffer| be a [=new=] {{ArrayBuffer}} created from |bytes|.
      2. Let |chunk| be a [=new=] {{Uint8Array}} view over |buffer|, who's length is the length of |bytes|.
      3. Invoke [=ReadableStream/enqueue=] on [=this=].{{[[readable]]}} with |chunk|.
    2. If a buffer overrun condition was encountered, invoke [=ReadableStream/error=] on [=this=].{{[[readable]]}} with a "BufferOverrunError" {{DOMException}} and invoke the steps to [=handle closing the readable stream=].
    3. If a break condition was encountered, invoke [=ReadableStream/error=] on [=this=].{{[[readable]]}} with a "BreakError" {{DOMException}} and invoke the steps to [=handle closing the readable stream=].
    4. If a framing error was encountered, invoke [=ReadableStream/error=] on [=this=].{{[[readable]]}} with a "FramingError" {{DOMException}} and invoke the steps to [=handle closing the readable stream=].
    5. If a parity error was encountered, invoke [=ReadableStream/error=] on [=this=].{{[[readable]]}} with a "ParityError" {{DOMException}} and invoke the steps to [=handle closing the readable stream=].
    6. If an operating system error was encountered, invoke [=ReadableStream/error=] on [=this=].{{[[readable]]}} with an "{{UnknownError}}" {{DOMException}} and invoke the steps to [=handle closing the readable stream=].
    7. If the port was disconnected, run the following steps:
      1. Set [=this=].{{[[readFatal]]}} to `true`,
      2. Invoke [=ReadableStream/error=] on [=this=].{{[[readable]]}} with a "{{NetworkError}}" {{DOMException}}.
      3. Invoke the steps to [=handle closing the readable stream=].
3. Return [=a promise resolved with=] `undefined`.
The {{Promise}} returned by this algorithm is immediately resolved so that it does not block canceling the stream. [[STREAMS]] specifies that this algorithm will not be invoked again until a chunk is enqueued.
Let |cancelAlgorithm| be the following steps:
1. Let |promise| be [=a new promise=].
2. Run the following steps [=in parallel=].
  1. Invoke the operating system to discard the contents of all software and hardware receive buffers for the port.
  2. [=Queue a global task=] on the [=relevant global object=] of [=this=] using the [=serial port task source=] to run the following steps:
    1. Invoke the steps to [=handle closing the readable stream=].
    2. [=Resolve=] |promise| with `undefined`.
3. Return |promise|.
[=ReadableStream/Set up=] |stream| with pullAlgorithm set to |pullAlgorithm|, cancelAlgorithm set to |cancelAlgorithm|, highWaterMark set to [=this=].{{[[bufferSize]]}}, and sizeAlgorithm set to a byte-counting size algorithm.
Set [=this=].{{[[readable]]}} to |stream|.
Return |stream|.

To handle closing the readable stream perform the following steps:

Set [=this=].{{[[readable]]}} to `null`.
If [=this=].{{[[writable]]}} is `null` and [=this=].{{[[pendingClosePromise]]}} is not `null`, [=resolve=] [=this=].{{[[pendingClosePromise]]}} with `undefined`.

writable attribute

To write individual chunks of data to the port a {{WritableStreamDefaultWriter}} can be created and released as necessary. This example uses a `TextEncoder` to encode a {{DOMString}} as the necessary {{Uint8Array}} for transmission.

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

When writing larger chunks it can be important to allow the port to apply back pressure so that the serial transmitter does not get too far behind sending data generated by the application. The {{WritableStreamDefaultWriter/write()}} method returns a {{Promise}} which resolves when data has been written. While having some data available in the transmit buffer is important to maintain good throughput awaiting this {{Promise}} before generating too many chunks of data is a good practice to avoid excessive buffering.

The {{SerialPort/writable}} getter steps are:

If [=this=].{{[[writable]]}} is not `null`, return [=this=].{{[[writable]]}}.
If [=this=].{{[[state]]}} is not `"opened"`, return `null`.
If [=this=].{{[[writeFatal]]}} is `true`, return `null`.
Let |stream:WritableStream| be a [=new=] {{WritableStream}}.
Let |writeAlgorithm| be the following steps, given |chunk|:
1. Let |promise:Promise| be [=a new promise=].
2. If |chunk| cannot be [=converted to an IDL value=] of type {{BufferSource}}, reject |promise| with a {{TypeError}} and return |promise|. Otherwise, save the result of the conversion in |source:BufferSource|.
3. [=Get a copy of the buffer source=] |source| and save the result in |bytes|.
4. [=In parallel=], run the following steps:
  1. Invoke the operating system to write |bytes| to the port. Alternately, store the chunk for future coalescing.
    The operating system may return from this operation once |bytes| has been queued for transmission rather than after it has been transmitted.
  2. [=Queue a global task=] on the [=relevant global object=] of [=this=] using the [=serial port task source=] to run the following steps:
    1. If the chunk was successfully written, or was stored for future coalescing, [=resolve=] |promise| with `undefined`.
      [[STREAMS]] specifies that |writeAlgorithm| will only be invoked after the {{Promise}} returned by a previous invocation of this algorithm has resolved. For efficiency an implementation is allowed to resolve this {{Promise}} early in order to coalesce multiple chunks waiting in the {{WritableStream}}'s internal queue into a single request to the operating system.
    2. If an operating system error was encountered, [=reject=] |promise| with an "{{UnknownError}}" {{DOMException}}.
    3. If the port was disconnected, run the following steps:
      1. Set [=this=].{{[[writeFatal]]}} to `true`.
      2. [=Reject=] |promise| with a "{{NetworkError}}" {{DOMException}}.
      3. Invoke the steps to [=handle closing the writable stream=].
5. Return |promise|.
Let |abortAlgorithm| be the following steps:
1. Let |promise| be [=a new promise=].
2. Run the following steps [=in parallel=].
  1. Invoke the operating system to discard the contents of all software and hardware transmit buffers for the port.
  2. [=Queue a global task=] on the [=relevant global object=] of [=this=] using the [=serial port task source=] to run the following steps:
    1. Invoke the steps to [=handle closing the writable stream=].
    2. [=Resolve=] |promise| with `undefined`.
3. Return |promise|.
[[STREAMS]] specifies that |abortAlgorithm| will only be invoked after the {{Promise}} returned by a previous invocation of |writeAlgorithm| (if any) has resolved. This blocks abort on completion of the most recent write operation. This could be fixed by passing an {{AbortSignal}} to |writeAlgorithm|.
This enhancement is tracked in whatwg/streams#1015.
Let |closeAlgorithm| be the following steps:
1. Let |promise| be [=a new promise=].
2. Run the following steps [=in parallel=].
  1. Invoke the operating system to flush the contents of all software and hardware transmit buffers for the port.
  2. [=Queue a global task=] on the [=relevant global object=] of [=this=] using the [=serial port task source=] to run the following steps:
    1. Invoke the steps to [=handle closing the writable stream=].
    2. [=Resolve=] |promise| with `undefined`.
3. Return |promise|.
[=WritableStream/Set up=] |stream| with writeAlgorithm set to |writeAlgorithm|, abortAlgorithm set to |abortAlgorithm|, closeAlgorithm set to |closeAlgorithm|, highWaterMark set to [=this=].{{[[bufferSize]]}}, and sizeAlgorithm set to a byte-counting size algorithm.
Set [=this=].{{[[writable]]}} to |stream|.
Return |stream|.

To handle closing the writable stream perform the following steps:

Set [=this=].{{[[writable]]}} to `null`.
If [=this=].{{[[readable]]}} is `null` and [=this=].{{[[pendingClosePromise]]}} is not `null`, [=resolve=] [=this=].{{[[pendingClosePromise]]}} with `undefined`.

setSignals() method

Serial ports include a number of additional signals for device detection and flow control which can be queried and set explicitly. As an example, programming some micro-controllers first requires entering a "programming" mode by toggling the "Data Terminal Ready" (or DTR) signal.

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

The {{SerialPort/setSignals()}} method steps are:

Let |promise| be [=a new promise=].
If [=this=].{{[[state]]}} is not `"opened"`, reject |promise| with an "{{InvalidStateError}}" {{DOMException}} and return |promise|.
If all of the specified members of |signals| are not present reject |promise| with {{TypeError}} and return |promise|.
Perform the following steps [=in parallel=]:
1. If |signals|["{{SerialOutputSignals/dataTerminalReady}}"] is present, invoke the operating system to either assert (if `true`) or deassert (if `false`) the "data terminal ready" or "DTR" signal on the serial port.
2. If |signals|["{{SerialOutputSignals/requestToSend}}"] is present, invoke the operating system to either assert (if `true`) or deassert (if `false`) the "request to send" or "RTS" signal on the serial port.
3. If |signals|["{{SerialOutputSignals/break}}"] is present, invoke the operating system to either assert (if `true`) or deassert (if `false`) the "break" signal on the serial port.
  The "break" signal is typically implemented as an in-band signal by holding the transmit line at the "mark" voltage and thus prevents data transmission for as long as it remains asserted.
4. If the operating system fails to change the state of any of these signals for any reason, [=queue a global task=] on the [=relevant global object=] of [=this=] using the [=serial port task source=] to reject |promise| with a "{{NetworkError}}" {{DOMException}}.
5. [=Queue a global task=] on the [=relevant global object=] of [=this=] using the [=serial port task source=] to [=resolve=] |promise| with `undefined`.
Return |promise|.

SerialOutputSignals dictionary

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

dataTerminalReady: Data Terminal Ready (DTR)
requestToSend: Request To Send (RTS)
break: Break

getSignals() method

The {{SerialPort/getSignals()}} method steps are:

Let |promise:Promise| be [=a new promise=].
If [=this=].{{[[state]]}} is not `"opened"`, reject |promise| with an "{{InvalidStateError}}" {{DOMException}} and return |promise|.
Perform the following steps [=in parallel=]:
1. Query the operating system for the status of the control signals that may be asserted by the device connected to the serial port.
2. If the operating system fails to determine the status of these signals for any reason, [=queue a global task=] on the [=relevant global object=] of [=this=] using the [=serial port task source=] to reject |promise| with a "{{NetworkError}}" {{DOMException}} and abort these steps.
3. Let |signals:SerialInputSignals| be a [=new=] {{SerialInputSignals}}.
4. Set |signals|["{{SerialInputSignals/dataCarrierDetect}}"] to `true` if the "data carrier detect" or "DCD" signal has been asserted by the device, and `false` otherwise.
5. Set |signals|["{{SerialInputSignals/clearToSend}}"] to `true` if the "clear to send" or "CTS" signal has been asserted by the device, and `false` otherwise.
6. Set |signals|["{{SerialInputSignals/dataCarrierDetect}}"] to `true` if the "ring indicator" or "RI" signal has been asserted by the device, and `false` otherwise.
7. Set |signals|["{{SerialInputSignals/dataCarrierDetect}}"] to `true` if the "data set ready" or "DSR" signal has been asserted by the device, and `false` otherwise.
8. [=Queue a global task=] on the [=relevant global object=] of [=this=] using the [=serial port task source=] to [=resolve=] |promise| with |signals|.
Return |promise|.

SerialInputSignals dictionary

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

dataCarrierDetect member: Data Carrier Detect (DCD)
clearToSend member: Clear To Send (CTS)
ringIndicator member: Ring Indicator (RI)
dataSetReady member: Data Set Ready (DSR)

close() method

When communication with the port is no longer required it can be closed and the associated resources released by the system.

Calling `port.`{{SerialPort/close()}} implicitly invokes `port.`{{SerialPort/readable}}`.`{{ReadableStream/cancel()}} and `port.`{{SerialPort/writable}}`.`{{WritableStream/abort()}} in order to clear any buffered data. If the application has called `port.`{{SerialPort/readable}}`.`{{ReadableStream/getReader()}} or `port.`{{SerialPort/writable}}`.`{{WritableStream/getWriter()}} the stream is locked and the port cannot be closed. This forces the developer to decide how to handle any read or write operations that are in progress. For example, to ensure that all buffered data has been transmitted before the port is closed the application must await the {{Promise}} returned by `writer.`{{WritableStreamDefaultWriter/close()}}.

        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();

To discard any unsent data the application could instead call `writer.`{{WritableStreamDefaultWriter/abort()}}.

If a {{TransformStream}} is being piped to `port`.{{SerialPort/writable}} then waiting for the {{Promise}} returned by `writer.`{{WritableStreamDefaultWriter/close()}} to resolve is insufficient. The application must wait for the pipe chain to close by waiting for the {{Promise}} returned by {{ReadableStream/pipeTo()}} to resolve instead.

        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();

If a loop is being used to read chunks from the port, as is done in [[[#readable-example]]], then it must be exited before calling `port.`{{SerialPort/close()}}.

        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;

Calling `reader.`{{ReadableStreamGenericReader/cancel()}} causes the call to `reader.`{{ReadableStreamDefaultReader/read()}} to return immediately, exiting the inner loop and calling `reader.`{{ReadableStreamDefaultReader/releaseLock()}}. The outer loop then exits because `keepReading` has been set to `false` and with the stream unlocked `port.`{{SerialPort/close()}} can complete successfully.

While it is also possible to call `port.`{{SerialPort/close()}} immediately after awaiting the {{Promise}} returned by `reader.`{{ReadableStreamGenericReader/cancel()}} it is better to place the call to `port.`{{SerialPort/close()}} as the last step of `readUntilClosed()` so that the port is also closed when a fatal error is encountered and `port.`{{SerialPort/readable}} becomes `null`.

The {{SerialPort/close()}} method steps are:

Let |promise| be [=a new promise=].
Let |cancelPromise:Promise| be the result of invoking [=ReadableStream/cancel=] on [=this=].{{[[readable]]}} or [=a promise resolved with=] `undefined` if [=this=].{{[[readable]]}} is `null`.
Let |abortPromise:Promise| be the result of invoking [=WritableStream/abort=] on [=this=].{{[[writable]]}} or [=a promise resolved with=] `undefined` if [=this=].{{[[writable]]}} is `null`.
Let |pendingClosePromise| be [=a new promise=].
If [=this=].{{[[readable]]}} and [=this=].{{[[writable]]}} are `null`, [=resolve=] |pendingClosePromise| with `undefined`.
Set [=this=].{{[[pendingClosePromise]]}} to |pendingClosePromise|.
Let |combinedPromise:Promise| be the result of [=getting a promise to wait for all=] with «|cancelPromise|, |abortPromise|, |pendingClosePromise|».
Set [=this=].{{[[state]]}} to `"closing"`.
[=promise/React=] to |combinedPromise|.
- If |combinedPromise| was fulfilled, then:
  1. Run the following steps [=in parallel=]:
    1. Invoke the operating system to close the serial port and release any associated resources.
    2. Set [=this=].{{[[state]]}} to `"closed"`.
    3. Set [=this=].{{[[readFatal]]}} and [=this=].{{[[writeFatal]]}} to `false`.
    4. Set [=this=].{{[[pendingClosePromise]]}} to `null`.
    5. [=Queue a global task=] on the [=relevant global object=] of [=this=] using the [=serial port task source=] to [=resolve=] |promise| with `undefined`.
- If |combinedPromise| was rejected with reason |r|, then:
  1. Set [=this=].{{[[pendingClosePromise]]}} to `null`.
  2. [=Queue a global task=] on the [=relevant global object=] of [=this=] using the [=serial port task source=] to [=reject=] |promise| with |r|.
Return |promise|.

Extensions to the {{Navigator}} interface

serial attribute

Extensions to the {{WorkerNavigator}} interface

serial attribute

{{Serial}} interface

requestPort() method

SerialPortRequestOptions dictionary

SerialPortFilter dictionary

getPorts() method

onconnect attribute

ondisconnect attribute

SerialPort interface

onconnect attribute

ondisconnect attribute

getInfo() method

SerialPortInfo dictionary

open() method

SerialOptions dictionary

ParityType enum

FlowControlType enum

readable attribute

writable attribute

setSignals() method

SerialOutputSignals dictionary

getSignals() method

SerialInputSignals dictionary

close() method

Security considerations

Privacy considerations

Acknowledgements