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.

Overview

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.

...

...

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(
    EXHIBIT_TOKEN,
    EXHIBIT_ID,
    './manifest.json'MANIFEST,
    {
      gbttEnabled  useLocalMQTTBroker: true,
 //  Enable the hardware MQTT broker MQTTBrokerPort: 1885,
    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

},
);

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 Modified Cyan	Only Cloud server connected
Image Modified Blue	Only Application server connected
Image Modified 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 comes online/connectsconnects to the Exhibit SDK, but before it registers properties
gb.on(SocketsSOCKETS.HARDWARE_ONLINECONNECTED, async (payload) => {
    console.log(`Hardware with ID ${payload.hardwareIdid} "${payload.name}" online.`);
    console.log(payload.peripherals); // Registered properties
connected.`);
});

// Event when hardware comes offline/disconnectsdisconnects from the Exhibit SDK
gb.on(SocketsSOCKETS.HARDWARE_OFFLINEDISCONNECTED, async (payload) => {
    console.log(`Hardware with ID ${payload.hardwareIdid} "${payload.name}" offline.disconnected.`);
});

...

Hardware registered event

// Event when hardware registers with sendsthe aExhibit propertySDK.
gb.on(SocketsSOCKETS.HARDWARE_PROPERTYFULLY_RECEIVEDREGISTERED, 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);

...

  //  payload: {
    //    id: "ed028e04-41d9-4e77-a5d2-ab4e7346e3a7",
    //    system: {
    //      info: {
    //        ...systemInfo
    //      },
    //      properties: {
    //        ...systemProperties
    //      }
    //    },
    //    app: {
    //      info: {
    //        ...appInfo
    //      },
    //      properties: {
    //        ...appProperties
    //      }
    //    }
    //  }
});

Receive hardware property event

// Event when hardware system or app property is changed
gb.on(SOCKETS.HARDWARE_PROPERTY_RECEIVED, async (payload) => {
  //  {
  //      id: 'ed028e04-41d9-4e77-a5d2-ab4e7346e3a7',
  //      info: {
  //        system: { info: [Object], properties: [Array] },
  //        app: { info: [Object], properties: [Array] }
  //      },
  //      value: [ "myValue" ],
  //      property: 'My Property',
  //      source: 'app'
  //  }
});

Set hardware property

gb.hardware.setProperty(hardwareId,"my/property/path", value);

Get hardware property

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

Get list of currently

...

registered hardware devices

hwlist = gb.hardware.getOnlineHardwaregetAllRegisteredHardware();

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_prop.getValue()) {
    psocLEDOn();
  }
  else {
    psocLEDOff();
  }
}

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

  // Attach the callback to execute when something is written to the LED/Toggle property
  led_toggle_prop.setWriteCallback(led_toggle_callback);

  // Automatically tell the exhibit application when the button is pressed or released
  button_prop.setPublishOnChange();
  // Prevent the exhibit application from updating our button
  button_prop.setReadOnly();

  // Register properties by calling subscribe
  gumbandSubscribe();
}

void loop()
{
  // Get if the on-board button is pressed
  button_prop.setValue(psocButtonIsPressed());

  // Call update to handle 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
    }
);

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);
    }
  }
});

...