@node-pigpio/core
Version:
pigpiod client for node.js
942 lines (941 loc) • 42.9 kB
JavaScript
;
/* eslint-disable camelcase */
/**
* pigpio
*
* Oritinal source by http://abyz.me.uk/rpi/pigpio/python.html
* port by s
* It is the same feature as the original except that all requests are asynchronous.
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.SPI_MODE_3 = exports.SPI_MODE_2 = exports.SPI_MODE_1 = exports.SPI_MODE_0 = exports.FROM_END = exports.FROM_CURRENT = exports.FROM_START = exports.FILE_TRUNC = exports.FILE_CREATE = exports.FILE_APPEND = exports.FILE_RW = exports.FILE_WRITE = exports.FILE_READ = exports.NO_TX_WAVE = exports.WAVE_NOT_FOUND = exports.WAVE_MODE_REPEAT_SYNC = exports.WAVE_MODE_ONE_SHOT_SYNC = exports.WAVE_MODE_REPEAT = exports.WAVE_MODE_ONE_SHOT = exports.NTFY_FLAGS_GPIO = exports.NTFY_FLAGS_WDOG = exports.NTFY_FLAGS_ALIVE = exports.NTFY_FLAGS_EVENT = exports.PI_SCRIPT_FAILED = exports.PI_SCRIPT_WAITING = exports.PI_SCRIPT_RUNNING = exports.PI_SCRIPT_HALTED = exports.PI_SCRIPT_INITING = exports.PUD_UP = exports.PUD_DOWN = exports.PUD_OFF = exports.ALT5 = exports.ALT4 = exports.ALT3 = exports.ALT2 = exports.ALT1 = exports.ALT0 = exports.OUTPUT = exports.INPUT = exports.EITHER_EDGE = exports.FALLING_EDGE = exports.RISING_EDGE = exports.TIMEOUT = exports.SET = exports.HIGH = exports.ON = exports.CLEAR = exports.LOW = exports.OFF = exports.exceptions = void 0;
exports.PI_EMPTY_WAVEFORM = exports.PI_TOO_MANY_OOL = exports.PI_TOO_MANY_CBS = exports.PI_BAD_WAVE_ID = exports.PI_BAD_MILS_DELAY = exports.PI_BAD_MICS_DELAY = exports.PI_BAD_TAG = exports.PI_SCRIPT_NOT_READY = exports.PI_TOO_MANY_PARAM = exports.PI_SOCK_WRIT_FAILED = exports.PI_SOCK_READ_FAILED = exports.PI_NO_MEMORY = exports.PI_NO_SCRIPT_ROOM = exports.PI_BAD_VAR_NUM = exports.PI_BAD_SCRIPT_CMD = exports.PI_TOO_MANY_TAGS = exports.PI_DUP_TAG = exports.PI_BAD_PARAM_NUM = exports.PI_BAD_SERIAL_COUNT = exports.PI_GPIO_IN_USE = exports.PI_BAD_SER_OFFSET = exports.PI_BAD_SCRIPT_ID = exports.PI_BAD_SCRIPT = exports.PI_BAD_PULSELEN = exports.PI_BAD_WVSP_COMMND = exports.PI_BAD_WVSM_COMMND = exports.PI_BAD_WVSC_COMMND = exports.PI_SOME_PERMITTED = exports.PI_NOT_PERMITTED = exports.PI_NOT_SERIAL_GPIO = exports.PI_TOO_MANY_CHARS = exports.PI_TOO_MANY_PULSES = exports.PI_BAD_WAVE_BAUD = exports.PI_BAD_HANDLE = exports.PI_NO_HANDLE = exports.PI_BAD_DUTYRANGE = exports.PI_BAD_WDOG_TIMEOUT = exports.PI_BAD_DUTYCYCLE = exports.PI_BAD_PULSEWIDTH = exports.PI_BAD_PUD = exports.PI_BAD_LEVEL = exports.PI_BAD_MODE = exports.PI_BAD_GPIO = exports.PI_BAD_USER_GPIO = exports.EVENT_BSC = exports.SPI_RX_LSBFIRST = exports.SPI_TX_LSBFIRST = exports.SPI_CS_HIGH_ACTIVE = exports.SPI_CPOL = exports.SPI_CPHA = void 0;
exports.PI_BAD_FOREVER = exports.PI_BAD_SER_INVERT = exports.PI_DEPRECATED = exports.PI_CHAIN_TOO_BIG = exports.PI_CHAIN_NESTING = exports.PI_BAD_CHAIN_DELAY = exports.PI_BAD_CHAIN_CMD = exports.PI_CHAIN_COUNTER = exports.PI_BAD_CHAIN_LOOP = exports.PI_CHAIN_LOOP_CNT = exports.PI_BAD_I2C_BAUD = exports.PI_BAD_I2C_CMD = exports.PI_BAD_I2C_RLEN = exports.PI_BAD_I2C_WLEN = exports.PI_NOT_I2C_GPIO = exports.PI_BAD_SMBUS_CMD = exports.PI_BAD_MALLOC_MODE = exports.PI_MSG_TOOBIG = exports.PI_BAD_STOPBITS = exports.PI_BAD_DATABITS = exports.PI_HPWM_ILLEGAL = exports.PI_BAD_HCLK_PASS = exports.PI_BAD_HCLK_FREQ = exports.PI_BAD_HPWM_DUTY = exports.PI_BAD_HPWM_FREQ = exports.PI_NOT_HPWM_GPIO = exports.PI_NOT_HCLK_GPIO = exports.PI_NOT_SERVO_GPIO = exports.PI_NOT_PWM_GPIO = exports.PI_NO_AUX_SPI = exports.PI_SPI_XFER_FAILED = exports.PI_UNKNOWN_COMMAND = exports.PI_SER_READ_NO_DATA = exports.PI_SER_READ_FAILED = exports.PI_SER_WRITE_FAILED = exports.PI_BAD_SPI_COUNT = exports.PI_I2C_READ_FAILED = exports.PI_I2C_WRITE_FAILED = exports.PI_BAD_PARAM = exports.PI_BAD_SER_SPEED = exports.PI_BAD_SER_DEVICE = exports.PI_BAD_SPI_SPEED = exports.PI_BAD_FLAGS = exports.PI_BAD_SPI_CHANNEL = exports.PI_BAD_I2C_ADDR = exports.PI_BAD_I2C_BUS = exports.PI_SPI_OPEN_FAILED = exports.PI_SER_OPEN_FAILED = exports.PI_I2C_OPEN_FAILED = exports.PI_NO_WAVEFORM_ID = void 0;
exports.pi = exports.tickDiff = exports.error_text = exports.PI_ONLY_ON_BCM2711 = exports.PI_NOT_ON_BCM2711 = exports.PI_CMD_INTERRUPTED = exports.PI_BAD_EVENT_ID = exports.PI_NOT_SPI_GPIO = exports.PI_BAD_SPI_BAUD = exports.PI_BAD_SCRIPT_NAME = exports.PI_BAD_SHELL_STATUS = exports.PI_FILE_IS_A_DIR = exports.PI_NO_FILE_ACCESS = exports.PI_NO_FILE_MATCH = exports.PI_BAD_FILE_SEEK = exports.PI_FILE_NOT_WOPEN = exports.PI_FILE_NOT_ROPEN = exports.PI_BAD_FILE_WRITE = exports.PI_BAD_FILE_READ = exports.PI_BAD_FILE_FLAG = exports.PI_BAD_FILE_MODE = exports.PI_FIL_OPEN_FAILED = exports.PI_BAD_STRENGTH = exports.PI_BAD_PAD = exports.PI_BAD_FILTER = void 0;
const Commands_1 = require("./command/Commands");
const NotifySocket_1 = require("./NotifySocket");
const RequestSocket_1 = require("./RequestSocket");
exports.exceptions = false;
exports.exceptions = true;
// GPIO levels
exports.OFF = 0;
exports.LOW = 0;
exports.CLEAR = 0;
exports.ON = 1;
exports.HIGH = 1;
exports.SET = 1;
exports.TIMEOUT = 2;
// GPIO edges
exports.RISING_EDGE = 0;
exports.FALLING_EDGE = 1;
exports.EITHER_EDGE = 2;
// GPIO modes
exports.INPUT = 0;
exports.OUTPUT = 1;
exports.ALT0 = 4;
exports.ALT1 = 5;
exports.ALT2 = 6;
exports.ALT3 = 7;
exports.ALT4 = 3;
exports.ALT5 = 2;
// GPIO Pull Up Down
exports.PUD_OFF = 0;
exports.PUD_DOWN = 1;
exports.PUD_UP = 2;
// script run status
exports.PI_SCRIPT_INITING = 0;
exports.PI_SCRIPT_HALTED = 1;
exports.PI_SCRIPT_RUNNING = 2;
exports.PI_SCRIPT_WAITING = 3;
exports.PI_SCRIPT_FAILED = 4;
// notification flags
exports.NTFY_FLAGS_EVENT = 1 << 7;
exports.NTFY_FLAGS_ALIVE = 1 << 6;
exports.NTFY_FLAGS_WDOG = 1 << 5;
exports.NTFY_FLAGS_GPIO = 31;
// wave modes
exports.WAVE_MODE_ONE_SHOT = 0;
exports.WAVE_MODE_REPEAT = 1;
exports.WAVE_MODE_ONE_SHOT_SYNC = 2;
exports.WAVE_MODE_REPEAT_SYNC = 3;
exports.WAVE_NOT_FOUND = 9998; // Transmitted wave not found.
exports.NO_TX_WAVE = 9999; // No wave being transmitted.
exports.FILE_READ = 1;
exports.FILE_WRITE = 2;
exports.FILE_RW = 3;
exports.FILE_APPEND = 4;
exports.FILE_CREATE = 8;
exports.FILE_TRUNC = 16;
exports.FROM_START = 0;
exports.FROM_CURRENT = 1;
exports.FROM_END = 2;
exports.SPI_MODE_0 = 0;
exports.SPI_MODE_1 = 1;
exports.SPI_MODE_2 = 2;
exports.SPI_MODE_3 = 3;
exports.SPI_CPHA = 1 << 0;
exports.SPI_CPOL = 1 << 1;
exports.SPI_CS_HIGH_ACTIVE = 1 << 2;
exports.SPI_TX_LSBFIRST = 1 << 14;
exports.SPI_RX_LSBFIRST = 1 << 15;
exports.EVENT_BSC = 31;
// pigpio error numbers
const _PI_INIT_FAILED = -1;
exports.PI_BAD_USER_GPIO = -2;
exports.PI_BAD_GPIO = -3;
exports.PI_BAD_MODE = -4;
exports.PI_BAD_LEVEL = -5;
exports.PI_BAD_PUD = -6;
exports.PI_BAD_PULSEWIDTH = -7;
exports.PI_BAD_DUTYCYCLE = -8;
const _PI_BAD_TIMER = -9;
const _PI_BAD_MS = -10;
const _PI_BAD_TIMETYPE = -11;
const _PI_BAD_SECONDS = -12;
const _PI_BAD_MICROS = -13;
const _PI_TIMER_FAILED = -14;
exports.PI_BAD_WDOG_TIMEOUT = -15;
const _PI_NO_ALERT_FUNC = -16;
const _PI_BAD_CLK_PERIPH = -17;
const _PI_BAD_CLK_SOURCE = -18;
const _PI_BAD_CLK_MICROS = -19;
const _PI_BAD_BUF_MILLIS = -20;
exports.PI_BAD_DUTYRANGE = -21;
const _PI_BAD_SIGNUM = -22;
const _PI_BAD_PATHNAME = -23;
exports.PI_NO_HANDLE = -24;
exports.PI_BAD_HANDLE = -25;
const _PI_BAD_IF_FLAGS = -26;
const _PI_BAD_CHANNEL = -27;
const _PI_BAD_PRIM_CHANNEL = -27;
const _PI_BAD_SOCKET_PORT = -28;
const _PI_BAD_FIFO_COMMAND = -29;
const _PI_BAD_SECO_CHANNEL = -30;
const _PI_NOT_INITIALISED = -31;
const _PI_INITIALISED = -32;
const _PI_BAD_WAVE_MODE = -33;
const _PI_BAD_CFG_INTERNAL = -34;
exports.PI_BAD_WAVE_BAUD = -35;
exports.PI_TOO_MANY_PULSES = -36;
exports.PI_TOO_MANY_CHARS = -37;
exports.PI_NOT_SERIAL_GPIO = -38;
const _PI_BAD_SERIAL_STRUC = -39;
const _PI_BAD_SERIAL_BUF = -40;
exports.PI_NOT_PERMITTED = -41;
exports.PI_SOME_PERMITTED = -42;
exports.PI_BAD_WVSC_COMMND = -43;
exports.PI_BAD_WVSM_COMMND = -44;
exports.PI_BAD_WVSP_COMMND = -45;
exports.PI_BAD_PULSELEN = -46;
exports.PI_BAD_SCRIPT = -47;
exports.PI_BAD_SCRIPT_ID = -48;
exports.PI_BAD_SER_OFFSET = -49;
exports.PI_GPIO_IN_USE = -50;
exports.PI_BAD_SERIAL_COUNT = -51;
exports.PI_BAD_PARAM_NUM = -52;
exports.PI_DUP_TAG = -53;
exports.PI_TOO_MANY_TAGS = -54;
exports.PI_BAD_SCRIPT_CMD = -55;
exports.PI_BAD_VAR_NUM = -56;
exports.PI_NO_SCRIPT_ROOM = -57;
exports.PI_NO_MEMORY = -58;
exports.PI_SOCK_READ_FAILED = -59;
exports.PI_SOCK_WRIT_FAILED = -60;
exports.PI_TOO_MANY_PARAM = -61;
exports.PI_SCRIPT_NOT_READY = -62;
exports.PI_BAD_TAG = -63;
exports.PI_BAD_MICS_DELAY = -64;
exports.PI_BAD_MILS_DELAY = -65;
exports.PI_BAD_WAVE_ID = -66;
exports.PI_TOO_MANY_CBS = -67;
exports.PI_TOO_MANY_OOL = -68;
exports.PI_EMPTY_WAVEFORM = -69;
exports.PI_NO_WAVEFORM_ID = -70;
exports.PI_I2C_OPEN_FAILED = -71;
exports.PI_SER_OPEN_FAILED = -72;
exports.PI_SPI_OPEN_FAILED = -73;
exports.PI_BAD_I2C_BUS = -74;
exports.PI_BAD_I2C_ADDR = -75;
exports.PI_BAD_SPI_CHANNEL = -76;
exports.PI_BAD_FLAGS = -77;
exports.PI_BAD_SPI_SPEED = -78;
exports.PI_BAD_SER_DEVICE = -79;
exports.PI_BAD_SER_SPEED = -80;
exports.PI_BAD_PARAM = -81;
exports.PI_I2C_WRITE_FAILED = -82;
exports.PI_I2C_READ_FAILED = -83;
exports.PI_BAD_SPI_COUNT = -84;
exports.PI_SER_WRITE_FAILED = -85;
exports.PI_SER_READ_FAILED = -86;
exports.PI_SER_READ_NO_DATA = -87;
exports.PI_UNKNOWN_COMMAND = -88;
exports.PI_SPI_XFER_FAILED = -89;
const _PI_BAD_POINTER = -90;
exports.PI_NO_AUX_SPI = -91;
exports.PI_NOT_PWM_GPIO = -92;
exports.PI_NOT_SERVO_GPIO = -93;
exports.PI_NOT_HCLK_GPIO = -94;
exports.PI_NOT_HPWM_GPIO = -95;
exports.PI_BAD_HPWM_FREQ = -96;
exports.PI_BAD_HPWM_DUTY = -97;
exports.PI_BAD_HCLK_FREQ = -98;
exports.PI_BAD_HCLK_PASS = -99;
exports.PI_HPWM_ILLEGAL = -100;
exports.PI_BAD_DATABITS = -101;
exports.PI_BAD_STOPBITS = -102;
exports.PI_MSG_TOOBIG = -103;
exports.PI_BAD_MALLOC_MODE = -104;
const _PI_TOO_MANY_SEGS = -105;
const _PI_BAD_I2C_SEG = -106;
exports.PI_BAD_SMBUS_CMD = -107;
exports.PI_NOT_I2C_GPIO = -108;
exports.PI_BAD_I2C_WLEN = -109;
exports.PI_BAD_I2C_RLEN = -110;
exports.PI_BAD_I2C_CMD = -111;
exports.PI_BAD_I2C_BAUD = -112;
exports.PI_CHAIN_LOOP_CNT = -113;
exports.PI_BAD_CHAIN_LOOP = -114;
exports.PI_CHAIN_COUNTER = -115;
exports.PI_BAD_CHAIN_CMD = -116;
exports.PI_BAD_CHAIN_DELAY = -117;
exports.PI_CHAIN_NESTING = -118;
exports.PI_CHAIN_TOO_BIG = -119;
exports.PI_DEPRECATED = -120;
exports.PI_BAD_SER_INVERT = -121;
const _PI_BAD_EDGE = -122;
const _PI_BAD_ISR_INIT = -123;
exports.PI_BAD_FOREVER = -124;
exports.PI_BAD_FILTER = -125;
exports.PI_BAD_PAD = -126;
exports.PI_BAD_STRENGTH = -127;
exports.PI_FIL_OPEN_FAILED = -128;
exports.PI_BAD_FILE_MODE = -129;
exports.PI_BAD_FILE_FLAG = -130;
exports.PI_BAD_FILE_READ = -131;
exports.PI_BAD_FILE_WRITE = -132;
exports.PI_FILE_NOT_ROPEN = -133;
exports.PI_FILE_NOT_WOPEN = -134;
exports.PI_BAD_FILE_SEEK = -135;
exports.PI_NO_FILE_MATCH = -136;
exports.PI_NO_FILE_ACCESS = -137;
exports.PI_FILE_IS_A_DIR = -138;
exports.PI_BAD_SHELL_STATUS = -139;
exports.PI_BAD_SCRIPT_NAME = -140;
exports.PI_BAD_SPI_BAUD = -141;
exports.PI_NOT_SPI_GPIO = -142;
exports.PI_BAD_EVENT_ID = -143;
exports.PI_CMD_INTERRUPTED = -144;
exports.PI_NOT_ON_BCM2711 = -145;
exports.PI_ONLY_ON_BCM2711 = -146;
/** Gets error text from error number */
function error_text(errnum) {
var _a;
const errorMessages = {
[_PI_INIT_FAILED]: 'pigpio initialisation failed',
[exports.PI_BAD_USER_GPIO]: 'GPIO not 0-31',
[exports.PI_BAD_GPIO]: 'GPIO not 0-53',
[exports.PI_BAD_MODE]: 'mode not 0-7',
[exports.PI_BAD_LEVEL]: 'level not 0-1',
[exports.PI_BAD_PUD]: 'pud not 0-2',
[exports.PI_BAD_PULSEWIDTH]: 'pulsewidth not 0 or 500-2500',
[exports.PI_BAD_DUTYCYCLE]: 'dutycycle not 0-range (default 255)',
[_PI_BAD_TIMER]: 'timer not 0-9',
[_PI_BAD_MS]: 'ms not 10-60000',
[_PI_BAD_TIMETYPE]: 'timetype not 0-1',
[_PI_BAD_SECONDS]: 'seconds < 0',
[_PI_BAD_MICROS]: 'micros not 0-999999',
[_PI_TIMER_FAILED]: 'gpioSetTimerFunc failed',
[exports.PI_BAD_WDOG_TIMEOUT]: 'timeout not 0-60000',
[_PI_NO_ALERT_FUNC]: 'DEPRECATED',
[_PI_BAD_CLK_PERIPH]: 'clock peripheral not 0-1',
[_PI_BAD_CLK_SOURCE]: 'DEPRECATED',
[_PI_BAD_CLK_MICROS]: 'clock micros not 1, 2, 4, 5, 8, or 10',
[_PI_BAD_BUF_MILLIS]: 'buf millis not 100-10000',
[exports.PI_BAD_DUTYRANGE]: 'dutycycle range not 25-40000',
[_PI_BAD_SIGNUM]: 'signum not 0-63',
[_PI_BAD_PATHNAME]: "can't open pathname",
[exports.PI_NO_HANDLE]: 'no handle available',
[exports.PI_BAD_HANDLE]: 'unknown handle',
[_PI_BAD_IF_FLAGS]: 'ifFlags > 4',
[_PI_BAD_CHANNEL]: 'DMA channel not 0-14',
[_PI_BAD_PRIM_CHANNEL]: 'DMA primary channel not 0-15',
[_PI_BAD_SOCKET_PORT]: 'socket port not 1024-30000',
[_PI_BAD_FIFO_COMMAND]: 'unknown fifo command',
[_PI_BAD_SECO_CHANNEL]: 'DMA secondary channel not 0-14',
[_PI_NOT_INITIALISED]: 'function called before gpioInitialise',
[_PI_INITIALISED]: 'function called after gpioInitialise',
[_PI_BAD_WAVE_MODE]: 'waveform mode not 0-1',
[_PI_BAD_CFG_INTERNAL]: 'bad parameter in gpioCfgInternals call',
[exports.PI_BAD_WAVE_BAUD]: 'baud rate not 50-250K(RX)/50-1M(TX)',
[exports.PI_TOO_MANY_PULSES]: 'waveform has too many pulses',
[exports.PI_TOO_MANY_CHARS]: 'waveform has too many chars',
[exports.PI_NOT_SERIAL_GPIO]: 'no bit bang serial read in progress on GPIO',
[_PI_BAD_SERIAL_STRUC]: 'bad (null) serial structure parameter',
[_PI_BAD_SERIAL_BUF]: 'bad (null) serial buf parameter',
[exports.PI_NOT_PERMITTED]: 'no permission to update GPIO',
[exports.PI_SOME_PERMITTED]: 'no permission to update one or more GPIO',
[exports.PI_BAD_WVSC_COMMND]: 'bad WVSC subcommand',
[exports.PI_BAD_WVSM_COMMND]: 'bad WVSM subcommand',
[exports.PI_BAD_WVSP_COMMND]: 'bad WVSP subcommand',
[exports.PI_BAD_PULSELEN]: 'trigger pulse length not 1-100',
[exports.PI_BAD_SCRIPT]: 'invalid script',
[exports.PI_BAD_SCRIPT_ID]: 'unknown script id',
[exports.PI_BAD_SER_OFFSET]: 'add serial data offset > 30 minute',
[exports.PI_GPIO_IN_USE]: 'GPIO already in use',
[exports.PI_BAD_SERIAL_COUNT]: 'must read at least a byte at a time',
[exports.PI_BAD_PARAM_NUM]: 'script parameter id not 0-9',
[exports.PI_DUP_TAG]: 'script has duplicate tag',
[exports.PI_TOO_MANY_TAGS]: 'script has too many tags',
[exports.PI_BAD_SCRIPT_CMD]: 'illegal script command',
[exports.PI_BAD_VAR_NUM]: 'script variable id not 0-149',
[exports.PI_NO_SCRIPT_ROOM]: 'no more room for scripts',
[exports.PI_NO_MEMORY]: "can't allocate temporary memory",
[exports.PI_SOCK_READ_FAILED]: 'socket read failed',
[exports.PI_SOCK_WRIT_FAILED]: 'socket write failed',
[exports.PI_TOO_MANY_PARAM]: 'too many script parameters (> 10)',
[exports.PI_SCRIPT_NOT_READY]: 'script initialising',
[exports.PI_BAD_TAG]: 'script has unresolved tag',
[exports.PI_BAD_MICS_DELAY]: 'bad MICS delay (too large)',
[exports.PI_BAD_MILS_DELAY]: 'bad MILS delay (too large)',
[exports.PI_BAD_WAVE_ID]: 'non existent wave id',
[exports.PI_TOO_MANY_CBS]: 'No more CBs for waveform',
[exports.PI_TOO_MANY_OOL]: 'No more OOL for waveform',
[exports.PI_EMPTY_WAVEFORM]: 'attempt to create an empty waveform',
[exports.PI_NO_WAVEFORM_ID]: 'no more waveform ids',
[exports.PI_I2C_OPEN_FAILED]: "can't open I2C device",
[exports.PI_SER_OPEN_FAILED]: "can't open serial device",
[exports.PI_SPI_OPEN_FAILED]: "can't open SPI device",
[exports.PI_BAD_I2C_BUS]: 'bad I2C bus',
[exports.PI_BAD_I2C_ADDR]: 'bad I2C address',
[exports.PI_BAD_SPI_CHANNEL]: 'bad SPI channel',
[exports.PI_BAD_FLAGS]: 'bad i2c/spi/ser open flags',
[exports.PI_BAD_SPI_SPEED]: 'bad SPI speed',
[exports.PI_BAD_SER_DEVICE]: 'bad serial device name',
[exports.PI_BAD_SER_SPEED]: 'bad serial baud rate',
[exports.PI_BAD_PARAM]: 'bad i2c/spi/ser parameter',
[exports.PI_I2C_WRITE_FAILED]: 'I2C write failed',
[exports.PI_I2C_READ_FAILED]: 'I2C read failed',
[exports.PI_BAD_SPI_COUNT]: 'bad SPI count',
[exports.PI_SER_WRITE_FAILED]: 'ser write failed',
[exports.PI_SER_READ_FAILED]: 'ser read failed',
[exports.PI_SER_READ_NO_DATA]: 'ser read no data available',
[exports.PI_UNKNOWN_COMMAND]: 'unknown command',
[exports.PI_SPI_XFER_FAILED]: 'spi xfer/read/write failed',
[_PI_BAD_POINTER]: 'bad (NULL) pointer',
[exports.PI_NO_AUX_SPI]: 'no auxiliary SPI on Pi A or B',
[exports.PI_NOT_PWM_GPIO]: 'GPIO is not in use for PWM',
[exports.PI_NOT_SERVO_GPIO]: 'GPIO is not in use for servo pulses',
[exports.PI_NOT_HCLK_GPIO]: 'GPIO has no hardware clock',
[exports.PI_NOT_HPWM_GPIO]: 'GPIO has no hardware PWM',
[exports.PI_BAD_HPWM_FREQ]: 'invalid hardware PWM frequency',
[exports.PI_BAD_HPWM_DUTY]: 'hardware PWM dutycycle not 0-1M',
[exports.PI_BAD_HCLK_FREQ]: 'invalid hardware clock frequency',
[exports.PI_BAD_HCLK_PASS]: 'need password to use hardware clock 1',
[exports.PI_HPWM_ILLEGAL]: 'illegal, PWM in use for main clock',
[exports.PI_BAD_DATABITS]: 'serial data bits not 1-32',
[exports.PI_BAD_STOPBITS]: 'serial (half) stop bits not 2-8',
[exports.PI_MSG_TOOBIG]: 'socket/pipe message too big',
[exports.PI_BAD_MALLOC_MODE]: 'bad memory allocation mode',
[_PI_TOO_MANY_SEGS]: 'too many I2C transaction segments',
[_PI_BAD_I2C_SEG]: 'an I2C transaction segment failed',
[exports.PI_BAD_SMBUS_CMD]: 'SMBus command not supported by driver',
[exports.PI_NOT_I2C_GPIO]: 'no bit bang I2C in progress on GPIO',
[exports.PI_BAD_I2C_WLEN]: 'bad I2C write length',
[exports.PI_BAD_I2C_RLEN]: 'bad I2C read length',
[exports.PI_BAD_I2C_CMD]: 'bad I2C command',
[exports.PI_BAD_I2C_BAUD]: 'bad I2C baud rate, not 50-500k',
[exports.PI_CHAIN_LOOP_CNT]: 'bad chain loop count',
[exports.PI_BAD_CHAIN_LOOP]: 'empty chain loop',
[exports.PI_CHAIN_COUNTER]: 'too many chain counters',
[exports.PI_BAD_CHAIN_CMD]: 'bad chain command',
[exports.PI_BAD_CHAIN_DELAY]: 'bad chain delay micros',
[exports.PI_CHAIN_NESTING]: 'chain counters nested too deeply',
[exports.PI_CHAIN_TOO_BIG]: 'chain is too long',
[exports.PI_DEPRECATED]: 'deprecated function removed',
[exports.PI_BAD_SER_INVERT]: 'bit bang serial invert not 0 or 1',
[_PI_BAD_EDGE]: 'bad ISR edge, not 1, 1, or 2',
[_PI_BAD_ISR_INIT]: 'bad ISR initialisation',
[exports.PI_BAD_FOREVER]: 'loop forever must be last chain command',
[exports.PI_BAD_FILTER]: 'bad filter parameter',
[exports.PI_BAD_PAD]: 'bad pad number',
[exports.PI_BAD_STRENGTH]: 'bad pad drive strength',
[exports.PI_FIL_OPEN_FAILED]: 'file open failed',
[exports.PI_BAD_FILE_MODE]: 'bad file mode',
[exports.PI_BAD_FILE_FLAG]: 'bad file flag',
[exports.PI_BAD_FILE_READ]: 'bad file read',
[exports.PI_BAD_FILE_WRITE]: 'bad file write',
[exports.PI_FILE_NOT_ROPEN]: 'file not open for read',
[exports.PI_FILE_NOT_WOPEN]: 'file not open for write',
[exports.PI_BAD_FILE_SEEK]: 'bad file seek',
[exports.PI_NO_FILE_MATCH]: 'no files match pattern',
[exports.PI_NO_FILE_ACCESS]: 'no permission to access file',
[exports.PI_FILE_IS_A_DIR]: 'file is a directory',
[exports.PI_BAD_SHELL_STATUS]: 'bad shell return status',
[exports.PI_BAD_SCRIPT_NAME]: 'bad script name',
[exports.PI_BAD_SPI_BAUD]: 'bad SPI baud rate, not 50-500k',
[exports.PI_NOT_SPI_GPIO]: 'no bit bang SPI in progress on GPIO',
[exports.PI_BAD_EVENT_ID]: 'bad event id',
[exports.PI_CMD_INTERRUPTED]: 'command interrupted, Python',
[exports.PI_NOT_ON_BCM2711]: 'not available on BCM2711',
[exports.PI_ONLY_ON_BCM2711]: 'only available on BCM2711',
};
return (_a = errorMessages[errnum]) !== null && _a !== void 0 ? _a : `unknown error (${errnum}))`;
}
exports.error_text = error_text;
/**
* Returns the microsecond difference between two ticks.
* @param t1 - the earlier tick
* @param t2 - the later tick
* ```ts
* console.log(tickDiff(4294967272, 12)) // 36
* ```
*/
function tickDiff(t1, t2) {
let tDiff = t2 - t1;
if (tDiff < 0) {
tDiff += 2 ** 32;
}
return tDiff;
}
exports.tickDiff = tickDiff;
/** This is low level interface.
* It is the same feature as the original python library except that all requests are asynchronous.
* http://abyz.me.uk/rpi/pigpio/python.html
* */
async function pi(host, port) {
const hostname = host || process.env.PIGPIO_ADDR || 'localhost';
const portnumber = port || Number(process.env.PIGPIO_PORT) || 8888;
const reqSocket = await RequestSocket_1.createRequestSocket(portnumber, hostname);
const notifySocket = await NotifySocket_1.createNotifySocket(portnumber, hostname, reqSocket);
const reqParam = Commands_1.createRequestParam;
const pigpioCommand = async (request) => {
const res = (await reqSocket.request(request)).res;
if (res < 0 && exports.exceptions) {
throw Error(error_text(res));
}
return res;
};
const pigpioCommandExt = async (request) => {
var _a;
const r = await reqSocket.request(request);
if (r.res < 0 && exports.exceptions) {
throw Error(error_text(r.res));
}
return [r.res, (_a = r.extension) !== null && _a !== void 0 ? _a : Buffer.of()];
};
class PiImpl {
async stop() {
await notifySocket.close();
await reqSocket.close();
}
set_mode(gpio, mode) {
return pigpioCommand(reqParam({ command: 'MODES', gpio, mode }));
}
get_mode(gpio) {
return pigpioCommand(reqParam({ command: 'MODEG', gpio }));
}
set_pull_up_down(gpio, pud) {
return pigpioCommand(reqParam({ command: 'PUD', gpio, pud }));
}
read(gpio) {
return pigpioCommand(reqParam({ command: 'READ', gpio }));
}
write(gpio, level) {
return pigpioCommand(reqParam({ command: 'WRITE', gpio, level }));
}
set_PWM_dutycycle(user_gpio, dutycycle) {
return pigpioCommand(reqParam({ command: 'PWM', gpio: user_gpio, dutycycle }));
}
set_PWM_frequency(user_gpio, frequency) {
return pigpioCommand(reqParam({ command: 'PFS', gpio: user_gpio, frequency }));
}
set_PWM_range(user_gpio, range) {
return pigpioCommand(reqParam({ command: 'PRS', gpio: user_gpio, range }));
}
get_PWM_dutycycle(user_gpio) {
return pigpioCommand(reqParam({ command: 'GDC', gpio: user_gpio }));
}
get_PWM_frequency(user_gpio) {
return pigpioCommand(reqParam({ command: 'PFG', gpio: user_gpio }));
}
get_PWM_range(user_gpio) {
return pigpioCommand(reqParam({ command: 'PRG', gpio: user_gpio }));
}
get_PWM_real_range(user_gpio) {
return pigpioCommand(reqParam({ command: 'PRRG', gpio: user_gpio }));
}
set_servo_pulsewidth(user_gpio, pulsewidth) {
return pigpioCommand(reqParam({ command: 'SERVO', gpio: user_gpio, pulsewidth }));
}
get_servo_pulsewidth(user_gpio) {
return pigpioCommand(reqParam({ command: 'GPW', gpio: user_gpio }));
}
gpio_trigger(user_gpio, pulse_len, level) {
const extension = Buffer.alloc(4);
extension.writeUInt32LE(level);
return pigpioCommand(reqParam({
command: 'TRIG',
gpio: user_gpio,
pulselen: pulse_len,
extension,
}));
}
set_watchdog(user_gpio, wdog_timeout) {
return pigpioCommand(reqParam({ command: 'WDOG', gpio: user_gpio, timeout: wdog_timeout }));
}
read_bank_1() {
return pigpioCommand(reqParam({ command: 'BR1' }));
}
read_bank_2() {
return pigpioCommand(reqParam({ command: 'BR2' }));
}
clear_bank_1(bits) {
return pigpioCommand(reqParam({ command: 'BC1', bits }));
}
clear_bank_2(bits) {
return pigpioCommand(reqParam({ command: 'BC2', bits }));
}
set_bank_1(bits) {
return pigpioCommand(reqParam({ command: 'BS1', bits }));
}
set_bank_2(bits) {
return pigpioCommand(reqParam({ command: 'BS2', bits }));
}
callback(user_gpio, edge, func) {
let count = 0;
const f = func !== null && func !== void 0 ? func : (() => {
count += 1;
});
const ev = {
gpio: user_gpio,
edge,
bit: 1 << user_gpio,
func: f,
};
notifySocket.append(ev);
const e = {
cancel: () => {
notifySocket.remove(ev);
},
tally: () => {
return count;
},
reset_tally: () => {
count = 0;
},
};
return e;
}
wait_for_edge(user_gpio, edge, wait_timeout) {
return new Promise((resolve) => {
const e = this.callback(user_gpio, edge, () => {
resolve(true);
e.cancel();
});
if (wait_timeout != null) {
setTimeout(() => {
resolve(false);
e.cancel();
}, wait_timeout * 1000);
}
});
}
notify_open() {
return pigpioCommand(reqParam({ command: 'NO' }));
}
notify_begin(handle, bits) {
return pigpioCommand(reqParam({ command: 'NB', handle, bits }));
}
notify_pause(handle) {
return pigpioCommand(reqParam({ command: 'NB', handle, bits: 0 }));
}
notify_close(handle) {
return pigpioCommand(reqParam({ command: 'NC', handle }));
}
hardware_clock(gpio, clkfreq) {
return pigpioCommand(reqParam({ command: 'HC', gpio, frequency: clkfreq }));
}
hardware_PWM(gpio, PWMfreq, PWMduty) {
const extension = Buffer.alloc(4);
extension.writeUInt32LE(PWMduty);
return pigpioCommand(reqParam({ command: 'HP', gpio, frequency: PWMfreq, extension }));
}
set_glitch_filter(user_gpio, steady) {
return pigpioCommand(reqParam({ command: 'FG', gpio: user_gpio, steady }));
}
set_noise_filter(user_gpio, steady, active) {
const extension = Buffer.alloc(4);
extension.writeUInt32LE(active);
return pigpioCommand(reqParam({ command: 'FN', gpio: user_gpio, steady, extension }));
}
set_pad_strength(pad, pad_strength) {
return pigpioCommand(reqParam({ command: 'PADS', pad, strength: pad_strength }));
}
get_pad_strength(pad) {
return pigpioCommand(reqParam({ command: 'PADG', pad }));
}
shell(shellscr, pstring) {
const extension = Buffer.from(shellscr + '\0' + pstring, 'utf-8');
return pigpioCommand(reqParam({ command: 'SHELL', 'len(name)': shellscr.length, extension }));
}
custom_1(arg1 = 0, arg2 = 0, argx = Buffer.of()) {
return pigpioCommand(reqParam({ command: 'CF1', arg1, arg2, extension: argx }));
}
custom_2(arg1 = 0, argx = Buffer.of(), retMax = 0) {
return pigpioCommandExt(reqParam({ command: 'CF2', arg1, retMax, extension: argx }));
}
event_callback(event, func) {
let count = 0;
const f = func !== null && func !== void 0 ? func : (() => {
count += 1;
});
const ev = {
event,
bit: 1 << event,
func: f,
};
notifySocket.appendEvent(ev);
const e = {
cancel: () => {
notifySocket.removeEvent(ev);
},
tally: () => {
return count;
},
reset_tally: () => {
count = 0;
},
};
return e;
}
event_trigger(event) {
return pigpioCommand(reqParam({ command: 'EVT', event }));
}
wait_for_event(event, wait_timeout) {
return new Promise((resolve) => {
const e = this.event_callback(event, () => {
resolve(true);
e.cancel();
});
setTimeout(() => {
resolve(false);
e.cancel();
}, wait_timeout * 1000);
});
}
store_script(script) {
return pigpioCommand(reqParam({ command: 'PROC', extension: Buffer.from(script, 'utf-8') }));
}
run_script(script_id, params) {
const extension = Buffer.alloc(params.length * 4);
params.forEach((p, index) => {
extension.writeUInt32LE(p, index * 4);
});
return pigpioCommand(reqParam({ command: 'PROCR', script_id, extension }));
}
update_script(script_id, params) {
const extension = Buffer.alloc(params.length * 4);
params.forEach((p, index) => {
extension.writeUInt32LE(p, index * 4);
});
return pigpioCommand(reqParam({ command: 'PROCU', script_id, extension }));
}
async script_status(script_id) {
const [res, d] = await pigpioCommandExt(reqParam({ command: 'PROCP', script_id }));
if (res === 0) {
return [0, []];
}
const status = d.readInt32LE();
const params = [];
let offset = 4;
while (offset + 4 < d.length) {
params.push(d.readInt32LE(offset));
offset += 4;
}
return [status, params];
}
stop_script(script_id) {
return pigpioCommand(reqParam({ command: 'PROCS', script_id }));
}
delete_script(script_id) {
return pigpioCommand(reqParam({ command: 'PROCD', script_id }));
}
i2c_open(i2c_bus, i2c_address, i2c_flags = 0) {
const extension = Buffer.alloc(4);
extension.writeUInt32LE(i2c_flags);
return pigpioCommand(reqParam({
command: 'I2CO',
bus: i2c_bus,
device: i2c_address,
extension,
}));
}
i2c_close(handle) {
return pigpioCommand(reqParam({ command: 'I2CC', handle }));
}
i2c_write_quick(handle, bit) {
return pigpioCommand(reqParam({ command: 'I2CWQ', handle, bit }));
}
i2c_read_byte(handle) {
return pigpioCommand(reqParam({ command: 'I2CRS', handle }));
}
i2c_write_byte(handle, byte_val) {
return pigpioCommand(reqParam({ command: 'I2CWS', handle, byte: byte_val }));
}
i2c_read_byte_data(handle, reg) {
return pigpioCommand(reqParam({ command: 'I2CRB', handle, register: reg }));
}
i2c_write_byte_data(handle, reg, byte_val) {
const extension = Buffer.alloc(4);
extension.writeUInt32LE(byte_val);
return pigpioCommand(reqParam({ command: 'I2CWB', handle, register: reg, extension }));
}
i2c_read_word_data(handle, reg) {
return pigpioCommand(reqParam({ command: 'I2CRW', handle, register: reg }));
}
i2c_write_word_data(handle, reg, word_val) {
const extension = Buffer.alloc(4);
extension.writeUInt32LE(word_val);
return pigpioCommand(reqParam({ command: 'I2CWW', handle, register: reg, extension }));
}
i2c_read_block_data(handle, reg) {
return pigpioCommandExt(reqParam({ command: 'I2CRK', handle, register: reg }));
}
i2c_write_block_data(handle, reg, data) {
return pigpioCommand(reqParam({ command: 'I2CWK', handle, register: reg, extension: data }));
}
i2c_read_i2c_block_data(handle, reg, count) {
const extension = Buffer.alloc(4);
extension.writeUInt32LE(count);
return pigpioCommandExt(reqParam({ command: 'I2CRI', handle, register: reg, extension }));
}
i2c_write_i2c_block_data(handle, reg, data) {
return pigpioCommand(reqParam({ command: 'I2CWI', handle, register: reg, extension: data }));
}
i2c_read_device(handle, count) {
return pigpioCommandExt(reqParam({ command: 'I2CRD', handle, count }));
}
i2c_write_device(handle, data) {
return pigpioCommand(reqParam({ command: 'I2CWD', handle, extension: data }));
}
i2c_process_call(handle, reg, word_val) {
const extension = Buffer.alloc(4);
extension.writeUInt32LE(word_val);
return pigpioCommand(reqParam({ command: 'I2CPC', handle, register: reg, extension }));
}
i2c_block_process_call(handle, reg, data) {
return pigpioCommandExt(reqParam({ command: 'I2CPC', handle, register: reg, extension: data }));
}
i2c_zip(handle, data) {
return pigpioCommandExt(reqParam({ command: 'I2CZ', handle, extension: data }));
}
bb_i2c_open(SDA, SCL, baud) {
const extension = Buffer.alloc(4);
extension.writeUInt32LE(baud);
return pigpioCommand(reqParam({ command: 'BI2CO', sda: SDA, scl: SCL, extension }));
}
bb_i2c_close(SDA) {
return pigpioCommand(reqParam({ command: 'BI2CC', sda: SDA }));
}
bb_i2c_zip(SDA, data) {
return pigpioCommandExt(reqParam({ command: 'BI2CZ', sda: SDA, extension: data }));
}
async bsc_xfer(bsc_control, data) {
const [res, d] = await pigpioCommandExt(reqParam({ command: 'BSCX', control: bsc_control, extension: data }));
if (res === 0) {
return [0, 0, d];
}
const status = d.readInt32LE();
return [status, res - 4, d];
}
bsc_i2c(i2c_address, data) {
const control = i2c_address ? (i2c_address << 16) | 0x305 : 0;
return this.bsc_xfer(control, data);
}
serial_open(tty, baud, ser_flags = 0) {
return pigpioCommand(reqParam({
command: 'SERO',
baud,
flags: ser_flags,
extension: Buffer.from(tty, 'utf-8'),
}));
}
serial_close(handle) {
return pigpioCommand(reqParam({ command: 'SERC', handle }));
}
serial_read_byte(handle) {
return pigpioCommand(reqParam({ command: 'SERRB', handle }));
}
serial_write_byte(handle, byte_val) {
return pigpioCommand(reqParam({ command: 'SERWB', handle, byte: byte_val }));
}
serial_read(handle, count) {
return pigpioCommandExt(reqParam({ command: 'SERR', handle, count }));
}
serial_write(handle, data) {
return pigpioCommand(reqParam({ command: 'SERW', handle, extension: data }));
}
serial_data_available(handle) {
return pigpioCommand(reqParam({ command: 'SERDA', handle }));
}
bb_serial_read_open(user_gpio, baud, bb_bits) {
const extension = Buffer.alloc(4);
extension.writeUInt32LE(bb_bits);
return pigpioCommand(reqParam({ command: 'SLRO', gpio: user_gpio, baud, extension }));
}
bb_serial_read_close(user_gpio) {
return pigpioCommand(reqParam({ command: 'SLRC', gpio: user_gpio }));
}
bb_serial_invert(user_gpio, invert) {
return pigpioCommand(reqParam({ command: 'SLRI', gpio: user_gpio, invert }));
}
bb_serial_read(user_gpio) {
return pigpioCommandExt(reqParam({ command: 'SLR', gpio: user_gpio, count: 10000 }));
}
spi_open(spi_channel, baud, spi_flags = 0) {
const extension = Buffer.alloc(4);
extension.writeUInt32LE(spi_flags);
return pigpioCommand(reqParam({ command: 'SPIO', channel: spi_channel, baud, extension }));
}
spi_close(handle) {
return pigpioCommand(reqParam({ command: 'SPIC', handle }));
}
spi_read(handle, count) {
return pigpioCommandExt(reqParam({ command: 'SPIR', handle, count }));
}
spi_write(handle, data) {
return pigpioCommand(reqParam({ command: 'SPIW', handle, extension: data }));
}
spi_xfer(handle, data) {
return pigpioCommandExt(reqParam({ command: 'SPIX', handle, extension: data }));
}
bb_spi_open(CS, MISO, MOSI, SCLK, baud, spiFlags = 0) {
const extension = Buffer.alloc(20);
extension.writeUInt32LE(MISO, 0);
extension.writeUInt32LE(MOSI, 4);
extension.writeUInt32LE(SCLK, 8);
extension.writeUInt32LE(baud, 12);
extension.writeUInt32LE(spiFlags, 16);
return pigpioCommand(reqParam({ command: 'BSPIO', CS, extension }));
}
bb_spi_close(CS) {
return pigpioCommand(reqParam({ command: 'BSPIC', CS }));
}
bb_spi_xfer(CS, data) {
return pigpioCommandExt(reqParam({ command: 'BSPIX', CS, extension: data }));
}
file_open(file_name, file_mode) {
return pigpioCommand(reqParam({
command: 'FO',
mode: file_mode,
extension: Buffer.from(file_name, 'utf-8'),
}));
}
file_close(handle) {
return pigpioCommand(reqParam({ command: 'FC', handle }));
}
file_read(handle, count) {
return pigpioCommandExt(reqParam({ command: 'FR', handle, count }));
}
file_write(handle, data) {
return pigpioCommand(reqParam({ command: 'FW', handle, extension: data }));
}
file_seek(handle, seek_offset, seek_from) {
const extension = Buffer.alloc(4);
extension.writeUInt32LE(seek_from);
return pigpioCommand(reqParam({ command: 'FS', handle, offset: seek_offset, extension }));
}
file_list(file_name) {
return pigpioCommandExt(reqParam({
command: 'FL',
count: 60000,
extension: Buffer.from(file_name, 'utf-8'),
}));
}
wave_clear() {
return pigpioCommand(reqParam({ command: 'WVCLR' }));
}
wave_add_new() {
return pigpioCommand(reqParam({ command: 'WVNEW' }));
}
wave_add_generic(pulses) {
const extension = Buffer.alloc(pulses.length * 12);
pulses.forEach((p, index) => {
extension.writeUInt32LE(p.gpio_on, index * 12);
extension.writeUInt32LE(p.gpio_off, index * 12 + 4);
extension.writeUInt32LE(p.delay, index * 12 + 8);
});
return pigpioCommand(reqParam({ command: 'WVAG', extension }));
}
wave_add_serial(user_gpio, baud, data, offset = 0, bb_bits = 8, bb_stop = 2) {
const extension = Buffer.alloc(data.length + 12);
extension.writeUInt32LE(bb_bits, 0);
extension.writeUInt32LE(bb_stop, 4);
extension.writeUInt32LE(offset, 8);
extension.set(data, 12);
return pigpioCommand(reqParam({ command: 'WVAS', gpio: user_gpio, baud, extension }));
}
wave_create() {
return pigpioCommand(reqParam({ command: 'WVCRE' }));
}
wave_create_and_pad(percent) {
return pigpioCommand(reqParam({ command: 'WVCAP', percent }));
}
wave_delete(wave_id) {
return pigpioCommand(reqParam({ command: 'WVDEL', wave_id }));
}
wave_send_once(wave_id) {
return pigpioCommand(reqParam({ command: 'WVTX', wave_id }));
}
wave_send_repeat(wave_id) {
return pigpioCommand(reqParam({ command: 'WVTXR', wave_id }));
}
wave_send_using_mode(wave_id, mode) {
return pigpioCommand(reqParam({ command: 'WVTXM', wave_id, mode }));
}
wave_chain(data) {
return pigpioCommand(reqParam({ command: 'WVCHA', extension: data }));
}
wave_tx_at() {
return pigpioCommand(reqParam({ command: 'WVTAT' }));
}
wave_tx_busy() {
return pigpioCommand(reqParam({ command: 'WVBSY' }));
}
wave_tx_stop() {
return pigpioCommand(reqParam({ command: 'WVHLT' }));
}
wave_get_cbs() {
return pigpioCommand(reqParam({ command: 'WVSC', subcmd: 0 }));
}
wave_get_max_cbs() {
return pigpioCommand(reqParam({ command: 'WVSC', subcmd: 2 }));
}
wave_get_micros() {
return pigpioCommand(reqParam({ command: 'WVSM', subcmd: 0 }));
}
wave_get_max_micros() {
return pigpioCommand(reqParam({ command: 'WVSM', subcmd: 2 }));
}
wave_get_pulses() {
return pigpioCommand(reqParam({ command: 'WVSP', subcmd: 0 }));
}
wave_get_max_pulses() {
return pigpioCommand(reqParam({ command: 'WVSP', subcmd: 2 }));
}
get_current_tick() {
return pigpioCommand(reqParam({ command: 'TICK' }));
}
get_hardware_revision() {
return pigpioCommand(reqParam({ command: 'HWVER' }));
}
get_pigpio_version() {
return pigpioCommand(reqParam({ command: 'PIGPV' }));
}
get connected() {
return reqSocket.connected;
}
}
return new PiImpl();
}
exports.pi = pi;