In this exercise, we will establish bidirectional communication between your board and another MQTT client which enables you to control/monitor the board remotely from any other MQTT client, running on a PC, tablet or smartphone.

When pressing button 1 on the board, the message “Button 1 pressed” is published to CONFIG_MQTT_SAMPLE_PUB_TOPIC, and any client subscribed to this topic will receive this message.

On the other hand, when the “LED1ON” message is sent from another client to the CONFIG_MQTT_SAMPLE_SUB_TOPIC topic, the LED on the board (LED1 on the nRF91 Series DK, red LED on the Thingy:91) is turned ON. When the “LED1OFF” message is sent from another client to the CONFIG_MQTT_SAMPLE_SUB_TOPIC topic, the LED is turned OFF.

We will practice using the MQTT helper library in nRF Connect SDK to:

• Configure the board as an MQTT client
• Connect to an MQTT broker (mqtt.nordicsemi.academy)
• Publish and subscribe to MQTT topics, set by the Kconfig symbols: CONFIG_MQTT_SAMPLE_PUB_TOPIC and CONFIG_MQTT_SAMPLE_SUB_TOPIC
• Control LEDs on the board via a remote MQTT client running on your PC
• Publish a message to the broker when button 1 is pressed on the DK

Exercise Steps

1. In the GitHub repository for this course, go to the base code for this exercise, found in l4/l4_e1.

2. Enable and configure the MQTT helper library.

2.1. Enable and configure the MQTT library in your application by enabling the following Kconfig symbols in the prj.conf file.

CONFIG_MQTT_HELPER=y
CONFIG_MQTT_CLEAN_SESSION=y

CONFIG_MQTT_HELPER=y
CONFIG_MQTT_CLEAN_SESSION=y

• CONFIG_MQTT_HELPER enables the MQTT helper which selects the necessary Kconfigs for MQTT.
• CONFIG_MQTT_CLEAN_SESSION is to disable persistent sessions. Setting this flag to y disables a persistent MQTT session.

2.2 Set the MQTT topics.

In the Kconfig file in the exercise folder, notice that there are many custom Kconfigs defined. Some of these have default values, like the broker hostname, and some we need to set in prj.conf before building the project.

We need to set the following Kconfigs in the prj.conf file.

• CONFIG_MQTT_SAMPLE_PUB_TOPIC: the topic name that the board will publish to.
• CONFIG_MQTT_SAMPLE_SUB_TOPIC: the topic name that the board will subscribe to.

Add the following lines to the prj.conf file

CONFIG_MQTT_SAMPLE_PUB_TOPIC="devacademy/publish/topic"
CONFIG_MQTT_SAMPLE_SUB_TOPIC="devacademy/subscribe/topic"

CONFIG_MQTT_SAMPLE_PUB_TOPIC="devacademy/publish/topic"
CONFIG_MQTT_SAMPLE_SUB_TOPIC="devacademy/subscribe/topic"

2.3  Include the header file for the MQTT helper library in main.c.

#include <net/mqtt_helper.h>

#include <net/mqtt_helper.h>

3. Define the commands to control and monitor LEDs and buttons.

Define the strings to send over MQTT that will tell the board to turn on or off either LED1 or LED2 and what message to send when pressing button 1 or 2. In addition, define the message ID used when subscribing to topics. This will be used to verify that a subscription succeeded.

#define LED1_ON_CMD       "LED1ON"
#define LED1_OFF_CMD      "LED1OFF"
#define LED2_ON_CMD       "LED2ON"
#define LED2_OFF_CMD      "LED2OFF"
#define BUTTON_MSG       "Button 1 pressed"
#define SUBSCRIBE_TOPIC_ID 1234

#define LED1_ON_CMD       "LED1ON"
#define LED1_OFF_CMD      "LED1OFF"
#define LED2_ON_CMD       "LED2ON"
#define LED2_OFF_CMD      "LED2OFF"
#define BUTTON_MSG       "Button 1 pressed"
#define SUBSCRIBE_TOPIC_ID 1234

4. Define the function subscribe() to subscribe to a specific topic.

We can subscribe to as many MQTT topics as we want.

4.1 Declare a variable of type mqtt_topic.

For each topic of interest, declare a variable of type mqtt_topic. This variable needs to contain the topic name (in UTF-8 format), the length of the topic name, and the quality of service requested for the subscription.

This is done in the code below where we have created one variable subscribe_topic of type mqtt_topic, to subscribe to CONFIG_MQTT_SAMPLE_SUB_TOPIC with QoS1.

struct mqtt_topic subscribe_topic = {
	.topic = {
		.utf8 = CONFIG_MQTT_SAMPLE_SUB_TOPIC,
		.size = strlen(CONFIG_MQTT_SAMPLE_SUB_TOPIC)
	},
	.qos = MQTT_QOS_1_AT_LEAST_ONCE
};

struct mqtt_topic subscribe_topic = {
	.topic = {
		.utf8 = CONFIG_MQTT_SAMPLE_SUB_TOPIC,
		.size = strlen(CONFIG_MQTT_SAMPLE_SUB_TOPIC)
	},
	.qos = MQTT_QOS_1_AT_LEAST_ONCE
};

4.2 Define a subscription list.

Once we have declared the topic(s) of interest, we need to create a subscription list variable of type mqtt_subscription_list. In the initialization of the list, we must provide a pointer to the topic or a pointer to the array of topics (if subscribed to more than one topic). In addition, we specify the number of topics and a message id, which can be a random number, and is used to identify the subscription request.

struct mqtt_subscription_list subscription_list = {
	.list = &subscribe_topic,
	.list_count = 1,
	.message_id = SUBSCRIBE_TOPIC_ID};

struct mqtt_subscription_list subscription_list = {
	.list = &subscribe_topic,
	.list_count = 1,
	.message_id = SUBSCRIBE_TOPIC_ID};

4.3 Subscribe to topics using mqtt_helper_subscribe().

Once we have the list variable initialized, we can call the MQTT helper library function mqtt_subscribe(), which takes one parameter, a pointer to a variable of type mqtt_subscription_list.

	LOG_INF("Subscribing to %s", CONFIG_MQTT_SAMPLE_SUB_TOPIC);
	err = mqtt_helper_subscribe(&subscription_list);
	if (err) {
		LOG_ERR("Failed to subscribe to topics, error: %d", err);
		return;
	}

	LOG_INF("Subscribing to %s", CONFIG_MQTT_SAMPLE_SUB_TOPIC);
	err = mqtt_helper_subscribe(&subscription_list);
	if (err) {
		LOG_ERR("Failed to subscribe to topics, error: %d", err);
		return;
	}

5. Define the function publish() to publish data to the broker.

In order to publish to a broker (send a message to a topic), we need to use the MQTT helper function mqtt_helper_publish(), which takes one parameter: a pointer to a variable of type mqtt_publish_param which encapsulates the message to be sent.

The function needs to populate the members of the mqtt_publish_param struct and call mqtt_helper_publish() to publish the message to the broker.

5.1 Declare and populate a variable of type mqtt_publish_param.

	struct mqtt_publish_param mqtt_param;

	mqtt_param.message.payload.data = data;
	mqtt_param.message.payload.len = len;
	mqtt_param.message.topic.qos = MQTT_QOS_1_AT_LEAST_ONCE;
	mqtt_param.message_id = mqtt_helper_msg_id_get(),
	mqtt_param.message.topic.topic.utf8 = CONFIG_MQTT_SAMPLE_PUB_TOPIC;
	mqtt_param.message.topic.topic.size = strlen(CONFIG_MQTT_SAMPLE_PUB_TOPIC);
	mqtt_param.dup_flag = 0;
	mqtt_param.retain_flag = 0;

	struct mqtt_publish_param mqtt_param;

	mqtt_param.message.payload.data = data;
	mqtt_param.message.payload.len = len;
	mqtt_param.message.topic.qos = MQTT_QOS_1_AT_LEAST_ONCE;
	mqtt_param.message_id = mqtt_helper_msg_id_get(),
	mqtt_param.message.topic.topic.utf8 = CONFIG_MQTT_SAMPLE_PUB_TOPIC;
	mqtt_param.message.topic.topic.size = strlen(CONFIG_MQTT_SAMPLE_PUB_TOPIC);
	mqtt_param.dup_flag = 0;
	mqtt_param.retain_flag = 0;

A few things to note:

• We are setting the topic the device will publish to in the line param.message.topic.topic.utf8 = CONFIG_MQTT_SAMPLE_PUB_TOPIC.
• The data to be sent is passed to the function, uint8_t *data, and is set in the line param.message.payload.data = data.
• The message ID is set by using the MQTT helper function mqtt_helper_msg_id_get(), which increments values by one for each call.
• Since we are not using duplication or a persistent MQTT session, the flags dup_flag and retain_flag are set to 0

5.2 Publish to MQTT broker using mqtt_helper_publish().

	err = mqtt_helper_publish(&mqtt_param);
	if (err) {
		LOG_WRN("Failed to send payload, err: %d", err);
		return err;
	}

	LOG_INF("Published message: \"%.*s\" on topic: \"%.*s\"", mqtt_param.message.payload.len,
								  mqtt_param.message.payload.data,
								  mqtt_param.message.topic.topic.size,
								  mqtt_param.message.topic.topic.utf8);

	err = mqtt_helper_publish(&mqtt_param);
	if (err) {
		LOG_WRN("Failed to send payload, err: %d", err);
		return err;
	}

	LOG_INF("Published message: \"%.*s\" on topic: \"%.*s\"", mqtt_param.message.payload.len,
								  mqtt_param.message.payload.data,
								  mqtt_param.message.topic.topic.size,
								  mqtt_param.message.topic.topic.utf8);

6. Define the callback handlers from the MQTT helper library.

These functions will be called whenever specific MQTT packets are received from the broker, or some library state has changed.

6.1 Define a callback handler for the CONNACK event.

This function is called upon a CONNACK event, which is an acknowledgement from the broker of the connection result. The return_code variable will indicate whether the connection was succesful or not, see the list of return codes below

If the return code indicates the connection was accepted MQTT_CONNECTION_ACCEPTED, log that as well as some information about the connection.

Then call subscribe() to subscribe to topics from the broker.

static void on_mqtt_connack(enum mqtt_conn_return_code return_code, bool session_present)
{
	ARG_UNUSED(session_present);
	if (return_code == MQTT_CONNECTION_ACCEPTED) {
		LOG_INF("Connected to MQTT broker");
		LOG_INF("Hostname: %s", CONFIG_MQTT_SAMPLE_BROKER_HOSTNAME);
		LOG_INF("Client ID: %s", (char *)client_id);
		LOG_INF("Port: %d", CONFIG_MQTT_HELPER_PORT);
		LOG_INF("TLS: %s", IS_ENABLED(CONFIG_MQTT_LIB_TLS) ? "Yes" : "No");
		subscribe();
	} else {
		LOG_WRN("Connection to broker not established, return_code: %d", return_code);
	}
}

static void on_mqtt_connack(enum mqtt_conn_return_code return_code, bool session_present)
{
	ARG_UNUSED(session_present);
	if (return_code == MQTT_CONNECTION_ACCEPTED) {
		LOG_INF("Connected to MQTT broker");
		LOG_INF("Hostname: %s", CONFIG_MQTT_SAMPLE_BROKER_HOSTNAME);
		LOG_INF("Client ID: %s", (char *)client_id);
		LOG_INF("Port: %d", CONFIG_MQTT_HELPER_PORT);
		LOG_INF("TLS: %s", IS_ENABLED(CONFIG_MQTT_LIB_TLS) ? "Yes" : "No");
		subscribe();
	} else {
		LOG_WRN("Connection to broker not established, return_code: %d", return_code);
	}
}

6.2 Define a callback handler for the SUBACK event.

This function is called upon a SUBACK event, which is an acknowledgment from the broker for the subscription request. The result variable will indicate whether the subscription was succesful or not, see the list of return codes below

If the subscription was succesfull, check if the message ID of the packet matches SUBSCRIBE_TOPIC_ID, to confirm it’s the subscription acknowledgement for the CONFIG_MQTT_SAMPLE_SUB_TOPIC topic. Then log the subscription status as well as the received QoS level.

static void on_mqtt_suback(uint16_t message_id, int result)
{	
	if (result != MQTT_SUBACK_FAILURE) {
		if (message_id == SUBSCRIBE_TOPIC_ID) {
			LOG_INF("Subscribed to %s with QoS %d", CONFIG_MQTT_SAMPLE_SUB_TOPIC, result);
			return;
		}
		LOG_WRN("Subscribed to unknown topic, id: %d with QoS %d", message_id, result);
		return;
	}
	LOG_ERR("Topic subscription failed, error: %d", result);
}

static void on_mqtt_suback(uint16_t message_id, int result)
{	
	if (result != MQTT_SUBACK_FAILURE) {
		if (message_id == SUBSCRIBE_TOPIC_ID) {
			LOG_INF("Subscribed to %s with QoS %d", CONFIG_MQTT_SAMPLE_SUB_TOPIC, result);
			return;
		}
		LOG_WRN("Subscribed to unknown topic, id: %d with QoS %d", message_id, result);
		return;
	}
	LOG_ERR("Topic subscription failed, error: %d", result);
}

6.3 Define a callback handler for the PUBLISH event.

This callback handler is called whenever there is a message published to the topic we are subscribed to.

We want to examine the message using strncmp() to compare it to the LED commands and turn the LED on or off accordingly.

static void on_mqtt_publish(struct mqtt_helper_buf topic, struct mqtt_helper_buf payload)
{
	int err; 
	LOG_INF("Received payload: %.*s on topic: %.*s", payload.size,
							 payload.ptr,
							 topic.size,
							 topic.ptr);
	
	if (strncmp(payload.ptr, LED1_ON_CMD,
			    sizeof(LED1_ON_CMD) - 1) == 0) {
				err = dk_set_led_on(DK_LED1);
				if (err) {
					LOG_ERR("Failed to set LED %d on, error: %d", DK_LED1, err);
					return;
				}
	} else if (strncmp(payload.ptr, LED1_OFF_CMD,
			   sizeof(LED1_OFF_CMD) - 1) == 0) {
				err = dk_set_led_off(DK_LED1);
				if (err) {
					LOG_ERR("Failed to set LED %d off, error: %d", DK_LED1, err);
					return;
				}
	} else if (strncmp(payload.ptr, LED2_ON_CMD,
			   sizeof(LED2_ON_CMD) - 1) == 0) {
				err = dk_set_led_on(DK_LED2);
				if (err) {
					LOG_ERR("Failed to set LED %d on, error: %d", DK_LED2, err);
					return;
				}
	} else if (strncmp(payload.ptr, LED2_OFF_CMD,
			   sizeof(LED2_OFF_CMD) - 1) == 0) {
				err = dk_set_led_off(DK_LED2);
				if (err) {
					LOG_ERR("Failed to set LED %d off, error: %d", DK_LED2, err);
					return;
				}
	}
}

static void on_mqtt_publish(struct mqtt_helper_buf topic, struct mqtt_helper_buf payload)
{
	int err; 
	LOG_INF("Received payload: %.*s on topic: %.*s", payload.size,
							 payload.ptr,
							 topic.size,
							 topic.ptr);
	
	if (strncmp(payload.ptr, LED1_ON_CMD,
			    sizeof(LED1_ON_CMD) - 1) == 0) {
				err = dk_set_led_on(DK_LED1);
				if (err) {
					LOG_ERR("Failed to set LED %d on, error: %d", DK_LED1, err);
					return;
				}
	} else if (strncmp(payload.ptr, LED1_OFF_CMD,
			   sizeof(LED1_OFF_CMD) - 1) == 0) {
				err = dk_set_led_off(DK_LED1);
				if (err) {
					LOG_ERR("Failed to set LED %d off, error: %d", DK_LED1, err);
					return;
				}
	} else if (strncmp(payload.ptr, LED2_ON_CMD,
			   sizeof(LED2_ON_CMD) - 1) == 0) {
				err = dk_set_led_on(DK_LED2);
				if (err) {
					LOG_ERR("Failed to set LED %d on, error: %d", DK_LED2, err);
					return;
				}
	} else if (strncmp(payload.ptr, LED2_OFF_CMD,
			   sizeof(LED2_OFF_CMD) - 1) == 0) {
				err = dk_set_led_off(DK_LED2);
				if (err) {
					LOG_ERR("Failed to set LED %d off, error: %d", DK_LED2, err);
					return;
				}
	}
}

6.4 Define a callback handler for the DISCONNECT event.

This function is called upon a disconnect event from the broker. In this case, we log the event and the result.

static void on_mqtt_disconnect(int result)
{
	LOG_INF("MQTT client disconnected: %d", result);
}

static void on_mqtt_disconnect(int result)
{
	LOG_INF("MQTT client disconnected: %d", result);
}

7. Define the button handler to publish upon button triggers.

Upon pressing button 1, we want the button handler to publish the corresponding message to the MQTT broker.

In button_handler(), if a button is pressed, call publish() with the message to be published, BUTTON_MSG.

7.1 Publish BUTTON_MSG if button 1 is pressed.

		if (button_state & DK_BTN1_MSK){
			int err = publish(BUTTON_MSG, sizeof(BUTTON_MSG)-1);
			if (err) {
				LOG_INF("Failed to send message, %d", err);
				return;
			}
		}

		if (button_state & DK_BTN1_MSK){
			int err = publish(BUTTON_MSG, sizeof(BUTTON_MSG)-1);
			if (err) {
				LOG_INF("Failed to send message, %d", err);
				return;
			}
		}

8. Initialize the MQTT helper library.

Before connecting to the MQTT broker, we need to initialize the MQTT helper library using the library function mqtt_helper_init(), which takes a single parameter: struct mqtt_helper_cfg, with the following members

Let’s assign the callback functions we created in a previous step to the relevant members and pass the struct to mqtt_helper_init() to initialize the library with the callbacks.

Add the following code snippet

	struct mqtt_helper_cfg config = {
		.cb = {
			.on_connack = on_mqtt_connack,
			.on_disconnect = on_mqtt_disconnect,
			.on_publish = on_mqtt_publish,
			.on_suback = on_mqtt_suback,
		},
	};

	err = mqtt_helper_init(&config);
	if (err) {
		LOG_ERR("Failed to initialize MQTT helper, error: %d", err);
		return 0;
	}

	struct mqtt_helper_cfg config = {
		.cb = {
			.on_connack = on_mqtt_connack,
			.on_disconnect = on_mqtt_disconnect,
			.on_publish = on_mqtt_publish,
			.on_suback = on_mqtt_suback,
		},
	};

	err = mqtt_helper_init(&config);
	if (err) {
		LOG_ERR("Failed to initialize MQTT helper, error: %d", err);
		return 0;
	}

9. Generate the client ID.

Before we connect, we need a client ID to be used when connecting to the MQTT broker.

9.1 Define the function client_id_get() to generate the client id.

First, we check if the Kconfig CONFIG_MQTT_SAMPLE_CLIENT_ID is empty or not. If it’s empty, we will generate the client ID by retrieving the IMEI of the device from the modem through the AT command AT+CGSN, then adding “nrf-” in front.

Add the following code snippet inside the function definition

	int len;
	int err;
	char imei_buf[CGSN_RESPONSE_LENGTH];

	if (!buffer || buffer_len == 0) {
		LOG_ERR("Invalid buffer parameters");
		return -EINVAL;
	}

	if (strlen(CONFIG_MQTT_SAMPLE_CLIENT_ID) > 0) {
		len = snprintk(buffer, buffer_len, "%s",
			 CONFIG_MQTT_SAMPLE_CLIENT_ID);
	if ((len < 0) || (len >= buffer_len)) {
		LOG_ERR("Failed to format client ID from config, error: %d", len);
		return -EMSGSIZE;
	}
	LOG_DBG("client_id = %s", buffer);
	return 0;
	}

	err = nrf_modem_at_cmd(imei_buf, sizeof(imei_buf), "AT+CGSN");
	if (err) {
		LOG_ERR("Failed to obtain IMEI, error: %d", err);
		return err;
	}

	/* Validate IMEI length before null termination */
	if (IMEI_LEN >= sizeof(imei_buf)) {
		LOG_ERR("IMEI_LEN exceeds buffer size");
		return -EINVAL;
	}

	imei_buf[IMEI_LEN] = '\0';

	len = snprintk(buffer, buffer_len, "nrf-%.*s", IMEI_LEN, imei_buf);
	if ((len < 0) || (len >= buffer_len)) {
		LOG_ERR("Failed to format client ID from IMEI, error: %d", len);
		return -EMSGSIZE;
	}

	LOG_DBG("client_id = %s", buffer);

	return 0;

	int len;
	int err;
	char imei_buf[CGSN_RESPONSE_LENGTH];

	if (!buffer || buffer_len == 0) {
		LOG_ERR("Invalid buffer parameters");
		return -EINVAL;
	}

	if (strlen(CONFIG_MQTT_SAMPLE_CLIENT_ID) > 0) {
		len = snprintk(buffer, buffer_len, "%s",
			 CONFIG_MQTT_SAMPLE_CLIENT_ID);
	if ((len < 0) || (len >= buffer_len)) {
		LOG_ERR("Failed to format client ID from config, error: %d", len);
		return -EMSGSIZE;
	}
	LOG_DBG("client_id = %s", buffer);
	return 0;
	}

	err = nrf_modem_at_cmd(imei_buf, sizeof(imei_buf), "AT+CGSN");
	if (err) {
		LOG_ERR("Failed to obtain IMEI, error: %d", err);
		return err;
	}

	/* Validate IMEI length before null termination */
	if (IMEI_LEN >= sizeof(imei_buf)) {
		LOG_ERR("IMEI_LEN exceeds buffer size");
		return -EINVAL;
	}

	imei_buf[IMEI_LEN] = '\0';

	len = snprintk(buffer, buffer_len, "nrf-%.*s", IMEI_LEN, imei_buf);
	if ((len < 0) || (len >= buffer_len)) {
		LOG_ERR("Failed to format client ID from IMEI, error: %d", len);
		return -EMSGSIZE;
	}

	LOG_DBG("client_id = %s", buffer);

	return 0;

9.2 Declare a variable for the client ID.

static uint8_t client_id[CLIENT_ID_LEN];

static uint8_t client_id[CLIENT_ID_LEN];

9.2 Generate the client ID.

Generate the client ID by calling client_id_get() with the client ID we defined in the previous step as a parameter.

Add the following code snippet to main().

	err = client_id_get(client_id, sizeof(client_id));
    if (err) {
        LOG_ERR("Failed to get client ID, error: %d", err);
        return 0;
    }

	err = client_id_get(client_id, sizeof(client_id));
    if (err) {
        LOG_ERR("Failed to get client ID, error: %d", err);
        return 0;
    }

10. Establish a connection to the MQTT broker..

To connect to the MQTT broker, we will use the MQTT helper function mqtt_helper_connect(), which takes a single parameter: struct mqtt_helper_conn_params

Declare the structure and assign the Kconfig CONFIG_MQTT_SAMPLE_BROKER_HOSTNAME to hostname and the client ID (client_id) we generated in the previous step to device_id. Then call mqtt_helper_connect() with the struct to initiate the connection.

	struct mqtt_helper_conn_params conn_params = {
		.hostname.ptr = CONFIG_MQTT_SAMPLE_BROKER_HOSTNAME,
		.hostname.size = strlen(CONFIG_MQTT_SAMPLE_BROKER_HOSTNAME),
		.device_id.ptr = (char *)client_id,
		.device_id.size = strlen(client_id),
	};
	
	err = mqtt_helper_connect(&conn_params);
	if (err) {
		LOG_ERR("Failed to connect to MQTT, error code: %d", err);
		return 0;
	}

	struct mqtt_helper_conn_params conn_params = {
		.hostname.ptr = CONFIG_MQTT_SAMPLE_BROKER_HOSTNAME,
		.hostname.size = strlen(CONFIG_MQTT_SAMPLE_BROKER_HOSTNAME),
		.device_id.ptr = (char *)client_id,
		.device_id.size = strlen(client_id),
	};
	
	err = mqtt_helper_connect(&conn_params);
	if (err) {
		LOG_ERR("Failed to connect to MQTT, error code: %d", err);
		return 0;
	}

11. Build the exercise and flash it to your board.

You should see the following log output

*** Booting nRF Connect SDK ***
[00:00:00.407,379] <inf> Lesson4_Exercise2: Initializing modem library
[00:00:00.773,895] <inf> Lesson4_Exercise2: Connecting to LTE network
[00:00:02.101,654] <inf> Lesson4_Exercise2: RRC mode: Connected
[00:00:03.817,840] <inf> Lesson4_Exercise2: Network registration status: Connected - roaming
[00:00:03.817,932] <inf> Lesson4_Exercise2: Connected to LTE network
[00:00:06.305,725] <inf> Lesson4_Exercise2: Connected to MQTT broker
[00:00:06.305,755] <inf> Lesson4_Exercise2: Hostname: mqtt.nordicsemi.academy
[00:00:06.305,786] <inf> Lesson4_Exercise2: Client ID: nrf-355025930008030
[00:00:06.305,786] <inf> Lesson4_Exercise2: Port: 8883
[00:00:06.305,816] <inf> Lesson4_Exercise2: TLS: Yes
[00:00:06.305,847] <inf> Lesson4_Exercise2: Subscribing to devacademy/subscribe/topic
[00:00:06.421,722] <inf> Lesson4_Exercise2: Subscribed to devacademy/subscribe/topic with QoS 0
[00:00:09.013,061] <inf> Lesson4_Exercise2: RRC mode: Idle

Testing

12. To test the application, let’s set up a MQTT client to communicate with our device.

You will need an MQTT client running on your PC, smartphone or tablet. We will use MQTT Explorer, which enables us to create an MQTT client on our PC. You can use any MQTT client of your preference, there are also available MQTT clients for Android and iOS.

13. Connect to the MQTT broker.

In MQTT Explorer, add a connection to the same broker the board is connected to, by providing the broker name, hostname and its port as shown in the illustration below. Make sure to switch off TLS and certificates. Then click on Connect.

14. Subscribe to the topic that the board is publishing to.

In the search bar at the top of the window, input the topic name that the board is publishing to (set by CONFIG_MQTT_SAMPLE_PUB_TOPIC defined in prj.conf), to subscribe to it.

The default value is devacademy/publish/topic.

15. Push button 1 on your board. You should see a message show up, and if you expand it to reveal the payload, you should see the message “Button 1 pressed”, or whatever string you defined as BUTTON_MSG in step 3 (in the image below, for example, it’s Hi from nRF91 Series device).

16. Publish to the topic that the board is subscribed to.

In the panel to the right, scroll down to find the “Publish” window. Enter the topic name that the board is subscribed to (set by CONFIG_MQTT_SAMPLE_SUB_TOPIC defined in prj.conf). The default value is devacademy/subscribe/topic.

Then select “raw” as the message type, and QoS is 1.

Now type in the command for turning on the LED

LED1ON

LED1ON

Click Publish.

Observe that either LED1 on the nRF91 Series DK or the red LED on the Thingy:91 turns on.

The red on the Thingy:91 will be mixed with the connection green LED, so you should see a yellow color.

Now send the command for turning off the LED

LED1OFF

LED1OFF

The solution for this exercise can be found in l4/l4_e1_sol.