See how to set up and use the Exhibit SDK first to get familiar with using the Node SDK, as well as the hardware getting started guide for using hardware for the first time.

...

Connecting the Hardware

There are two ways to connect hardware to an Exhibit SDK application:

• Online Mode - authenticate, connect, and manage hardware using the Gumband Dashboard and Service.

• Offline Mode - connect and manage hardware directly, no authentication through Gumband Services.

More information about authentication scenarios, including caching the authentication whitelist, see SDK Hardware Authentication Scenarios

...

Note: Gumband hardware connects to the Gumband Services and to the Gumband SDK using GBTT, the Gumband MQTT Hardware Service.

const { Gumband, Sockets } = require('@deeplocal/gumband-node-sdk');

const EXHIBIT_ID = '40';
const EXHIBIT_TOKEN = 'a45ne3...';

const gb = new Gumband(
    EXHIBIT_TOKEN,
    EXHIBIT_ID,
    './manifest.json',
    {
      gbttEnabled: true, // Enable the hardware MQTT broker
      gbttPort: 1883, // (Optional) port for the MQTT broker, defaults to 1883
    }
);

gb.on(Sockets.READY, async () => {
    console.log('Gumband Ready!');
});

Online Mode

...

Online mode is all done using Gumband Dashboard!

Set the Exhibit MQTT IP address

Note: This step is a current limitation of the SDK not registering the IP address where the hardware should connect to, and is planned to be removed in the future.

In the “Hardware” tab for the exhibit, enter the IP address the hardware should connect to. This is typically the IP of the computer running the SDK application.

...

Associate the Hardware with the Exhibit SDK

...

Offline Mode

...

For instances where you want to bypass hardware authentication and management through Gumband Services. This could include an on-site installation where there is flakey or non-existent cloud access.

Whitelist the Hardware ID in the SDK

const { Gumband, Sockets } = require('@deeplocal/gumband-node-sdk');

const EXHIBIT_ID = '40';
const EXHIBIT_TOKEN = 'a45ne3...';

const gb = new Gumband(
    EXHIBIT_TOKEN,
    EXHIBIT_ID,
    './manifest.json',
    {
      gbttEnabled: true, // Enable the hardware MQTT broker
      gbttPort: 1883, // (Optional) port for the MQTT broker, defaults to 1883
      noInternetConnection: true, // SDK needs to run in offline mode to use Hardware ID whitelist
      noInternetHardwareIds: [] // Array of offline hardware IDs
    }
);

gb.on(Sockets.READY, async () => {
    console.log('Gumband Ready!');
});

Configure the Exhibit Application IP on the Hardware

The hardware needs to know the IP of the computer running the SDK application so it knows where to connect to. We’ll configure the hardware to use this IP, and disable the cloud/ Gumband Service from being able to change it.

...

Description

...

Command

...

Set Exhibit Server to Static

...

write static_exhibit true

...

Set Exhibit Server

...

write exhibit_server XX.XX.XX.XX:1883

Checking the Hardware LED Status

The hardware’s LED status will correspond to how it is connected.

...

Color

...

Description

...

Cyan

...

Only Cloud server connected

...

Blue

...

Only Application server connected

...

Green

...

Both Cloud server and Application server connected

Interacting with the SDK

See SDK Events for more information.

...

Setting Up the MQTT Broker

Built In MQTT Broker

The Exhibit SDK comes with a built in MQTT Broker that the hardware and SDK can use to communicate with each other. To enable the MQTT Broker during the SDK initialization:

const gb = new Gumband(
    TOKEN,
    EXHIBIT_ID,
    MANIFEST,
    {
        useLocalMQTTBroker: true,
        MQTTBrokerPort: 1885,
    },
);

This will instruct the Exhibit SDK to create an MQTT broker at port 1885 (the default port is 1883), and to connect a client to the broker on the Exhibit SDK’s behalf. In this case, the MQTT IP is not required since the SDK has a direct reference to the MQTT broker.

User Defined MQTT Broker

If you want to use your own MQTT Broker instead, you can do that by providing the MQTTBrokerIP option:

const gb = new Gumband(
    TOKEN,
    EXHIBIT_ID,
    MANIFEST,
    {
        MQTTBrokerIP: "123.123.1.12",
    },
);

This will instruct the Exhibit SDK to create a client that connects to the broker at 123.123.1.12:1883

Connecting the Hardware

An Exhibit SDK application will only accept messages from hardware that are whitelisted. There are three options to define this whitelist:

Default: Accept Messages From Any Hardware ID

By default, the whitelist will consist of only a *. This indicates that the SDK will accept and process messages from any hardware that sends them over the MQTT broker.

Only Accept Messages From Hardware IDs in the Approved Whitelist

Set a whitelist of hardware IDs when the Exhibit SDK first initializes:

const gb = new Gumband(
    TOKEN,
    EXHIBIT_ID,
    MANIFEST,
    {
        useLocalMQTTBroker: true,
        allowedHardwareIds: ['ed028e04-41d9-4e77-a5d2-ab4e7346e3a7']
    },
);

This will only allow the Exhibit SDK to accept messages from hardware with an ID of ed028e04-41d9-4e77-a5d2-ab4e7346e3a7. All other messages will still be seen by the SDK, but will be ignored.

Only Accept Messages From Hardware That Are Associated With the Same Exhibit in the Gumband UI

Set the whitelist of hardware IDs to whatever hardwares are associated with the same exhibit as the Exhibit SDK in the Gumband UI:

const gb = new Gumband(
    TOKEN,
    EXHIBIT_ID,
    MANIFEST,
    {
        useLocalMQTTBroker: true,
        allowOnlyCloudHardwareIds: true
    },
);

You can see which Exhibit SDKs and Hardware are associated with any given exhibit by navigating to the Components tab of any exhibit:

...

Checking the Hardware LED Status

The hardware’s LED status will correspond to how it is connected.

Color	Description
Image Added Cyan	Only Cloud server connected
Image Added Blue	Only Application server connected
Image Added Green	Both Cloud server and Application server connected

...

Interacting with the SDK

See SDK Events for more information about these events and the available data in the payloads.

There are two stages that the hardware goes through when it connects to the Exhibit SDK. When the SDK receives its first registration message from the hardware, the hardware is considered “connected”. At this time, the SOCKETS.HARDWARE_CONNECTED event is emitted through the SDK class.

After all system properties and at least one application property has been registered with the Exhibit SDK, that hardware is considered “registered” and the SDK will emit a SOCKETS.HARDWARE_REGISTERED event. The “registered” event is the more significant of the two, since that event means the SDK is ready to start sending/receiving property updates to/from the hardware.

Hardware connected/disconnected event

// Event when hardware connects to the Exhibit SDK, but before it registers properties
gb.on(SOCKETS.HARDWARE_CONNECTED, async (payload) => {
    console.log(`Hardware with ID ${payload.id} connected.`);
});

// Event when hardware disconnects from the Exhibit SDK
gb.on(SOCKETS.HARDWARE_DISCONNECTED, async (payload) => {
    console.log(`Hardware with ID ${payload.id} disconnected.`);
});

Hardware registered event

// Event when hardware registers with the Exhibit SDK.
gb.on(SOCKETS.HARDWARE_FULLY_REGISTERED, async (payload) => {
    //  payload: {
    //    id: "ed028e04-41d9-4e77-a5d2-ab4e7346e3a7",
    //    system: {
    //      info: {
    //        ...systemInfo
    //      },
    //      properties: {
    //        ...systemProperties
    //      }
    //    },
    //    app: {
    //      info: {
    //        ...appInfo
    //      },
    //      properties: {
    //        ...appProperties
    //      }
    //    }
    //  }
});

Receive hardware property event

// Event when hardware comes online/connects system or app property is changed
gb.on(SocketsSOCKETS.HARDWARE_PROPERTY_ONLINERECEIVED, async (payload) => {
  //  {
  //      id: 'ed028e04-41d9-4e77-a5d2-ab4e7346e3a7',
 console.log(`Hardware with ID ${payload.hardwareId} "${payload.name}" online.`);
    console.log(payload.peripherals); // Registered properties
});

// Event when hardware comes offline/disconnects
gb.on(Sockets.HARDWARE_OFFLINE, async (payload) => {
    console.log(`Hardware with ID ${payload.hardwareId} "${payload.name}" offline.`);
});

Receive hardware property event

// Event when hardware sends a property
gb.on(Sockets.HARDWARE_PROPERTY_RECEIVED, async (payload) => {
  console.log(`Hardware ID ${payload.hardwareId} "${payload.name}" sent a property`);
  console.log(`  property: "${payload.peripheral}/${payload.property}"`);
  console.log(`  value: ${payload.value}`);
});

Set hardware property

gb.hardware.set(`{hardwareId}/{peripheral name}/{property name}`, value);

...

 //      info: {
  //        system: { info: [Object], properties: [Array] },
  //        app: { info: [Object], properties: [Array] }
  //      },
  //      value: [ "myValue" ],
  //      property: 'My Property',
  //      source: 'app'
  //  }
});

Set hardware property

value = gb.hardware.getsetProperty(`{hardwareId}/{peripheral name}/{property name}`,"my/property/path", value);

Get

...

hardware

...

property

hwlistvalue = gb.hardware.getOnlineHardware();

Examples

Putting it all together!

SDK Button LED Example

Button presses from the hardware get sent to the SDK, and the SDK toggles the hardware LED in return.

getProperty(hardwareId, "my/property/path");

Get list of currently registered hardware devices

hwlist 

= gb.hardware.getAllRegisteredHardware();

Examples

SDK Button LED Example

Button presses from the hardware get sent to the SDK, and the SDK toggles the hardware LED in return.

The firmware for the hardware is the Remote LED and Button example in Arduino (version 1.8.4 or newer).

...

/*
 * Gumband Remote Button/LED Example
 * 
 * Demonstrates how to control hardware using an Exhibit Application
 *   - sets up a property to turn the on-board LED on/off.
 *   - sets up a property that updates when on-board button is pressed/released.
 */
#include <Gumband.h>

// Create the Gumband Properties
GumbandBool button_prop("Button", "Press");
GumbandBool led_toggle_prop("LED", "Toggle");

// Define our LED/Toggle property write callback
void led_toggle_callback(void)
{
  // Turn the on-board LED on or off using the toggle value
 
  if(led_toggle_val == 1prop.getValue()) {
      gumbandLedOnpsocLEDOn();
    }
 
  else {
      gumbandLedOffpsocLEDOff();
 
  }
}

void setup()
{
  // Initialize Gumband
  gumbandInit();

  // Attach the callback to executesexecute when something is written to the LED/Toggle property
  gumbandSetWriteCallback(led_toggle_prop, .setWriteCallback(led_toggle_callback);
}

void loop()
{
  // Automatically Iftell the on-board exhibit application when the button is pressed or released
if(gumbandButtonPressed() && button_currently_pressed == false) {
    
prop.setPublishOnChange();
   // TellPrevent the exhibit application the button has been pressed
 from updating our button
  gumbandPublish(button_prop, true.setReadOnly();

  // Register button_currently_pressed = true;
  }
  else if(!gumbandButtonPressed() && button_currently_pressed == true)
  {
 properties by calling subscribe
  gumbandSubscribe();
}

void loop()
{
  // Get Tellif the exhibit application the on-board button hasis been releasedpressed
    gumbandPublish(button_prop, false.setValue(psocButtonIsPressed());

  // Call update to handle button_currently_pressed = false;incoming Gumband messages
  }gumbandUpdate();
}

const { Gumband, Sockets } = require('@deeplocal/gumband-node-sdk');

const EXHIBIT_ID = '40';
const EXHIBIT_TOKEN = 'a45ne3...';

const gb = new Gumband(
    EXHIBIT_TOKEN,
    EXHIBIT_ID,
    './manifest.json',
    {
      gbttEnableduseLocalMQTTBroker: true, // Enable the hardware MQTT broker
      //gbttPortMQTTBrokerPort: 1883, // Port for the MQTT broker, defaults to 1883
      //noInternetConnection: true, // SDK in offline mode
      //noInternetHardwareIds: [] // Array of offline hardware IDs to 1883
    }
);

gb.on(Sockets.READY, async () => {
    console.log('Gumband Ready!');
});

// Event when hardware comes online/connectsconnects and registers
gb.on(Sockets.HARDWARE_ONLINEREGISTERED, async (payload) => {
    console.log(`Hardware with ID ${payload.hardwareIdid} connectedregistered.`);
});

// Event when hardware comes offline/disconnects
gb.on(Sockets.HARDWARE_OFFLINEDISCONNECTED, async (payload) => {
    console.log(`Hardware with ID ${payload.hardwareIdid} disconnected.`);
});

// Event when hardware sends a property
gb.on(Sockets.HARDWARE_PROPERTY_RECEIVED, async (payload) => {
  //console.log(`Hardware ID ${payload.hardwareIdid} sent a property`);
  //console.log(`  property: "${payload.peripheral}/${payload.property}"`);
  //console.log(`  value: ${payload.value}`);
  
  // If we receive the Button/Press property
  if(payload.peripheralproperty === 'Button' && payload.property === '/Press') {
    // If the button is pressed
    if(payload.value == 1) {
      console.log(`Button pressed!`);
      // Set the LED/Toggle property to 1 (on)
      gb.hardware.set(`${payload.hardwareIdid}/LED/Toggle`, 1);
    }
    // If the button is not pressed
    else {
      console.log(`Button released!`);
      // Set the LED/Toggle property to 0 (off)
      gb.hardware.set(`${payload.hardwareIdid}/LED/Toggle`, 0);
    }
  }
});

...