Initial commit
This commit is contained in:
Jason Harrell
165
build/fs/api_uart.js
Normal file
165
build/fs/api_uart.js
Normal file
@@ -0,0 +1,165 @@
|
||||
// UART API. Source C API is defined at:
|
||||
// [mgos_uart.h](https://github.com/cesanta/mongoose-os/blob/master/fw/src/mgos_uart.h)
|
||||
let UART = {
|
||||
_free: ffi('void free(void *)'),
|
||||
_cdef: ffi('void *mgos_uart_config_get_default(int)'),
|
||||
_cbp: ffi('void mgos_uart_config_set_basic_params(void *, int, int, int, int)'),
|
||||
_crx: ffi('void mgos_uart_config_set_rx_params(void *, int, int, int)'),
|
||||
_ctx: ffi('void mgos_uart_config_set_tx_params(void *, int, int)'),
|
||||
_cfg: ffi('int mgos_uart_configure(int, void *)'),
|
||||
_wr: ffi('int mgos_uart_write(int, char *, int)'),
|
||||
_rd: ffi('int mgos_uart_read(int, void *, int)'),
|
||||
|
||||
// ## **`UART.setConfig(uartNo, param)`**
|
||||
// Set UART config. `param` is an
|
||||
// object with the following optional fields:
|
||||
//
|
||||
// - `baudRate`: baud rate, integer, default: 115200;
|
||||
// - `numDataBits`: Number of data bits, default: 8;
|
||||
// - `parity`: Parity: 0 - none, 1 - even, 2 - odd; default: none;
|
||||
// - `numStopBits`: Number of stop bits: 1 - 1 bit, 2 - 2 bits, 3 - 1.5; default: 1;
|
||||
// - `rxBufSize`: size of the Rx buffer, integer, default: 256;
|
||||
// - `rxFlowControl`: whether Rx flow control (RTS pin) is enabled, boolean,
|
||||
// default: false;
|
||||
// - `rxLingerMicros`: how many microseconds to linger after Rx fifo
|
||||
// is empty, in case more data arrives. Integer, default: 15;
|
||||
// - `txBufSize`: size of the Tx buffer, integer, default: 256;
|
||||
// - `txFlowControl`: whether Tx flow control (CTS pin) is enabled, boolean,
|
||||
// default: false;
|
||||
//
|
||||
// Other than that, there are architecture-dependent settings, grouped in
|
||||
// the objects named with the architecture name: "esp32", "esp8266", etc.
|
||||
//
|
||||
// Settings for esp32:
|
||||
//
|
||||
// ```
|
||||
// esp32: {
|
||||
// /*
|
||||
// * GPIO pin numbers, default values depend on UART.
|
||||
// *
|
||||
// * UART 0: Rx: 3, Tx: 1, CTS: 19, RTS: 22
|
||||
// * UART 1: Rx: 13, Tx: 14, CTS: 15, RTS: 16
|
||||
// * UART 2: Rx: 17, Tx: 25, CTS: 26, RTS: 27
|
||||
// */
|
||||
// gpio: {
|
||||
// rx: number,
|
||||
// tx: number,
|
||||
// cts: number,
|
||||
// rts: number,
|
||||
// },
|
||||
//
|
||||
// /* Hardware FIFO tweaks */
|
||||
// fifo: {
|
||||
// /*
|
||||
// * A number of bytes in the hardware Rx fifo, should be between 1 and 127.
|
||||
// * How full hardware Rx fifo should be before "rx fifo full" interrupt is
|
||||
// * fired.
|
||||
// */
|
||||
// rxFullThresh: number,
|
||||
//
|
||||
// /*
|
||||
// * A number of bytes in the hardware Rx fifo, should be more than
|
||||
// * rx_fifo_full_thresh.
|
||||
// *
|
||||
// * How full hardware Rx fifo should be before CTS is deasserted, telling
|
||||
// * the other side to stop sending data.
|
||||
// */
|
||||
// rxFcThresh: number,
|
||||
//
|
||||
// /*
|
||||
// * Time in uart bit intervals when "rx fifo full" interrupt fires even if
|
||||
// * it's not full enough
|
||||
// */
|
||||
// rxAlarm: number,
|
||||
//
|
||||
// /*
|
||||
// * A number of bytes in the hardware Tx fifo, should be between 1 and 127.
|
||||
// * When the number of bytes in Tx buffer becomes less than
|
||||
// * tx_fifo_empty_thresh, "tx fifo empty" interrupt fires.
|
||||
// */
|
||||
// txEmptyThresh: number,
|
||||
// },
|
||||
// }
|
||||
// ```
|
||||
setConfig: function(uartNo, param) {
|
||||
let cfg = this._cdef(uartNo);
|
||||
|
||||
this._cbp(cfg, param.baudRate || 115200,
|
||||
param.numDataBits || 8,
|
||||
param.parity || 0,
|
||||
param.numStopBits || 1);
|
||||
|
||||
this._crx(
|
||||
cfg,
|
||||
param.rxBufSize || 256,
|
||||
param.rxFlowControl || false,
|
||||
param.rxLingerMicros || 15
|
||||
);
|
||||
|
||||
this._ctx(
|
||||
cfg,
|
||||
param.txBufSize || 256,
|
||||
param.txFlowControl || false
|
||||
);
|
||||
|
||||
// Apply arch-specific config
|
||||
if (this._arch !== undefined) {
|
||||
this._arch.scfg(uartNo, cfg, param);
|
||||
}
|
||||
|
||||
let res = this._cfg(uartNo, cfg);
|
||||
|
||||
this._free(cfg);
|
||||
cfg = null;
|
||||
|
||||
return res;
|
||||
},
|
||||
|
||||
// ## **`UART.setDispatcher(uartNo, callback, userdata)`**
|
||||
// Set UART dispatcher
|
||||
// callback which gets invoked when there is a new data in the input buffer
|
||||
// or when the space becomes available on the output buffer.
|
||||
//
|
||||
// Callback receives the following arguments: `(uartNo, userdata)`.
|
||||
setDispatcher: ffi('void mgos_uart_set_dispatcher(int, void(*)(int, userdata), userdata)'),
|
||||
|
||||
// ## **`UART.write(uartNo, data)`**
|
||||
// Write data to the buffer. Returns number of bytes written.
|
||||
//
|
||||
// Example usage: `UART.write(1, "foobar")`, in this case, 6 bytes will be written.
|
||||
write: function(uartNo, data) {
|
||||
this._wr(uartNo, data, data.length);
|
||||
},
|
||||
|
||||
// ## **`UART.writeAvail(uartNo)`**
|
||||
// Return amount of space available in the output buffer.
|
||||
writeAvail: ffi('int mgos_uart_write_avail(int)'),
|
||||
|
||||
// ## **`UART.read(uartNo)`**
|
||||
// It never blocks, and returns a string containing
|
||||
// read data (which will be empty if there's no data available).
|
||||
read: function(uartNo) {
|
||||
let n = 0; let res = ''; let buf = 'xxxxxxxxxx'; // Should be > 5
|
||||
while ((n = this._rd(uartNo, buf, buf.length)) > 0) {
|
||||
res += buf.slice(0, n);
|
||||
}
|
||||
return res;
|
||||
},
|
||||
// ## **`UART.readAvail(uartNo)`**
|
||||
// Return amount of data available in the input buffer.
|
||||
readAvail: ffi('int mgos_uart_read_avail(int)'),
|
||||
|
||||
// ## **`UART.setRxEnabled(uartNo)`**
|
||||
// Set whether Rx is enabled.
|
||||
setRxEnabled: ffi('void mgos_uart_set_rx_enabled(int, int)'),
|
||||
// ## **`UART.isRxEnabled(uartNo)`**
|
||||
// Returns whether Rx is enabled.
|
||||
isRxEnabled: ffi('int mgos_uart_is_rx_enabled(int)'),
|
||||
|
||||
// ## **`UART.flush(uartNo)`**
|
||||
// Flush the UART output buffer, wait for the data to be sent.
|
||||
flush: ffi('void mgos_uart_flush(int)'),
|
||||
};
|
||||
|
||||
// Load arch-specific API
|
||||
load('api_arch_uart.js');
|
||||
Reference in New Issue
Block a user