372 lines
12 KiB
Plaintext
Executable File
372 lines
12 KiB
Plaintext
Executable File
// Copyright 2014 The Chromium Authors
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
// Use the <code>chrome.serial</code> API to read from and write to a device
|
|
// connected to a serial port.
|
|
namespace serial {
|
|
|
|
dictionary DeviceInfo {
|
|
// The device's system path. This should be passed as the <code>path</code>
|
|
// argument to <code>chrome.serial.connect</code> in order to connect to
|
|
// this device.
|
|
DOMString path;
|
|
|
|
// A PCI or USB vendor ID if one can be determined for the underlying
|
|
// device.
|
|
long? vendorId;
|
|
|
|
// A USB product ID if one can be determined for the underlying device.
|
|
long? productId;
|
|
|
|
// A human-readable display name for the underlying device if one can be
|
|
// queried from the host driver.
|
|
DOMString? displayName;
|
|
};
|
|
|
|
callback GetDevicesCallback = void (DeviceInfo[] ports);
|
|
|
|
enum DataBits { seven, eight };
|
|
enum ParityBit { no, odd, even };
|
|
enum StopBits { one, two };
|
|
|
|
dictionary ConnectionOptions {
|
|
// Flag indicating whether or not the connection should be left open when
|
|
// the application is suspended (see
|
|
// <a href="http://developer.chrome.com/apps/app_lifecycle.html">Manage App
|
|
// Lifecycle</a>). The default value is "false." When the application is
|
|
// loaded, any serial connections previously opened with persistent=true
|
|
// can be fetched with <code>getConnections</code>.
|
|
boolean? persistent;
|
|
|
|
// An application-defined string to associate with the connection.
|
|
DOMString? name;
|
|
|
|
// The size of the buffer used to receive data. The default value is 4096.
|
|
long? bufferSize;
|
|
|
|
// The requested bitrate of the connection to be opened. For compatibility
|
|
// with the widest range of hardware, this number should match one of
|
|
// commonly-available bitrates, such as 110, 300, 1200, 2400, 4800, 9600,
|
|
// 14400, 19200, 38400, 57600, 115200. There is no guarantee, of course,
|
|
// that the device connected to the serial port will support the requested
|
|
// bitrate, even if the port itself supports that bitrate. <code>9600</code>
|
|
// will be passed by default.
|
|
long? bitrate;
|
|
|
|
// <code>"eight"</code> will be passed by default.
|
|
DataBits? dataBits;
|
|
|
|
// <code>"no"</code> will be passed by default.
|
|
ParityBit? parityBit;
|
|
|
|
// <code>"one"</code> will be passed by default.
|
|
StopBits? stopBits;
|
|
|
|
// Flag indicating whether or not to enable RTS/CTS hardware flow control.
|
|
// Defaults to false.
|
|
boolean? ctsFlowControl;
|
|
|
|
// The maximum amount of time (in milliseconds) to wait for new data before
|
|
// raising an <code>onReceiveError</code> event with a "timeout" error.
|
|
// If zero, receive timeout errors will not be raised for the connection.
|
|
// Defaults to 0.
|
|
long? receiveTimeout;
|
|
|
|
// The maximum amount of time (in milliseconds) to wait for a
|
|
// <code>send</code> operation to complete before calling the callback with
|
|
// a "timeout" error. If zero, send timeout errors will not be triggered.
|
|
// Defaults to 0.
|
|
long? sendTimeout;
|
|
};
|
|
|
|
// Result of the <code>getInfo</code> method.
|
|
dictionary ConnectionInfo {
|
|
// The id of the serial port connection.
|
|
long connectionId;
|
|
|
|
// Flag indicating whether the connection is blocked from firing onReceive
|
|
// events.
|
|
boolean paused;
|
|
|
|
// See <code>ConnectionOptions.persistent</code>
|
|
boolean persistent;
|
|
|
|
// See <code>ConnectionOptions.name</code>
|
|
DOMString name;
|
|
|
|
// See <code>ConnectionOptions.bufferSize</code>
|
|
long bufferSize;
|
|
|
|
// See <code>ConnectionOptions.receiveTimeout</code>
|
|
long receiveTimeout;
|
|
|
|
// See <code>ConnectionOptions.sendTimeout</code>
|
|
long sendTimeout;
|
|
|
|
// See <code>ConnectionOptions.bitrate</code>. This field may be omitted
|
|
// or inaccurate if a non-standard bitrate is in use, or if an error
|
|
// occurred while querying the underlying device.
|
|
long? bitrate;
|
|
|
|
// See <code>ConnectionOptions.dataBits</code>. This field may be omitted
|
|
// if an error occurred while querying the underlying device.
|
|
DataBits? dataBits;
|
|
|
|
// See <code>ConnectionOptions.parityBit</code>. This field may be omitted
|
|
// if an error occurred while querying the underlying device.
|
|
ParityBit? parityBit;
|
|
|
|
// See <code>ConnectionOptions.stopBits</code>. This field may be omitted
|
|
// if an error occurred while querying the underlying device.
|
|
StopBits? stopBits;
|
|
|
|
// See <code>ConnectionOptions.ctsFlowControl</code>. This field may be
|
|
// omitted if an error occurred while querying the underlying device.
|
|
boolean? ctsFlowControl;
|
|
};
|
|
|
|
// Callback from the <code>connect</code> method;
|
|
callback ConnectCallback = void (ConnectionInfo connectionInfo);
|
|
|
|
// Callback from the <code>update</code> method.
|
|
callback UpdateCallback = void (boolean result);
|
|
|
|
// Callback from the <code>disconnect</code> method. Returns true if the
|
|
// operation was successful.
|
|
callback DisconnectCallback = void (boolean result);
|
|
|
|
// Callback from the <code>setPaused</code> method.
|
|
callback SetPausedCallback = void ();
|
|
|
|
// Callback from the <code>getInfo</code> method.
|
|
callback GetInfoCallback = void (ConnectionInfo connectionInfo);
|
|
|
|
// Callback from the <code>getConnections</code> method.
|
|
callback GetConnectionsCallback = void (ConnectionInfo[] connectionInfos);
|
|
|
|
enum SendError {
|
|
// The connection was disconnected.
|
|
disconnected,
|
|
|
|
// A send was already pending.
|
|
pending,
|
|
|
|
// The send timed out.
|
|
timeout,
|
|
|
|
// A system error occurred and the connection may be unrecoverable.
|
|
system_error
|
|
};
|
|
|
|
dictionary SendInfo {
|
|
// The number of bytes sent.
|
|
long bytesSent;
|
|
|
|
// An error code if an error occurred.
|
|
SendError? error;
|
|
};
|
|
|
|
callback SendCallback = void (SendInfo sendInfo);
|
|
|
|
callback FlushCallback = void (boolean result);
|
|
|
|
callback SetBreakCallback = void (boolean result);
|
|
|
|
callback ClearBreakCallback = void (boolean result);
|
|
|
|
// The set of control signals which may be sent to a connected serial device
|
|
// using <code>setControlSignals</code>. Note that support for these signals
|
|
// is device-dependent.
|
|
dictionary HostControlSignals {
|
|
// DTR (Data Terminal Ready).
|
|
boolean? dtr;
|
|
|
|
// RTS (Request To Send).
|
|
boolean? rts;
|
|
};
|
|
|
|
// The set of control signals which may be set by a connected serial device.
|
|
// These can be queried using <code>getControlSignals</code>. Note that
|
|
// support for these signals is device-dependent.
|
|
dictionary DeviceControlSignals {
|
|
// DCD (Data Carrier Detect) or RLSD (Receive Line Signal/ Detect).
|
|
boolean dcd;
|
|
|
|
// CTS (Clear To Send).
|
|
boolean cts;
|
|
|
|
// RI (Ring Indicator).
|
|
boolean ri;
|
|
|
|
// DSR (Data Set Ready).
|
|
boolean dsr;
|
|
};
|
|
|
|
// Returns a snapshot of current control signals.
|
|
callback GetControlSignalsCallback = void (DeviceControlSignals signals);
|
|
|
|
// Returns true if operation was successful.
|
|
callback SetControlSignalsCallback = void (boolean result);
|
|
|
|
// Data from an <code>onReceive</code> event.
|
|
dictionary ReceiveInfo {
|
|
// The connection identifier.
|
|
long connectionId;
|
|
|
|
// The data received.
|
|
ArrayBuffer data;
|
|
};
|
|
|
|
enum ReceiveError {
|
|
// The connection was disconnected.
|
|
disconnected,
|
|
|
|
// No data has been received for <code>receiveTimeout</code> milliseconds.
|
|
timeout,
|
|
|
|
// The device was most likely disconnected from the host.
|
|
device_lost,
|
|
|
|
// The device detected a break condition.
|
|
break,
|
|
|
|
// The device detected a framing error.
|
|
frame_error,
|
|
|
|
// A character-buffer overrun has occurred. The next character is lost.
|
|
overrun,
|
|
|
|
// An input buffer overflow has occurred. There is either no room in the
|
|
// input buffer, or a character was received after the end-of-file (EOF)
|
|
// character.
|
|
buffer_overflow,
|
|
|
|
// The device detected a parity error.
|
|
parity_error,
|
|
|
|
// A system error occurred and the connection may be unrecoverable.
|
|
system_error
|
|
};
|
|
|
|
// Data from an <code>onReceiveError</code> event.
|
|
dictionary ReceiveErrorInfo {
|
|
// The connection identifier.
|
|
long connectionId;
|
|
|
|
// An error code indicating what went wrong.
|
|
ReceiveError error;
|
|
};
|
|
|
|
interface Functions {
|
|
// Returns information about available serial devices on the system.
|
|
// The list is regenerated each time this method is called.
|
|
// |callback| : Called with the list of <code>DeviceInfo</code> objects.
|
|
static void getDevices(GetDevicesCallback callback);
|
|
|
|
// Connects to a given serial port.
|
|
// |path| : The system path of the serial port to open.
|
|
// |options| : Port configuration options.
|
|
// |callback| : Called when the connection has been opened.
|
|
static void connect(
|
|
DOMString path,
|
|
optional ConnectionOptions options,
|
|
ConnectCallback callback);
|
|
|
|
// Update the option settings on an open serial port connection.
|
|
// |connectionId| : The id of the opened connection.
|
|
// |options| : Port configuration options.
|
|
// |callback| : Called when the configuation has completed.
|
|
static void update(
|
|
long connectionId,
|
|
ConnectionOptions options,
|
|
UpdateCallback callback);
|
|
|
|
// Disconnects from a serial port.
|
|
// |connectionId| : The id of the opened connection.
|
|
// |callback| : Called when the connection has been closed.
|
|
static void disconnect(
|
|
long connectionId,
|
|
DisconnectCallback callback);
|
|
|
|
// Pauses or unpauses an open connection.
|
|
// |connectionId| : The id of the opened connection.
|
|
// |paused| : Flag to indicate whether to pause or unpause.
|
|
// |callback| : Called when the connection has been successfully paused or
|
|
// unpaused.
|
|
static void setPaused(
|
|
long connectionId,
|
|
boolean paused,
|
|
SetPausedCallback callback);
|
|
|
|
// Retrieves the state of a given connection.
|
|
// |connectionId| : The id of the opened connection.
|
|
// |callback| : Called with connection state information when available.
|
|
static void getInfo(
|
|
long connectionId,
|
|
GetInfoCallback callback);
|
|
|
|
// Retrieves the list of currently opened serial port connections owned by
|
|
// the application.
|
|
// |callback| : Called with the list of connections when available.
|
|
static void getConnections(
|
|
GetConnectionsCallback callback);
|
|
|
|
// Writes data to the given connection.
|
|
// |connectionId| : The id of the connection.
|
|
// |data| : The data to send.
|
|
// |callback| : Called when the operation has completed.
|
|
static void send(
|
|
long connectionId,
|
|
ArrayBuffer data,
|
|
SendCallback callback);
|
|
|
|
// Flushes all bytes in the given connection's input and output buffers.
|
|
static void flush(
|
|
long connectionId,
|
|
FlushCallback callback);
|
|
|
|
// Retrieves the state of control signals on a given connection.
|
|
// |connectionId| : The id of the connection.
|
|
// |callback| : Called when the control signals are available.
|
|
static void getControlSignals(
|
|
long connectionId,
|
|
GetControlSignalsCallback callback);
|
|
|
|
// Sets the state of control signals on a given connection.
|
|
// |connectionId| : The id of the connection.
|
|
// |signals| : The set of signal changes to send to the device.
|
|
// |callback| : Called once the control signals have been set.
|
|
static void setControlSignals(
|
|
long connectionId,
|
|
HostControlSignals signals,
|
|
SetControlSignalsCallback callback);
|
|
|
|
// Suspends character transmission on a given connection and places the
|
|
// transmission line in a break state until the clearBreak is called.
|
|
// |connectionId| : The id of the connection.
|
|
static void setBreak(
|
|
long connectionId,
|
|
SetBreakCallback callback);
|
|
|
|
// Restore character transmission on a given connection and place the
|
|
// transmission line in a nonbreak state.
|
|
// |connectionId| : The id of the connection.
|
|
static void clearBreak(
|
|
long connectionId,
|
|
ClearBreakCallback callback);
|
|
};
|
|
|
|
interface Events {
|
|
// Event raised when data has been read from the connection.
|
|
// |info| : Event data.
|
|
static void onReceive(ReceiveInfo info);
|
|
|
|
// Event raised when an error occurred while the runtime was waiting for
|
|
// data on the serial port. Once this event is raised, the connection may be
|
|
// set to <code>paused</code>. A <code>"timeout"</code> error does not pause
|
|
// the connection.
|
|
static void onReceiveError(ReceiveErrorInfo info);
|
|
};
|
|
};
|