ixfx
    Preparing search index...

    Class EspruinoSerialDevice

    Serial device. Assumes data is sent with new line characters (\r\n) between messages.

    import { Serial } from 'https://unpkg.com/ixfx/dist/io.js'
    const s = new Serial.Device();
    s.addEventListener(`change`, evt => {
     console.log(`State change ${evt.priorState} -> ${evt.newState}`);
     if (evt.newState === `connected`) {
       // Do something when connected...
     }
    });

    // In a UI event handler...
    s.connect();

    Reading incoming data:

    // Parse incoming data as JSON
    s.addEventListener(`data`, evt => {
     try {
       const o = JSON.parse(evt.data);
       // If we get this far, JSON is legit
     } catch (ex) {
     }
    });

    Writing to the microcontroller

    s.write(JSON.stringify({msg:"hello"}));

    Hierarchy (View Summary)

    Constructors

    constructor

    Properties

    abort baudRate chunkSize codec connectAttempts evalReplyBluetooth evalTimeoutMs name port rxBuffer states tx txBuffer verboseLogging

    Accessors

    isClosed isConnected isDisposed

    Methods

    addEventListener close connect disconnect dispose eval fireEvent log onClosed onConnectAttempt onPreConnect removeEventListener verbose warn write writeInternal writeScript

    Constructors

    constructor

    Properties

    abort

    abort: AbortController

    baudRate

    baudRate: number

    chunkSize

    chunkSize: number

    codec

    codec: Codec

    connectAttempts

    connectAttempts: number

    evalReplyBluetooth

    evalReplyBluetooth: boolean = false

    evalTimeoutMs

    evalTimeoutMs: number

    name

    name: string

    port

    port: undefined | SerialPort

    rxBuffer

    rxBuffer: StringReceiveBuffer

    states

    states: Flow.StateMachine.WithEvents<
        Readonly<
            Readonly<
                {
                    closed: "connecting";
                    connected: string[];
                    connecting: string[];
                    ready: "connecting";
                },
            >,
        >,
    >

    tx

    tx: undefined | WritableStreamDefaultWriter<string>

    txBuffer

    txBuffer: StringWriteBuffer

    verboseLogging

    verboseLogging: boolean = false

    Accessors

    isClosed

    • get isClosed(): boolean

      Returns boolean

    isConnected

    • get isConnected(): boolean

      Returns boolean

    isDisposed

    • get isDisposed(): boolean

      Returns boolean

    Methods

    addEventListener

    close

    • close(): Promise<void>

      Returns Promise<void>

    connect

    • connect(): Promise<void>

      Returns Promise<void>

    disconnect

    • disconnect(): Promise<void>

      Returns Promise<void>

    dispose

    eval

    • eval(
          code: string,
          opts?: EvalOpts,
          warn?: (message: string) => void,
      ): Promise<string>

      Sends some code to be executed on the Espruino. The result is packaged into JSON and sent back to your code. An exception is thrown if code can't be executed for some reason.

      const sum = await e.eval(`2+2`);

      It will wait for a period of time for a well-formed response from the Espruino. This might not happen if there is a connection problem or a syntax error in the code being evaled. In cases like the latter, it will take up to timeoutMs (default 5 seconds) before we give up waiting for a correct response and throw an error.

      Tweaking of the timeout may be required if eval() is giving up too quickly or too slowly. A default timeout can be given when creating the class.

      Options: timeoutMs: Timeout for execution. 5 seconds by default assumeExclusive: If true, eval assumes all replies from controller are in response to eval. True by default debug: If true, execution is traced via warn callback

      Parameters

      • code: string

        Code to run on the Espruino.

      • opts: EvalOpts = {}

        Options

      • Optionalwarn: (message: string) => void

        Function to pass warning/trace messages to. If undefined, this.warn is used, printing to console.

      Returns Promise<string>

    ProtectedfireEvent

    Protectedlog

    • log(m: string): void

      Parameters

      • m: string

      Returns void

    onClosed

    • onClosed(): void

      Must change state

      Returns void

    onConnectAttempt

    • onConnectAttempt(): Promise<void>

      Should throw if did not succeed.

      Returns Promise<void>

    onPreConnect

    removeEventListener

    Protectedverbose

    • verbose(m: string): void

      Parameters

      • m: string

      Returns void

    Protectedwarn

    • warn(m: unknown): void

      Parameters

      • m: unknown

      Returns void

    write

    • write(txt: string): void

      Parameters

      • txt: string

      Returns void

    ProtectedwriteInternal

    • writeInternal(txt: string): Promise<void>

      Writes text collected in buffer

      Parameters

      • txt: string

      Returns Promise<void>

    writeScript

    • writeScript(code: string): void

      Writes a script to Espruino.

      It will first send a CTRL+C to cancel any previous input, reset() to clear the board, and then the provided code followed by a new line.

      Use eval instead to execute remote code and get the result back.

      // Eg from https://www.espruino.com/Web+Bluetooth
      writeScript(`
       setInterval(() => Bluetooth.println(E.getTemperature()), 1000);
       NRF.on('disconnect',()=>reset());
      `);

      Parameters

      • code: string

        Code to send. A new line is added automatically.

      Returns void

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Accessors
    Methods