Controlling 10 devices is easy, controlling 10,000 is a different story. The trick is to plan for scale, which is what we specialize in here at Golioth.
A few weeks ago we announced the Golioth Device Settings Service that enables you to change settings for your entire fleet at the click of a button. Of course, you can drill down to groups of devices and single devices too. While the announcement post showed the Settings Service using our ESP-IDF SDK, today we’ll look at this setting service from the device point of view with Zephyr RTOS.
Device-side building blocks
The good news is that the Golioth Zephyr SDK has done all the hard work for you. We just need to do three things to start using the settings service in any Zephyr firmware project:
- Enable the settings service in KConfig
- Register a callback function when the device connects to Golioth
- Validate the data and do something useful when a new setting arrives
Code walk-through
Golioth’s settings sample code is a great starting point. It watches for a settings key named LOOP_DELAY_S to remotely adjust the delay between sending messages back to the server. Let’s walk through the important parts of that code for a better understanding of what is involved.
1. Enable settings in KConfig
CONFIG_GOLIOTH_SETTINGS=y
To turn the settings service on, the CONFIG_GOLIOTH_SETTINGS symbol needs to be selected. Add the code above to your prj.conf file.
2. Register a callback for settings updates
static void golioth_on_connect(struct golioth_client *client)
{
if (IS_ENABLED(CONFIG_GOLIOTH_SETTINGS)) {
int err = golioth_settings_register_callback(client, on_setting);
if (err) {
LOG_ERR("Failed to register settings callback: %d", err);
}
}
}
To do anything useful with the settings service, we need to be able to execute a function when new settings are received. Register the callback function each time the device connects to Golioth. Your app may already have a golioth_on_connect() function declared, look for the following code at the beginning of main and add it if it’s not already there.
client->on_connect = golioth_on_connect; client->on_message = golioth_on_message; golioth_system_client_start();
Each time the Golioth Client detects a new connection, the golioth_on_connect() function will run, which in turn registers your on_setting() function to run.
3. Validate and process the received settings
enum golioth_settings_status on_setting(
const char *key,
const struct golioth_settings_value *value)
{
LOG_DBG("Received setting: key = %s, type = %d", key, value->type);
if (strcmp(key, "LOOP_DELAY_S") == 0) {
/* This setting is expected to be numeric, return an error if it's not */
if (value->type != GOLIOTH_SETTINGS_VALUE_TYPE_INT64) {
return GOLIOTH_SETTINGS_VALUE_FORMAT_NOT_VALID;
}
/* This setting must be in range [1, 100], return an error if it's not */
if (value->i64 < 1 || value->i64 > 100) {
return GOLIOTH_SETTINGS_VALUE_OUTSIDE_RANGE;
}
/* Setting has passed all checks, so apply it to the loop delay */
_loop_delay_s = (int32_t)value->i64;
LOG_INF("Set loop delay to %d seconds", _loop_delay_s);
return GOLIOTH_SETTINGS_SUCCESS;
}
/* If the setting is not recognized, we should return an error */
return GOLIOTH_SETTINGS_KEY_NOT_RECOGNIZED;
}
The callback function will provide a key (the name of the settings) that is a string type, and a golioth_settings_value that includes the value, as well as an indicate of the value type (bool, float, string, or int64). The callback function should validate that the expected key was received, and test that the received value is the proper type and within your expected bounds before acting upon the data.
The final piece of the device settings puzzle is to return an enum value indicating the device status after receiving a new setting. This is used by the Golioth Cloud to indicate sync status. Our example demonstrates the GOLIOTH_SETTINGS_SUCCESS and GOLIOTH_SETTINGS_KEY_NOT_RECOGNIZED status values, but it’s worth checking out the doxygen reference for golioth_settings_status to see how different invalid key and value messages can be sent to Golioth for display in the web console.
Coordinating with the Golioth Cloud
The device settings key format is tightly specified by Golioth, allowing only “A-Z (upper case), 0-9 and underscore (_) characters”. We recommend that you add a key to the Golioth web console while writing your firmware to ensure the device knows what to expect.
Each device page includes a status indicator to show if the settings are in sync with the Golioth cloud.
Additional information is available when a device is out of sync. Here you can see that hovering over the information icon indicates the key is not valid. For this example I created a VERY_IMPORTANT_BOOL_7 but didn’t add support for that to the firmware. This is the result of our callback function returning GOLIOTH_SETTINGS_KEY_NOT_RECOGNIZED. In cases like this, Golioth’s Over-the-Air firmwmare update (OTA) service can help you to push a new firmware to your devices in the field that will recognize the newly created Settings variable.
IoT Fleet control on day one
The pain of IoT often comes when you need to scale. Golioth’s mission is to make sure you avoid that pain and are ready to grow starting from day one.
Our device settings service gives you the power to remotely change settings on your entire fleet, on a group of devices, and all the way down to a single device. You are able to verify your devices are in sync, and receive helpful information when they are not. Take Golioth for a test drive today, our dev tier is free for the first 50 devices.
