Class Obniz

obniz class is the abstract version of obniz Board hardware within JavaScript.

By providing obniz id and instantiating it, you can control obniz Board and the connected parts without the details of websocket api.

obnizOS version and obniz.js version

obniz cloud compare your obniz.js version and target device obnizOS version. If your js sdk major number is below from OS version (eg obniz.js is 2.0.0 and obnizOS is 3.0.0) then obniz cloud will alert when connection established. It will work somehow but some functions looses compatibility.

one device from two program

obniz cloud accept multiple websocket connection from multiple obniz.js at same time. every commands from obniz.js will passed to a device and every command from a device will be dispatched to every obniz.js connected to the cloud.

But If one of obniz.js established a connection to a device, then target device will send datas only via local connect. So other connected obniz.js only can send datas and never receive datas from a device.

If you'd like to receive, you need to specify local_connect: false at all of obniz.js to disable local connect.

Hierarchy

Constructors

constructor

Properties - Embeds

ble? display? location? motion? storage? switch?

Properties - Measurement

logicAnalyzer? measure?

Properties - Other

boot_reason? connected_network? connectionCheckLoopInterval connectionState debugprint deviceTimestamp firmware_ver? hw? id isNode metadata? onclose? onconnect? onerror? onloop? onmessage plugin_name? prefixed

Properties - Peripherals

ad0? ad1? ad10? ad11? ad2? ad3? ad4? ad5? ad6? ad7? ad8? ad9? canbus0? i2c0? io? io0? io1? io10? io11? io2? io3? io4? io5? io6? io7? io8? io9? pwm0? pwm1? pwm2? pwm3? pwm4? pwm5? spi0? spi1? uart0? uart1?

Properties - hardware specific components

components?

Properties - network

wifi?

Properties - plugin

plugin?

Accessors

autoConnect App api version

Methods

_stopPingLoopInBackground addListener close closeWait connect connectWait emit endCommandPool endTrafficMeasurement eventNames getAD getExtraInterface getFreeI2C getFreePwm getFreeSpi getFreeTcp getFreeUart getI2CWithConfig getIO getSpiWithConfig getTrafficData hasExtraInterface isValidAD isValidIO keepWorkingAtOffline listenerCount listeners message off on once pingWait reboot removeAllListeners removeListener repeat reset resetOnDisconnect resetTrafficMeasurement send setClock setLoopInterval setQueueMode setVccGnd sleep sleepIoTrigger sleepMinute sleepSeconds startCommandPool startTrafficMeasurement wait wired PartsRegistrate getBleParts getPartsClass getWsCommandModule isIpAddress isValidObnizId

Constructors

constructor

  • We will now instantiate obniz.

    obniz id is a string. Hyphen '-' is optional, but with just the numbers they can't be accepted.

    new Obniz('1234-5678') // OK
    new Obniz('12345678') // OK
    new Obniz(12345678) // Can't accept

    If you connect to obniz which has an access token, provide an option like this

    new Obniz('1234-5678', {access_token: 'your token here'})

    If obniz id is incorrect, connection will never be established. In nodejs, an error occurs. In HTML, obniz.js shows a prompt message. The user can put in a correct obniz id into it. It shows up only when the format is invalid. If you specify obniz id which doesn't exist, this would never be shown.

    When id is correct, obniz.js will try to connect cloud api and onconnect will be called after connection is established.

    When obniz Board and the device running obniz.js is expected to be in the same network, obniz.js will try to establish a direct Websocket connection to obniz Board. This is called "local connect". When local connect is avaiable, obniz Board can be controlled with almost all commands without having to go through the cloud. However, the connection to the cloud never gets disconnected even when using local connect. But when cloud connection gets closed, the local connect also gets closed.

    The timing onconnect() gets called depends on the availability of local connect. obniz.js will wait a little to establish connection via local connect as much as possible. See the flow below.

    The second parameter when instantiating obniz Board is an option.

    Parameters

    Returns Obniz

Properties - Embeds

Optional ble

ble?: ObnizBLE

If obnizOS ver >= 3.0.0, automatically load [[ObnizCore.Components.Ble.Hci.ObnizBLE|ObnizHciBLE]], and obnizOS ver < 3.0.0 throw unsupported Error,

Optional display

display?: Display

Optional location

location?: Location

Optional motion

motion?: Motion

Optional storage

storage?: Storage

Optional switch

switch?: ObnizSwitch

Properties - Measurement

Optional logicAnalyzer

logicAnalyzer?: LogicAnalyzer

Optional measure

measure?: ObnizMeasure

Properties - Other

Optional boot_reason

boot_reason?: string

This variable indicate installed boot reason of target device

var obniz = new Obniz('1234-5678');
obniz.onconnect = async function() {
  console.log(obniz.boot_reason) // ex. "DEEPSLEEP_RESET"
}

Optional connected_network

connected_network?: ConnectedNetwork

Target obniz device's connected network information. This could be changed when obniz device connect another netowrk.

var obniz = new Obniz('1234-5678');
obniz.onconnect = async function() {
  console.log(obniz.connected_network.online_at) // online since in unix time.
}

connectionCheckLoopInterval

connectionCheckLoopInterval: null | number = null

This variable sets interval time to check connection state to obniz Device.

connectionState

connectionState: "closed" | "connected" | "connecting" | "closing"

This let you know connection state to your obniz Board as string value.

  • 'closed' : not connected.
  • 'connecting' : connecting
  • 'connected' : connection established
  • 'closing' : closing connection.
var obniz = new Obniz('1234-5678');
console.log(obniz.connectionState) // => === "connecting"
obniz.onconnect = async function() {
 console.log(obniz.connectionState) // => === "connected"
}

debugprint

debugprint: boolean

This lets obniz.js to show logs like communicated jsons and connection logs in console.log.

var obniz = new Obniz('1234-5678');
obniz.onconnect = async function() {
 obniz.io0.output(true);
}

deviceTimestamp

deviceTimestamp: null | number = null

Optional firmware_ver

firmware_ver?: string

This variable indicate installed firmware version of target device

var obniz = new Obniz('1234-5678');
obniz.onconnect = async function() {
  console.log(obniz.firmware_ver) // ex. "2.0.0"
}

Optional hw

hw?: string

This variable indicate connected hardware identifier of target device

var obniz = new Obniz('1234-5678');
obniz.onconnect = async function() {
  console.log(obniz.hw) // ex. "obnizb1"
}

id

id: string

obniz id

Readonly isNode

isNode: boolean

Is node.js environment or not.

Optional metadata

metadata?: {
    [key: string]: string;
}

Device metadata set on obniz cloud.

var obniz = new Obniz('1234-5678');
obniz.onconnect = async function() {
  console.log(obniz.metadata.description) // value for "description"
}

Type declaration

  • [key: string]: string

Optional onclose

onclose?: ((obniz) => void)

Type declaration

    • (obniz): void

    • onclose will be called when disconnected.

      var obniz = new Obniz('1234-5678');
      obniz.onconnect = async function() {

      }
      obniz.onclose = async function() {

      }

      Parameters

      Returns void

Optional onconnect

onconnect?: ((obniz) => void)

Type declaration

    • (obniz): void

    • Once connection is established, onconnect function will be called.

      var obniz = new Obniz('1234-5678');
      obniz.onconnect = async function() {

      }

      Operations like turning on/off an io becomes possible only after connection is established, so any operations you want obniz Board to undertake must be written in onconnect

      var obniz = new Obniz('1234-5678');
      obniz.onconnect = async function() {
        obniz.io0.output(true);
      }

      Parameters

      Returns void

Optional onerror

onerror?: ((obniz, error) => void)

Type declaration

    • (obniz, error): void

    • If an error occurs, the onerror function is called.

      var obniz = new Obniz('1234-5678');
      obniz.onconnect = async function() {

      }
      obniz.onerror = async function(ob, error) {
         console.error(error);
      }

      Parameters

      • obniz: Obniz
      • error: Error

      Returns void

Optional onloop

onloop?: ((obniz) => void | Promise<void>)

Type declaration

    • (obniz): void | Promise<void>

    • Called continuously while obniz device is online. Put your main code inside of onloop and put your setup code inside of onconnect.

      onloop will be called after onconnect called. If your funciton set to onconnect return promise, onloop wait until done promise. Even onconnect throws an error onloop will start.

      onloop call pingWait() every time to keep connection data buffer between device to your software clean.

      var obniz = new Obniz('1234-5678');
      obniz.onconnect = async function() {

      }
      obniz.onloop = async function() {

      }

      Parameters

      Returns void | Promise<void>

onmessage

onmessage: any

Receive message. If you want to send message, see [[Obniz.message]]

// Example
obniz.onconnect = function() {
  var motor = obniz.wired("ServoMotor", {gnd:0, vcc:1, signal:2});

  motor.angle(0);
  obniz.onmessage = function(message, from) {
    if (message === "pressed") {
      motor.angle(85);
    }
  };
}

Optional plugin_name

plugin_name?: string

This variable indicate installed plugin_name of target device

var obniz = new Obniz('1234-5678');
obniz.onconnect = async function() {
  console.log(obniz.plugin_name) // ex. "my_plugin"
}

Static prefixed

prefixed: string | boolean

Properties - Peripherals

Optional ad0

ad0?: PeripheralAD

Optional ad1

ad1?: PeripheralAD

Optional ad10

ad10?: PeripheralAD

Optional ad11

ad11?: PeripheralAD

Optional ad2

ad2?: PeripheralAD

Optional ad3

ad3?: PeripheralAD

Optional ad4

ad4?: PeripheralAD

Optional ad5

ad5?: PeripheralAD

Optional ad6

ad6?: PeripheralAD

Optional ad7

ad7?: PeripheralAD

Optional ad8

ad8?: PeripheralAD

Optional ad9

ad9?: PeripheralAD

Optional canbus0

canbus0?: PeripheralCANBus

Optional i2c0

i2c0?: PeripheralI2C

Optional io

io?: Directive

Optional io0

io0?: PeripheralIO

Optional io1

io1?: PeripheralIO

Optional io10

io10?: PeripheralIO

Optional io11

io11?: PeripheralIO

Optional io2

io2?: PeripheralIO

Optional io3

io3?: PeripheralIO

Optional io4

io4?: PeripheralIO

Optional io5

io5?: PeripheralIO

Optional io6

io6?: PeripheralIO

Optional io7

io7?: PeripheralIO

Optional io8

io8?: PeripheralIO

Optional io9

io9?: PeripheralIO

Optional pwm0

pwm0?: PeripheralPWM

Optional pwm1

pwm1?: PeripheralPWM

Optional pwm2

pwm2?: PeripheralPWM

Optional pwm3

pwm3?: PeripheralPWM

Optional pwm4

pwm4?: PeripheralPWM

Optional pwm5

pwm5?: PeripheralPWM

Optional spi0

spi0?: PeripheralSPI

Optional spi1

spi1?: PeripheralSPI

Optional uart0

uart0?: PeripheralUART

Optional uart1

uart1?: PeripheralUART

Properties - hardware specific components

Optional components

components?: IntelligentEdgeKiloComponent

Properties - network

Optional wifi

wifi?: WiFi

Properties - plugin

Optional plugin

plugin?: Plugin

Accessors

autoConnect

Static App

Static api

Static version

Methods

_stopPingLoopInBackground

addListener

close

  • This closes the current connection. You need to set auto_connect to false. Otherwise the connection will be recovered.

    var obniz = new Obniz('1234-5678', {
      auto_connect: false,
      reset_obniz_on_ws_disconnection: false
    });

    obniz.connect();
    obniz.onconnect = async function() {
      obniz.io0.output(true);
      obniz.close();
    }

    Returns void

    Deprecated

    replace with closeWait

closeWait

  • This closes the current connection. You need to set auto_connect to false. Otherwise the connection will be recovered.

    var obniz = new Obniz('1234-5678', {
      auto_connect: false,
      reset_obniz_on_ws_disconnection: false
    });

    obniz.connect();
    obniz.onconnect = async function() {
      obniz.io0.output(true);
      await obniz.closeWait();
    }

    Returns Promise<void>

connect

  • You can connect to obniz Board manually by calling connect() when auto_connect is set to be false.

    var obniz = new Obniz('1234-5678', { auto_connect: false });

    obniz.connect();
    obniz.onconnect = async function() {
     obniz.io0.output(true);
    }

    Returns void

connectWait

  • With this you wait until the connection to obniz Board succeeds.

    var obniz = new Obniz('1234-5678');

    await obniz.connectWait();

    obniz.io0.output(true);
    await obniz.closeWait();
    • with timeout
    var obniz = new Obniz('1234-5678');

    await obniz.connectWait({timeout:10});  //timeout 10sec

    if(connected){
       obniz.io0.output(true);
       await obniz.closeWait();
    }
    • with auto_connect:false

    If the param auto_connect is set as false, it will try to connect only once and, if unsuccessful, return false.

    var obniz = new Obniz('1234-5678',{auto_connect: false});

    var connected = await obniz.connectWait();  //try once

    if(connected){
      obniz.io0.output(true);
      await obniz.closeWait();
    }

    Parameters

    • Optional option: {
          timeout?: number;
      }
      • Optional timeout?: number

        timeout in seconds

    Returns Promise<boolean>

    False will be returned when connection is not established within a set timeout.

emit

  • Calls each of the listeners registered for a given event.

    Parameters

    Returns boolean

endCommandPool

endTrafficMeasurement

  • Returns {
        ceilByte: number;
        readByte: number;
        readCount: number;
        sendByte: number;
        sendCount: number;
    }

    • ceilByte: number
    • readByte: number
    • readCount: number
    • sendByte: number
    • sendCount: number

eventNames

getAD

getExtraInterface

getFreeI2C

getFreePwm

getFreeSpi

getFreeTcp

getFreeUart

getI2CWithConfig

getIO

getSpiWithConfig

getTrafficData

  • Returns {
        ceilByte: number;
        readByte: number;
        readCount: number;
        sendByte: number;
        sendCount: number;
    }

    • ceilByte: number
    • readByte: number
    • readCount: number
    • sendByte: number
    • sendCount: number

hasExtraInterface

isValidAD

isValidIO

keepWorkingAtOffline

  • By default, obniz Board resets after disconnection from the cloud. It means the output value and pwm will all stop at that point. But the above function with the argument true can nullify that default setting and change it to "do not reset when offline". This configuration remains as long as obniz Board is on.

    // Example
    obniz.keepWorkingAtOffline(true);

    Parameters

    • working: any

    Returns void

listenerCount

  • Return the number of listeners listening to a given event.

    Parameters

    Returns number

listeners

  • Return the listeners registered for a given event.

    Parameters

    Returns ListenerFn[]

message

  • Send message to obniz clients. If you want receive data, see [[Obniz.onmessage]]

    // Example
    obniz.onconnect = function(){
     var button = obniz.wired("Button",  {signal:0, gnd:1});

     button.onchange = function(){
       var targets = [
         "1234-1231",
         "1234-1232",
         "1234-1233",
         "1234-1234",
         "1234-1235",
         "1234-1236",
         "1234-1237",
         "1234-1238",
         "1234-1239",
         "1234-1230"];

       obniz.message(targets, "pressed");
      };
    }

    Parameters

    • target: string | string[]

      destination obniz id

    • message: string

      message data

    Returns void

off

  • Parameters

    • event: ObnizConnectionEventNames | ObnizConnectionEventNamesInternal
    • Optional fn: ListenerFn
    • Optional context: any
    • Optional once: boolean

    Returns Obniz

on

  • Add a listener for a given event.

    Parameters

    Returns Obniz

once

  • Add a one-time listener for a given event.

    Parameters

    Returns Obniz

pingWait

  • Ping to obniz device and wait pong response.

    If debugprint option enabled, it display ping/pong response time on console.

    await obniz.pingWait(); //waiting pong.

    Parameters

    • Optional unixtime: number

      start time of measure response time

    • Optional rand: number

      Unique identifier of ping data

    • Optional forceGlobalNetwork: boolean

    Returns Promise<void>

reboot

removeAllListeners

removeListener

  • Remove the listeners of a given event.

    Parameters

    • event: ObnizConnectionEventNames | ObnizConnectionEventNamesInternal
    • Optional fn: ListenerFn
    • Optional context: any
    • Optional once: boolean

    Returns Obniz

repeat

  • Set onloop function. Use onloop property instead. This is deprecated function.

    Parameters

    • callback: any
    • Optional interval: number

      default 100. It mean 100ms interval loop.

    Returns void

    Deprecated

reset

  • This forces the obniz Board to go back to the initial state when the power was just turned on.

    // Example
    obniz = new Obniz("1234-5678");
    obniz.onconnect = function() {
      obniz.reset();
    }

    Returns void

resetOnDisconnect

  • This lets you change the setting of reset_obniz_on_ws_disconnection after connection is established.

    By default, obniz cloud resets target obniz Board when the all websocket to obniz cloud was closed. It means the output value and pwm will all stop at that point. With the above function, you can nullify these resetting activities. This configuration will remain until target obniz Board gets disconnected. Set this function to false to keep working without any of the websocket connections.

    // Example
    obniz.resetOnDisconnect(false);

    Parameters

    • reset: boolean

    Returns void

resetTrafficMeasurement

  • Returns null | {
        ceilByte: number;
        readByte: number;
        readCount: number;
        sendByte: number;
        sendCount: number;
    }

send

  • Send json/binary data to obniz Cloud or device.

    Parameters

    • obj: Record<string, any> | Record<string, any>[]

      send data

    • Optional options: {
          connect_check?: boolean;
          local_connect?: boolean;
      }

      send option

      • Optional connect_check?: boolean
      • Optional local_connect?: boolean

        If false, send data via gloval internet.

    Returns void

setClock

  • Set the internal clock of the obniz device. This will be set to device immediately and used as device timestamp.

    // JavaScript example
    obniz.setClock();

    Parameters

    • Optional unix_milliseconds: number

      number of milliseconds since January 1, 1970 00:00:00 UTC. If not specified, the current time will be used.

    Returns void

setLoopInterval

  • Sets the execution interval of onLoop function. Changes will be reflected after the next onloop is executed.

    Parameters

    • interval: number

      interval of execution in milliseconds.

    Returns void

setQueueMode

  • Parameters

    • params: {
          interval: number;
          timestamp: "none" | "unix_seconds" | "unix_milliseconds";
      }
      • interval: number
      • timestamp: "none" | "unix_seconds" | "unix_milliseconds"

    Returns void

setVccGnd

sleep

  • Action only with obniz Board 1Y.

    Obniz Board sleeps for the value specified in Date type. Sleep for up to 45 days (64800 minutes).

    // JavaScript example
    let dt = new Date();
    dt.setHours(dt.getHours () + 1,0,0,0);
    obniz.sleep(dt);

    Parameters

    • date: Date

    Returns void

sleepIoTrigger

  • Action only with obniz Board 1Y.

    It returns from sleep depending on the pin state of IO0.

    // JavaScript example
    obniz.sleepIoTrigger (true);

    Parameters

    • trigger: boolean

      true: Rise (LOW -> HIGH)

      • false: Falling (HIGH -> LOW)

    Returns void

sleepMinute

  • Action only with obniz Board 1Y.

    Obniz Board sleeps for the value specified in minutes.

    // JavaScript example
    obniz.sleepMinute (60); // 60 minutes

    Parameters

    • minute: number

      up to 64800 minutes(45 days ).

    Returns void

sleepSeconds

  • Action only with obniz Board 1Y.

    Obniz Board sleeps for the value specified in seconds.

    // JavaScript example
    obniz.sleepSeconds (60); // 60 seconds

    Parameters

    • sec: number

      up to 64800 seconds (18 hours).

    Returns void

startCommandPool

startTrafficMeasurement

wait

  • This pauses obniz Board for a period given in terms of ms (millisecond).

    // Javascript Example
    led.on();
    obniz.wait(1000); // led ON 1sec.
    led.off();

    This method pauses only obniz Board, not JavaScript.

    // Javascript Example
    var time = new Date();
    led.on();
    obniz.wait(1000); // led ON 1sec.
    led.off();
    console.log((new Date()).getTime() - time.getTime()) // 0 or very few ms. not 1000ms.

    However, when you call this method together with the await function, JavaScript will pause for the given period in ms.

    // Javascript Example
    var time = new Date();
    led.on();
    await obniz.wait(1000); // led ON 1sec.
    led.off();
    console.log((new Date()).getTime() - time.getTime()) // => about 1000

    Parameters

    • msec: number

    Returns Promise<void>

wired

Static PartsRegistrate

Static getBleParts

Static getPartsClass

Static getWsCommandModule

  • Returns WSCommandManager<WsCommandModules>

Static isIpAddress

Static isValidObnizId

Settings

Member Visibility

Theme

On This Page

Generated using TypeDoc