Using nrf9160 with W5500 Ethernet
NCS Version 2.6.1
My normal MQTT connection is working fine, but connecting to aws is being an issue. I am getting mqtt -22 error. I have tried almost everything but nothing is working. I have tested using mqtt client software my AWS side is working fine, so there is definitly issue on my coding side.
.conf file
# GPIO
CONFIG_GPIO=y
# Logging
CONFIG_LOG=y
CONFIG_CONSOLE=y
#CONFIG_LOG_BUFFER_SIZE=2048
CONFIG_HW_ID_LIBRARY=y
CONFIG_JSON_LIBRARY=y
# Heap and stacks
CONFIG_HEAP_MEM_POOL_SIZE=4096
CONFIG_MAIN_STACK_SIZE=4096
#CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE=2048
# Newlibc
CONFIG_NEWLIB_LIBC=y
# Ethernet
CONFIG_SPI=y
CONFIG_NET_L2_ETHERNET=y
CONFIG_ETH_W5500=y
CONFIG_ETH_W5500_TIMEOUT=10000
CONFIG_ETHERNET_LOG_LEVEL_DBG=y
CONFIG_ETHERNET_LOG_LEVEL_INF=y
CONFIG_NETWORKING=y
CONFIG_NET_IPV6=n
CONFIG_NET_IPV4=y
CONFIG_NET_ARP=y
CONFIG_NET_UDP=y
CONFIG_NET_DHCPV4=y
CONFIG_NET_DHCPV4_OPTION_CALLBACKS=y
#CONFIG_NET_NATIVE=n
CONFIG_NET_SOCKETS=y
CONFIG_NET_SOCKETS_SOCKOPT_TLS=y
#CONFIG_NET_SOCKETS_OFFLOAD=y
CONFIG_NET_TCP=y
CONFIG_NET_CONNECTION_MANAGER=y
CONFIG_NET_CONNECTION_MANAGER_MONITOR_STACK_SIZE=1024
CONFIG_DNS_RESOLVER=y
#CONFIG_DNS_SERVER_IP_ADDRESSES=y
#CONFIG_NET_SOCKETS_POSIX_NAMES=y
#CONFIG_DNS_SERVER1="8.8.8.8"
#CONFIG_NET_CONFIG_NEED_IPV4=y
#CONFIG_NET_CONFIG_SETTINGS=y
CONFIG_TEST_RANDOM_GENERATOR=y
CONFIG_INIT_STACKS=y
CONFIG_NET_MGMT=y
CONFIG_NET_MGMT_EVENT=y
CONFIG_NET_LOG=y
#CONFIG_SLIP_STATISTICS=n
CONFIG_NET_SHELL=y
# # AWS IoT library
# CONFIG_AWS_IOT=y
# CONFIG_AWS_IOT_CLIENT_ID_STATIC="aws_nrf9160"
# CONFIG_AWS_IOT_BROKER_HOST_NAME="ag9gkz7w9pc2h-ats.iot.us-east-1.amazonaws.com"
# CONFIG_AWS_IOT_TOPIC_UPDATE_DELTA_SUBSCRIBE=y
# CONFIG_AWS_IOT_TOPIC_GET_ACCEPTED_SUBSCRIBE=y
# CONFIG_AWS_IOT_TOPIC_GET_REJECTED_SUBSCRIBE=y
# # MQTT helper library
# CONFIG_MQTT_HELPER=y
# CONFIG_MQTT_HELPER_SEC_TAG=201
# CONFIG_MQTT_HELPER_LAST_WILL=y
# CONFIG_MQTT_HELPER_STACK_SIZE=4096
# # MQTT - Maximum MQTT keepalive timeout specified by AWS IoT Core
# CONFIG_MQTT_KEEPALIVE=1200
# CONFIG_MQTT_CLEAN_SESSION=y
# Modem library
# CONFIG_TRUSTED_EXECUTION_NONSECURE=y
# CONFIG_NRF_MODEM_LIB=y
# CONFIG_MODEM_KEY_MGMT=y
# Enable the MQTT Lib
CONFIG_MQTT_LIB=y
CONFIG_MQTT_LIB_TLS=y
# # TLS configuration
CONFIG_MBEDTLS=y
CONFIG_MBEDTLS_BUILTIN=y
# # CONFIG_MBEDTLS_ENABLE_HEAP=y
# # CONFIG_MBEDTLS_HEAP_SIZE=30000
# # CONFIG_MBEDTLS_SSL_MAX_CONTENT_LEN=16384
# CONFIG_MBEDTLS_PEM_CERTIFICATE_FORMAT=y
# CONFIG_MBEDTLS_SERVER_NAME_INDICATION=y
Network establishing file with w5500
#include <zephyr/kernel.h>
#include <zephyr/net/net_if.h>
#include <zephyr/net/net_core.h>
#include <zephyr/net/net_context.h>
#include <zephyr/net/net_mgmt.h>
#include <zephyr/logging/log.h>
#include <zephyr/net/socket.h>
#include <zephyr/net/conn_mgr_connectivity.h>
#include <zephyr/net/conn_mgr_monitor.h>
LOG_MODULE_REGISTER(app_network);
#include "app_network.h"
#define DHCP_OPTION_NTP (42)
static uint8_t ntp_server[4];
/* Network mgmt */
static struct net_mgmt_event_callback mgmt_cb;
static struct net_mgmt_event_callback mgmt_cb_link_up;
static struct net_mgmt_event_callback mgmt_cb_link_down;
static struct net_dhcpv4_option_callback dhcp_cb;
/* Macros used to subscribe to specific Zephyr NET management events. */
#define L4_EVENT_MASK (NET_EVENT_L4_CONNECTED | NET_EVENT_L4_DISCONNECTED)
/* Zephyr NET management event callback structures. */
static struct net_mgmt_event_callback l4_cb;
/* Network interface */
struct net_if *iface;
/* Define message queue */
K_MSGQ_DEFINE(app_event_msq, sizeof(struct app_event), APP_EVENT_QUEUE_SIZE, 4);
static void option_handler(struct net_dhcpv4_option_callback *cb,
size_t length,
enum net_dhcpv4_msg_type msg_type,
struct net_if *iface)
{
char buf[NET_IPV4_ADDR_LEN];
LOG_INF("DHCP Option %d: %s", cb->option,
net_addr_ntop(AF_INET, cb->data, buf, sizeof(buf)));
}
int app_event_manager_push(struct app_event *p_evt)
{
return k_msgq_put(&app_event_msq, p_evt, K_NO_WAIT);
}
int app_event_manager_get(struct app_event *p_evt)
{
return k_msgq_get(&app_event_msq, p_evt, K_FOREVER);
}
char *app_event_type_to_string(enum app_event_type type)
{
switch (type)
{
case APP_EVENT_ETHERNET_DISCONNECT:
return "APP_EVENT_ETHERNET_DISCONNECT";
case APP_EVENT_ETHERNET_CONNECTED:
return "APP_EVENT_ETHERNET_CONNECTED";
case APP_EVENT_ETHERNET_READY:
return "APP_EVENT_ETHERNET_READY";
case APP_EVENT_BACKEND_ERROR:
return "APP_EVENT_BACKEND_ERROR";
case APP_EVENT_BACKEND_CONNECTED:
return "APP_EVENT_BACKEND_CONNECTED";
case APP_EVENT_BACKEND_DISCONNECTED:
return "APP_EVENT_BACKEND_DISCONNECTED";
case APP_EVENT_BLE_DATA:
return "APP_EVENT_BLE_DATA";
default:
return "UNKNOWN";
}
}
/**
* @brief Network management handler
*
* @param cb
* @param mgmt_event
* @param iface
*/
static void net_mgmt_handler(struct net_mgmt_event_callback *cb,
uint32_t mgmt_event,
struct net_if *iface)
{
int i = 0;
switch (mgmt_event)
{
case NET_EVENT_IPV4_ADDR_ADD:
for (i = 0; i < NET_IF_MAX_IPV4_ADDR; i++)
{
char buf[NET_IPV4_ADDR_LEN];
if (iface->config.ip.ipv4->unicast[i].addr_type !=
NET_ADDR_DHCP)
{
continue;
}
LOG_INF("Your address: %s",
(char *)(net_addr_ntop(AF_INET,
&iface->config.ip.ipv4->unicast[i].address.in_addr,
buf, sizeof(buf))));
LOG_INF("Lease time: %u seconds",
iface->config.dhcpv4.lease_time);
LOG_INF("Subnet: %s",
(char *)(net_addr_ntop(AF_INET,
&iface->config.ip.ipv4->netmask,
buf, sizeof(buf))));
LOG_INF("Router: %s",
(char *)(net_addr_ntop(AF_INET,
&iface->config.ip.ipv4->gw,
buf, sizeof(buf))));
/* Ready event */
// APP_EVENT_MANAGER_PUSH(APP_EVENT_ETHERNET_READY);
}
break;
default:
LOG_INF("Net management event: %i", mgmt_event);
break;
}
}
static void net_mgmt_link_up(struct net_mgmt_event_callback *cb,
uint32_t mgmt_event,
struct net_if *iface)
{
if (mgmt_event == NET_EVENT_IF_UP) {
LOG_INF("LINK UP");
}
}
static void net_mgmt_link_down(struct net_mgmt_event_callback *cb,
uint32_t mgmt_event,
struct net_if *iface)
{
if (mgmt_event == NET_EVENT_IF_DOWN) {
LOG_INF("LINK DOWN");
}
}
static void l4_event_handler(struct net_mgmt_event_callback *cb,
uint32_t event,
struct net_if *iface)
{
int err;
enum network_status status;
switch (event) {
case NET_EVENT_L4_CONNECTED:
LOG_INF("Network connectivity established");
status = NETWORK_CONNECTED;
APP_EVENT_MANAGER_PUSH(APP_EVENT_ETHERNET_READY);
break;
case NET_EVENT_L4_DISCONNECTED:
LOG_INF("Network connectivity lost");
status = NETWORK_DISCONNECTED;
break;
default:
/* Don't care */
return;
}
}
/**
* @brief Initialize ethernet network
*
*/
void app_net_init()
{
int err;
LOG_INF("Network Initialization");
/* Setup callback */
net_mgmt_init_event_callback(&mgmt_cb, net_mgmt_handler,NET_EVENT_IPV4_ADDR_ADD );
net_mgmt_init_event_callback(&mgmt_cb_link_up, net_mgmt_link_up,NET_EVENT_IF_UP );
net_mgmt_init_event_callback(&mgmt_cb_link_down, net_mgmt_link_down,NET_EVENT_IF_DOWN );
net_mgmt_add_event_callback(&mgmt_cb);
net_mgmt_add_event_callback(&mgmt_cb_link_up);
net_mgmt_add_event_callback(&mgmt_cb_link_down);
net_dhcpv4_init_option_callback(&dhcp_cb, option_handler,
DHCP_OPTION_NTP, ntp_server,
sizeof(ntp_server));
net_dhcpv4_add_option_callback(&dhcp_cb);
/* Get interface */
iface = net_if_get_default();
LOG_INF("Start on %s: index=%d", net_if_get_device(iface)->name,
net_if_get_by_iface(iface));
// /* Start dhcp discovery */
net_dhcpv4_start(iface);
/* Setup handler for Zephyr NET Connection Manager events. */
net_mgmt_init_event_callback(&l4_cb, l4_event_handler, L4_EVENT_MASK);
net_mgmt_add_event_callback(&l4_cb);
err = conn_mgr_all_if_up(true);
if (err) {
LOG_ERR("conn_mgr_all_if_up, error: %d", err);
return;
}
err = conn_mgr_all_if_connect(true);
if (err) {
LOG_ERR("conn_mgr_all_if_connect, error: %d", err);
return;
}
// APP_EVENT_MANAGER_PUSH(APP_EVENT_ETHERNET_READY);
}
MQTT file to make AWS connection
#if defined(CONFIG_MQTT_LIB_TLS)
#define SERVER_ADDR "ag9gkz7w9pc2h-ats.iot.us-east-1.amazonaws.com"
#define SERVER_PORT 8883
#else
#define SERVER_ADDR "broker.hivemq.com"
#define SERVER_PORT 1883
#endif
#define APP_MQTT_BUFFER_SIZE 128
#define APP_CONNECT_TRIES 10
#define MQTT_CLIENTID "aws_nrf9160"
#include <zephyr/logging/log.h>
#include <zephyr/kernel.h>
#include <zephyr/net/socket.h>
#include <zephyr/net/mqtt.h>
#include <zephyr/random/random.h>
#include <string.h>
#include <errno.h>
#include <zephyr/net/tls_credentials.h>
// #include <modem/modem_key_mgmt.h>
// #include <modem/nrf_modem_lib.h>
LOG_MODULE_REGISTER(app_mqtt);
#include "app_mqtt.h"
#include "creds.h"
/* Buffers for MQTT client. */
static uint8_t rx_buffer[256];
static uint8_t tx_buffer[256];
/* MQTT client context */
static struct mqtt_client client_ctx;
/* MQTT Broker address information. */
static struct sockaddr_storage broker;
static struct zsock_pollfd fds[1];
static bool connected;
#if defined(CONFIG_MQTT_LIB_TLS)
#define TLS_SNI_HOSTNAME "ag9gkz7w9pc2h-ats.iot.us-east-1.amazonaws.com"
#define APP_CA_CERT_TAG 1
#define APP_DEV_CERT_TAG 2
#define APP_PRIV_CERT_TAG 3
#define APP_CERT_TAG 16842753
#define APP_PSK_TAG 2
#define TLS_TAG_DEVICE_CERTIFICATE 1
#define TLS_TAG_DEVICE_PRIVATE_KEY 1
#define TLS_TAG_AWS_CA_CERTIFICATE 2
static sec_tag_t m_sec_tags[] = {
TLS_TAG_DEVICE_CERTIFICATE,
// TLS_TAG_AWS_CA_CERTIFICATE,
};
static int tls_init(void)
{
int ret;
ret = tls_credential_add(TLS_TAG_DEVICE_CERTIFICATE, TLS_CREDENTIAL_CA_CERTIFICATE, ca_cert,
ca_cert_len);
if (ret < 0)
{
LOG_ERR("Failed to add ca certs: %d", ret);
return ret;
}
ret = tls_credential_add(TLS_TAG_DEVICE_PRIVATE_KEY, TLS_CREDENTIAL_PRIVATE_KEY,
private_key, private_key_len);
if (ret < 0)
{
LOG_ERR("Failed to add device private key: %d", ret);
return ret;
}
ret = tls_credential_add(TLS_TAG_DEVICE_CERTIFICATE, TLS_CREDENTIAL_SERVER_CERTIFICATE,
public_cert, public_cert_len);
if (ret < 0)
{
LOG_ERR("Failed to add device certificate: %d", ret);
return ret;
}
return ret;
}
#endif
static void mqtt_evt_handler(struct mqtt_client *client,
const struct mqtt_evt *evt)
{
int err;
switch (evt->type)
{
case MQTT_EVT_CONNACK:
if (evt->result != 0)
{
LOG_ERR("MQTT connect failed %d", evt->result);
break;
}
connected = true;
LOG_INF("MQTT client connected!");
break;
case MQTT_EVT_DISCONNECT:
LOG_INF("MQTT client disconnected %d", evt->result);
connected = false;
break;
case MQTT_EVT_PUBACK:
if (evt->result != 0)
{
LOG_ERR("MQTT PUBACK error %d", evt->result);
break;
}
LOG_INF("PUBACK packet id: %u", evt->param.puback.message_id);
break;
case MQTT_EVT_PUBREC:
if (evt->result != 0)
{
LOG_ERR("MQTT PUBREC error %d", evt->result);
break;
}
LOG_INF("PUBREC packet id: %u", evt->param.pubrec.message_id);
const struct mqtt_pubrel_param rel_param = {
.message_id = evt->param.pubrec.message_id};
break;
case MQTT_EVT_PUBCOMP:
if (evt->result != 0)
{
LOG_ERR("MQTT PUBCOMP error %d", evt->result);
break;
}
LOG_INF("PUBCOMP packet id: %u",
evt->param.pubcomp.message_id);
break;
case MQTT_EVT_PINGRESP:
LOG_INF("PINGRESP packet");
break;
default:
break;
}
}
static char *get_mqtt_payload(enum mqtt_qos qos)
{
static char payload[] = "DOORS:OPEN_QoSx";
payload[strlen(payload) - 1] = '0' + qos;
return payload;
}
static int publish(struct mqtt_client *client, enum mqtt_qos qos)
{
struct mqtt_publish_param param;
param.message.topic.qos = qos;
param.message.topic.topic.utf8 = (uint8_t *)"TEST";
param.message.topic.topic.size =
strlen(param.message.topic.topic.utf8);
param.message.payload.data = get_mqtt_payload(qos);
param.message.payload.len =
strlen(param.message.payload.data);
param.message_id = sys_rand32_get();
param.dup_flag = 0U;
param.retain_flag = 0U;
return mqtt_publish(client, ¶m);
}
/**@brief Resolves the configured hostname and
* initializes the MQTT broker structure
*/
static int broker_init(void)
{
int err;
struct addrinfo *result;
struct addrinfo *addr;
struct addrinfo hints = {
.ai_family = AF_INET,
.ai_socktype = SOCK_STREAM};
err = getaddrinfo(SERVER_ADDR, "8883", &hints, &result);
if (err)
{
LOG_ERR("getaddrinfo failed: %d", err);
return -ECHILD;
}
addr = result;
/* Look for address of the broker. */
while (addr != NULL)
{
/* IPv4 Address. */
if (addr->ai_addrlen == sizeof(struct sockaddr_in))
{
struct sockaddr_in *broker4 =
((struct sockaddr_in *)&broker);
char ipv4_addr[NET_IPV4_ADDR_LEN];
broker4->sin_addr.s_addr =
((struct sockaddr_in *)addr->ai_addr)
->sin_addr.s_addr;
broker4->sin_family = AF_INET;
broker4->sin_port = htons(SERVER_PORT);
inet_ntop(AF_INET, &broker4->sin_addr.s_addr,
ipv4_addr, sizeof(ipv4_addr));
LOG_INF("IPv4 Address found %s", ipv4_addr);
break;
}
else
{
LOG_ERR("ai_addrlen = %u should be %u or %u",
(unsigned int)addr->ai_addrlen,
(unsigned int)sizeof(struct sockaddr_in),
(unsigned int)sizeof(struct sockaddr_in6));
}
addr = addr->ai_next;
}
/* Free the address. */
freeaddrinfo(result);
return err;
}
static int resolve_broker_addr()
{
struct sockaddr_in *broker4 =
((struct sockaddr_in *)&broker);
int ret;
struct zsock_addrinfo *ai = NULL;
const struct zsock_addrinfo hints = {
.ai_family = AF_INET,
.ai_socktype = SOCK_STREAM,
.ai_protocol = 0,
};
ret = zsock_getaddrinfo(SERVER_ADDR, "8883", &hints, &ai);
if (ret == 0)
{
char addr_str[INET_ADDRSTRLEN];
memcpy(broker4, ai->ai_addr, MIN(ai->ai_addrlen, sizeof(struct sockaddr_storage)));
zsock_inet_ntop(AF_INET, &broker4->sin_addr, addr_str, sizeof(addr_str));
LOG_INF("Resolved: %s:%u", addr_str, htons(broker4->sin_port));
}
else
{
LOG_ERR("failed to resolve hostname err = %d (errno = %d)", ret, errno);
}
zsock_freeaddrinfo(ai);
return ret;
}
static void client_init(struct mqtt_client *client)
{
mqtt_client_init(client);
broker_init();
//resolve_broker_addr();
/* MQTT client configuration */
client->broker = &broker;
client->evt_cb = mqtt_evt_handler;
client->client_id.utf8 = (uint8_t *)MQTT_CLIENTID;
client->client_id.size = strlen(MQTT_CLIENTID);
client->password = NULL;
client->user_name = NULL;
client->protocol_version = MQTT_VERSION_3_1_1;
/* MQTT buffers configuration */
client->rx_buf = rx_buffer;
client->rx_buf_size = sizeof(rx_buffer);
client->tx_buf = tx_buffer;
client->tx_buf_size = sizeof(tx_buffer);
#if defined(CONFIG_MQTT_LIB_TLS)
client->transport.type = MQTT_TRANSPORT_SECURE;
struct mqtt_sec_config *tls_config = &client->transport.tls.config;
tls_config->peer_verify = TLS_PEER_VERIFY_REQUIRED;
tls_config->cipher_list = NULL;
tls_config->sec_tag_list = m_sec_tags;
tls_config->sec_tag_count = ARRAY_SIZE(m_sec_tags);
tls_config->hostname = TLS_SNI_HOSTNAME;
// tls_config->set_native_tls = true;
#else
client->transport.type = MQTT_TRANSPORT_NON_SECURE;
#endif
}
void app_mqtt_init()
{
int rc, i = 0;
#if defined(CONFIG_MQTT_LIB_TLS)
rc = tls_init();
LOG_INF("tls_init %d", rc);
#endif
while (i++ < APP_CONNECT_TRIES && !connected)
{
LOG_INF("Initializing MQTT ");
client_init(&client_ctx);
rc = mqtt_connect(&client_ctx);
if (rc != 0)
{
LOG_INF("mqtt_connect, %d", rc);
k_msleep(1000);
continue;
}
if (client_ctx.transport.type == MQTT_TRANSPORT_NON_SECURE)
{
fds[0].fd = client_ctx.transport.tcp.sock;
}
#if defined(CONFIG_MQTT_LIB_TLS)
else if (client_ctx.transport.type == MQTT_TRANSPORT_SECURE)
{
fds[0].fd = client_ctx.transport.tls.sock;
}
#endif
fds[0].events = ZSOCK_POLLIN;
poll(fds, 1, 2000);
mqtt_input(&client_ctx);
if (!connected)
{
mqtt_abort(&client_ctx);
}
}
while (connected)
{
poll(fds, 1, 2000);
mqtt_input(&client_ctx);
rc = mqtt_live(&client_ctx);
if (rc != 0 && rc != -EAGAIN)
{
LOG_INF("mqtt_live, %d", rc);
}
else if (rc == 0)
{
rc = mqtt_input(&client_ctx);
if (rc != 0)
{
LOG_INF("mqtt_input, %d", rc);
}
}
rc = publish(&client_ctx, MQTT_QOS_0_AT_MOST_ONCE);
LOG_INF("mqtt_publish, %d", rc);
}
}
main file
#include <stdlib.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(Main);
#include <app_network.h>
#include <app_mqtt.h>
#include "app_aws.h"
int main(void)
{
int aws_client;
LOG_INF("Main started .... ");
/* Init network */
app_net_init();
//aws_client = app_aws_client_init();
while (true)
{
struct app_event evt = {0};
app_event_manager_get(&evt);
switch (evt.type)
{
case APP_EVENT_ETHERNET_READY:
LOG_INF("Ethernet is Ready");
app_mqtt_init();
// if(!aws_client)
// {
// app_aws_init();
// }
// else
// {
// LOG_INF("aws client issue");
// }
break;
default:
break;
}
}
return 0;
}
Finally my output
[00:00:00.382,110] <inf> eth_w5500: MAC ADDRESS: 2 8 dc 86 7 e2
[00:00:00.383,300] <inf> eth_w5500: W5500 Initialized
*** Booting nRF Connect SDK 3758bcbfa5cd ***
[00:00:00.384,521] <inf> Main: Main started ....
[00:00:00.384,552] <inf> app_network: Network Initialization
[00:00:00.384,582] <inf> app_network: Start on eth_w5500@0: index=1
[00:00:00.384,613] <inf> app_network: Net management event: -536608761
[00:00:02.383,789] <inf> eth_w5500: eth_w5500@0: Link up
[00:00:02.383,911] <inf> app_network: LINK UP
[00:00:07.582,427] <inf> net_dhcpv4: Received: 192.168.1.95
[00:00:07.582,580] <inf> app_network: Your address: 192.168.1.95
[00:00:07.582,580] <inf> app_network: Lease time: 4294967295 seconds
[00:00:07.582,641] <inf> app_network: Subnet: 255.255.255.0
[00:00:07.582,672] <inf> app_network: Router: 192.168.1.1
[00:00:07.582,794] <inf> app_network: Network connectivity established
[00:00:07.582,855] <inf> Main: Ethernet is Ready
[00:00:07.582,885] <inf> app_mqtt: tls_init 0
[00:00:07.582,885] <inf> app_mqtt: Initializing MQTT
[00:00:07.701,812] <inf> app_mqtt: IPv4 Address found 52.70.185.82
[00:00:07.935,333] <inf> app_mqtt: mqtt_connect, -22
[00:00:08.935,424] <inf> app_mqtt: Initializing MQTT
[00:00:08.980,041] <inf> app_mqtt: IPv4 Address found 54.204.31.69
[00:00:09.204,101] <inf> app_mqtt: mqtt_connect, -22
[00:00:10.204,223] <inf> app_mqtt: Initializing MQTT
[00:00:10.210,235] <inf> app_mqtt: IPv4 Address found 52.4.41.178
[00:00:10.432,830] <inf> app_mqtt: mqtt_connect, -22
[00:00:11.432,952] <inf> app_mqtt: Initializing MQTT
[00:00:11.475,982] <inf> app_mqtt: IPv4 Address found 54.145.177.121
[00:00:11.689,270] <inf> app_mqtt: mqtt_connect, -22
[00:00:12.689,331] <inf> app_mqtt: Initializing MQTT
[00:00:12.694,732] <inf> app_mqtt: IPv4 Address found 52.7.86.229
[00:00:12.908,233] <inf> app_mqtt: mqtt_connect, -22
[00:00:13.908,325] <inf> app_mqtt: Initializing MQTT
[00:00:13.913,696] <inf> app_mqtt: IPv4 Address found 52.54.187.118
[00:00:14.137,512] <inf> app_mqtt: mqtt_connect, -22
[00:00:15.137,603] <inf> app_mqtt: Initializing MQTT
[00:00:15.143,707] <inf> app_mqtt: IPv4 Address found 54.209.10.217
[00:00:15.367,218] <inf> app_mqtt: mqtt_connect, -22
[00:00:16.367,279] <inf> app_mqtt: Initializing MQTT
[00:00:16.373,321] <inf> app_mqtt: IPv4 Address found 52.70.185.82
[00:00:16.605,560] <inf> app_mqtt: mqtt_connect, -22
[00:00:17.605,682] <inf> app_mqtt: Initializing MQTT
[00:00:17.611,419] <inf> app_mqtt: IPv4 Address found 52.2.217.188
[00:00:17.833,465] <inf> app_mqtt: mqtt_connect, -22
[00:00:18.833,526] <inf> app_mqtt: Initializing MQTT
[00:00:18.838,989] <inf> app_mqtt: IPv4 Address found 52.4.36.166
[00:00:19.060,577] <inf> app_mqtt: mqtt_connect, -22
