feat(esp-mqtt): Add ESP-MQTT example

examples/protocols/esp-mqtt/ws/CMakeLists.txt

@@ -0,0 +1,7 @@
+# The following four lines of boilerplate have to be in your project's CMakeLists
+# in this exact order for cmake to work correctly
+cmake_minimum_required(VERSION 3.5)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+
+project(mqtt_websocket)

examples/protocols/esp-mqtt/ws/Makefile

@@ -0,0 +1,7 @@
+#
+# This is a project Makefile. It is assumed the directory this Makefile resides in is a
+# project subdirectory.
+#
+PROJECT_NAME := mqtt_websocket
+
+include $(IDF_PATH)/make/project.mk

examples/protocols/esp-mqtt/ws/README.md

@@ -0,0 +1,62 @@
+# ESP-MQTT MQTT over Websocket
+
+(See the README.md file in the upper level 'examples' directory for more information about examples.)
+
+This example connects to the broker iot.eclipse.org over web sockets as a demonstration subscribes/unsubscribes and send a message on certain topic.
+
+It uses ESP-MQTT library which implements mqtt client to connect to mqtt broker.
+
+## How to use example
+
+### Hardware Required
+
+This example can be executed on any ESP32 board, the only required interface is WiFi and connection to internet.
+
+### Configure the project
+
+```
+make menuconfig
+```
+
+* Set serial port under Serial Flasher Options.
+
+* Set ssid and password for the board to connect to AP.
+
+### Build and Flash
+
+Build the project and flash it to the board, then run monitor tool to view serial output:
+
+```
+make -j4 flash monitor
+```
+
+(To exit the serial monitor, type ``Ctrl-]``.)
+
+See the Getting Started Guide for full steps to configure and use ESP-IDF to build projects.
+
+## Example Output
+
+```
+I (3714) event: sta ip: 192.168.0.139, mask: 255.255.255.0, gw: 192.168.0.2
+I (3714) system_api: Base MAC address is not set, read default base MAC address from BLK0 of EFUSE
+I (3964) MQTT_CLIENT: Sending MQTT CONNECT message, type: 1, id: 0000
+I (4164) MQTTWS_EXAMPLE: MQTT_EVENT_CONNECTED
+I (4174) MQTTWS_EXAMPLE: sent publish successful, msg_id=41464
+I (4174) MQTTWS_EXAMPLE: sent subscribe successful, msg_id=17886
+I (4174) MQTTWS_EXAMPLE: sent subscribe successful, msg_id=42970
+I (4184) MQTTWS_EXAMPLE: sent unsubscribe successful, msg_id=50241
+I (4314) MQTTWS_EXAMPLE: MQTT_EVENT_PUBLISHED, msg_id=41464
+I (4484) MQTTWS_EXAMPLE: MQTT_EVENT_SUBSCRIBED, msg_id=17886
+I (4484) MQTTWS_EXAMPLE: sent publish successful, msg_id=0
+I (4684) MQTTWS_EXAMPLE: MQTT_EVENT_SUBSCRIBED, msg_id=42970
+I (4684) MQTTWS_EXAMPLE: sent publish successful, msg_id=0
+I (4884) MQTT_CLIENT: deliver_publish, message_length_read=19, message_length=19
+I (4884) MQTTWS_EXAMPLE: MQTT_EVENT_DATA
+TOPIC=/topic/qos0
+DATA=data
+I (5194) MQTT_CLIENT: deliver_publish, message_length_read=19, message_length=19
+I (5194) MQTTWS_EXAMPLE: MQTT_EVENT_DATA
+TOPIC=/topic/qos0
+DATA=data
+```
+

examples/protocols/esp-mqtt/ws/main/CMakeLists.txt

@@ -0,0 +1,4 @@
+set(COMPONENT_SRCS "app_main.c")
+set(COMPONENT_ADD_INCLUDEDIRS ".")
+
+register_component()

examples/protocols/esp-mqtt/ws/main/Kconfig.projbuild

@@ -0,0 +1,21 @@
+menu "Example Configuration"
+
+config WIFI_SSID
+    string "WiFi SSID"
+    default "myssid"
+    help
+        SSID (network name) for the example to connect to.
+
+config WIFI_PASSWORD
+    string "WiFi Password"
+    default "mypassword"
+    help
+        WiFi password (WPA or WPA2) for the example to use.
+
+config BROKER_URI
+    string "Broker URL"
+    default "ws://iot.eclipse.org:80/ws"
+    help
+        URL of an mqtt broker which this example connects to.
+
+endmenu

examples/protocols/esp-mqtt/ws/main/app_main.c

@@ -0,0 +1,144 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+#include "esp_wifi.h"
+#include "esp_system.h"
+#include "nvs_flash.h"
+#include "esp_event_loop.h"
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/semphr.h"
+#include "freertos/queue.h"
+#include "freertos/event_groups.h"
+
+#include "lwip/sockets.h"
+#include "lwip/dns.h"
+#include "lwip/netdb.h"
+
+#include "esp_log.h"
+#include "mqtt_client.h"
+
+static const char *TAG = "MQTTWS_EXAMPLE";
+
+static EventGroupHandle_t wifi_event_group;
+const static int CONNECTED_BIT = BIT0;
+
+
+static esp_err_t mqtt_event_handler(esp_mqtt_event_handle_t event)
+{
+    esp_mqtt_client_handle_t client = event->client;
+    int msg_id;
+    // your_context_t *context = event->context;
+    switch (event->event_id) {
+        case MQTT_EVENT_CONNECTED:
+            ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED");
+            msg_id = esp_mqtt_client_subscribe(client, "/topic/qos0", 0);
+            ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);
+
+            msg_id = esp_mqtt_client_subscribe(client, "/topic/qos1", 1);
+            ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);
+
+            msg_id = esp_mqtt_client_unsubscribe(client, "/topic/qos1");
+            ESP_LOGI(TAG, "sent unsubscribe successful, msg_id=%d", msg_id);
+            break;
+        case MQTT_EVENT_DISCONNECTED:
+            ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED");
+            break;
+
+        case MQTT_EVENT_SUBSCRIBED:
+            ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);
+            msg_id = esp_mqtt_client_publish(client, "/topic/qos0", "data", 0, 0, 0);
+            ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id);
+            break;
+        case MQTT_EVENT_UNSUBSCRIBED:
+            ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id);
+            break;
+        case MQTT_EVENT_PUBLISHED:
+            ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id);
+            break;
+        case MQTT_EVENT_DATA:
+            ESP_LOGI(TAG, "MQTT_EVENT_DATA");
+            printf("TOPIC=%.*s\r\n", event->topic_len, event->topic);
+            printf("DATA=%.*s\r\n", event->data_len, event->data);
+            break;
+        case MQTT_EVENT_ERROR:
+            ESP_LOGI(TAG, "MQTT_EVENT_ERROR");
+            break;
+    }
+    return ESP_OK;
+}
+
+static esp_err_t wifi_event_handler(void *ctx, system_event_t *event)
+{
+    switch (event->event_id) {
+        case SYSTEM_EVENT_STA_START:
+            esp_wifi_connect();
+            break;
+        case SYSTEM_EVENT_STA_GOT_IP:
+            xEventGroupSetBits(wifi_event_group, CONNECTED_BIT);
+
+            break;
+        case SYSTEM_EVENT_STA_DISCONNECTED:
+            esp_wifi_connect();
+            xEventGroupClearBits(wifi_event_group, CONNECTED_BIT);
+            break;
+        default:
+            break;
+    }
+    return ESP_OK;
+}
+
+static void wifi_init(void)
+{
+    tcpip_adapter_init();
+    wifi_event_group = xEventGroupCreate();
+    ESP_ERROR_CHECK(esp_event_loop_init(wifi_event_handler, NULL));
+    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
+    ESP_ERROR_CHECK(esp_wifi_init(&cfg));
+    ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));
+    wifi_config_t wifi_config = {
+        .sta = {
+            .ssid = CONFIG_WIFI_SSID,
+            .password = CONFIG_WIFI_PASSWORD,
+        },
+    };
+    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
+    ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config));
+    ESP_LOGI(TAG, "start the WIFI SSID:[%s]", CONFIG_WIFI_SSID);
+    ESP_ERROR_CHECK(esp_wifi_start());
+    ESP_LOGI(TAG, "Waiting for wifi");
+    xEventGroupWaitBits(wifi_event_group, CONNECTED_BIT, false, true, portMAX_DELAY);
+}
+
+static void mqtt_app_start(void)
+{
+    const esp_mqtt_client_config_t mqtt_cfg = {
+        .uri = CONFIG_BROKER_URI,
+        .event_handle = mqtt_event_handler,
+        // .user_context = (void *)your_context
+    };
+
+    esp_mqtt_client_handle_t client = esp_mqtt_client_init(&mqtt_cfg);
+    esp_mqtt_client_start(client);
+}
+
+void app_main()
+{
+    ESP_LOGI(TAG, "[APP] Startup..");
+    ESP_LOGI(TAG, "[APP] Free memory: %d bytes", esp_get_free_heap_size());
+    ESP_LOGI(TAG, "[APP] IDF version: %s", esp_get_idf_version());
+
+    esp_log_level_set("*", ESP_LOG_INFO);
+    esp_log_level_set("MQTT_CLIENT", ESP_LOG_VERBOSE);
+    esp_log_level_set("TRANSPORT_TCP", ESP_LOG_VERBOSE);
+    esp_log_level_set("TRANSPORT_SSL", ESP_LOG_VERBOSE);
+    esp_log_level_set("TRANSPORT_WS", ESP_LOG_VERBOSE);
+    esp_log_level_set("TRANSPORT", ESP_LOG_VERBOSE);
+    esp_log_level_set("OUTBOX", ESP_LOG_VERBOSE);
+
+    nvs_flash_init();
+    wifi_init();
+    mqtt_app_start();
+}

examples/protocols/esp-mqtt/ws/mqtt_ws_example_test.py

@@ -0,0 +1,115 @@
+from __future__ import print_function
+from __future__ import unicode_literals
+from builtins import str
+import re
+import os
+import sys
+import paho.mqtt.client as mqtt
+from threading import Thread, Event
+
+
+try:
+    import IDF
+except Exception:
+    # this is a test case write with tiny-test-fw.
+    # to run test cases outside tiny-test-fw,
+    # we need to set environment variable `TEST_FW_PATH`,
+    # then get and insert `TEST_FW_PATH` to sys path before import FW module
+    test_fw_path = os.getenv("TEST_FW_PATH")
+    if test_fw_path and test_fw_path not in sys.path:
+        sys.path.insert(0, test_fw_path)
+    import IDF
+
+import DUT
+
+event_client_connected = Event()
+event_stop_client = Event()
+event_client_received_correct = Event()
+message_log = ""
+
+
+# The callback for when the client receives a CONNACK response from the server.
+def on_connect(client, userdata, flags, rc):
+    print("Connected with result code " + str(rc))
+    event_client_connected.set()
+    client.subscribe("/topic/qos0")
+
+
+def mqtt_client_task(client):
+    while not event_stop_client.is_set():
+        client.loop()
+
+
+# The callback for when a PUBLISH message is received from the server.
+def on_message(client, userdata, msg):
+    global message_log
+    payload = msg.payload.decode()
+    if not event_client_received_correct.is_set() and payload == "data":
+        client.publish("/topic/qos0", "data_to_esp32")
+        if msg.topic == "/topic/qos0" and payload == "data":
+            event_client_received_correct.set()
+    message_log += "Received data:" + msg.topic + " " + payload + "\n"
+
+
+@IDF.idf_example_test(env_tag="Example_WIFI")
+def test_examples_protocol_mqtt_ws(env, extra_data):
+    broker_url = ""
+    broker_port = 0
+    """
+    steps: |
+      1. join AP and connects to ws broker
+      2. Test connects a client to the same broker
+      3. Test evaluates it received correct qos0 message
+      4. Test ESP32 client received correct qos0 message
+    """
+    dut1 = env.get_dut("mqtt_websocket", "examples/protocols/mqtt/ws")
+    # check and log bin size
+    binary_file = os.path.join(dut1.app.binary_path, "mqtt_websocket.bin")
+    bin_size = os.path.getsize(binary_file)
+    IDF.log_performance("mqtt_websocket_bin_size", "{}KB".format(bin_size // 1024))
+    IDF.check_performance("mqtt_websocket_size", bin_size // 1024)
+    # Look for host:port in sdkconfig
+    try:
+        value = re.search(r'\:\/\/([^:]+)\:([0-9]+)', dut1.app.get_sdkconfig()["CONFIG_BROKER_URI"])
+        broker_url = value.group(1)
+        broker_port = int(value.group(2))
+    except Exception:
+        print('ENV_TEST_FAILURE: Cannot find broker url in sdkconfig')
+        raise
+    client = None
+    # 1. Test connects to a broker
+    try:
+        client = mqtt.Client(transport="websockets")
+        client.on_connect = on_connect
+        client.on_message = on_message
+        client.ws_set_options(path="/ws", headers=None)
+        print("Connecting...")
+        client.connect(broker_url, broker_port, 60)
+    except Exception:
+        print("ENV_TEST_FAILURE: Unexpected error while connecting to broker {}: {}:".format(broker_url, sys.exc_info()[0]))
+        raise
+    # Starting a py-client in a separate thread
+    thread1 = Thread(target=mqtt_client_task, args=(client,))
+    thread1.start()
+    try:
+        print("Connecting py-client to broker {}:{}...".format(broker_url, broker_port))
+        if not event_client_connected.wait(timeout=30):
+            raise ValueError("ENV_TEST_FAILURE: Test script cannot connect to broker: {}".format(broker_url))
+        dut1.start_app()
+        try:
+            ip_address = dut1.expect(re.compile(r" sta ip: ([^,]+),"), timeout=30)
+            print("Connected to AP with IP: {}".format(ip_address))
+        except DUT.ExpectTimeout:
+            print('ENV_TEST_FAILURE: Cannot connect to AP')
+            raise
+        print("Checking py-client received msg published from esp...")
+        if not event_client_received_correct.wait(timeout=30):
+            raise ValueError('Wrong data received, msg log: {}'.format(message_log))
+        print("Checking esp-client received msg published from py-client...")
+        dut1.expect(re.compile(r"DATA=data_to_esp32"), timeout=30)
+    finally:
+        event_stop_client.set()
+        thread1.join()
+
+if __name__ == '__main__':
+    test_examples_protocol_mqtt_ws()

examples/protocols/esp-mqtt/ws/sdkconfig.ci

@@ -0,0 +1 @@
+CONFIG_BROKER_URI="ws://${EXAMPLE_MQTT_BROKER_WS}/ws"