Hi, I am using nrf9160 with aws_iot library with zeyphros
Now the issue is when aws is initalized I get mpu fault, I have tracked down that issue is coming from mqtt helper library, the way I tracked it down is I ditch aws library and directly started using mqtt helper library and the issue persists and to further track down the issue from where it was coming, I then used simple mqtt library, now simple mqtt library works fine the issue arrives when I try to find ip address for the broker links here the sample code. This piece of code takes the controller into MPU fault
/**@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(CONFIG_MQTT_BROKER_HOSTNAME, NULL, &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(CONFIG_MQTT_BROKER_PORT);
inet_ntop(AF_INET, &broker4->sin_addr.s_addr,
ipv4_addr, sizeof(ipv4_addr));
LOG_INF("IPv4 Address found %s", log_strdup(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;
}
Now getting back to aws library which in the backend using mqtt helper library which runs this specific code to find brokers ip address.
Here is my code
#include <zephyr/kernel.h>
#include <zephyr/sys/reboot.h>
#include <zephyr/dfu/mcuboot.h>
#include <zephyr/logging/log.h>
#include <zephyr/logging/log_ctrl.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/net/socket.h>
#include <zephyr/net/conn_mgr_connectivity.h>
#include <zephyr/net/conn_mgr_monitor.h>
#include <net/aws_iot.h>
#include <stdio.h>
#include <stdlib.h>
#include <hw_id.h>
#include "json_payload.h"
LOG_MODULE_REGISTER(app_aws);
#define CONFIG_AWS_IOT_SAMPLE_APP_VERSION "v1.0.0"
/* Application specific topics. */
#define MY_CUSTOM_TOPIC_1 "my-custom-topic/example"
#define MY_CUSTOM_TOPIC_2 "my-custom-topic/example_2"
/* Variable used to store the device's hardware ID. */
static char hw_id[HW_ID_LEN];
static bool connected;
/* Event handlers */
static void aws_iot_event_handler(const struct aws_iot_evt *const evt)
{
switch (evt->type) {
case AWS_IOT_EVT_CONNECTING:
LOG_INF("AWS_IOT_EVT_CONNECTING");
break;
case AWS_IOT_EVT_CONNECTED:
LOG_INF("AWS_IOT_EVT_CONNECTED");
//on_aws_iot_evt_connected(evt);
connected = true;
break;
case AWS_IOT_EVT_DISCONNECTED:
LOG_INF("AWS_IOT_EVT_DISCONNECTED");
//on_aws_iot_evt_disconnected();
connected = false;
break;
case AWS_IOT_EVT_DATA_RECEIVED:
LOG_INF("AWS_IOT_EVT_DATA_RECEIVED");
LOG_INF("Received message: \"%.*s\" on topic: \"%.*s\"", evt->data.msg.len,
evt->data.msg.ptr,
evt->data.msg.topic.len,
evt->data.msg.topic.str);
break;
case AWS_IOT_EVT_PUBACK:
LOG_INF("AWS_IOT_EVT_PUBACK, message ID: %d", evt->data.message_id);
break;
case AWS_IOT_EVT_PINGRESP:
LOG_INF("AWS_IOT_EVT_PINGRESP");
break;
case AWS_IOT_EVT_FOTA_START:
LOG_INF("AWS_IOT_EVT_FOTA_START");
break;
case AWS_IOT_EVT_FOTA_ERASE_PENDING:
LOG_INF("AWS_IOT_EVT_FOTA_ERASE_PENDING");
break;
case AWS_IOT_EVT_FOTA_ERASE_DONE:
LOG_INF("AWS_FOTA_EVT_ERASE_DONE");
break;
case AWS_IOT_EVT_FOTA_DONE:
LOG_INF("AWS_IOT_EVT_FOTA_DONE");
//on_aws_iot_evt_fota_done(evt);
break;
case AWS_IOT_EVT_FOTA_DL_PROGRESS:
LOG_INF("AWS_IOT_EVT_FOTA_DL_PROGRESS, (%d%%)", evt->data.fota_progress);
break;
case AWS_IOT_EVT_ERROR:
LOG_INF("AWS_IOT_EVT_ERROR, %d", evt->data.err);
//FATAL_ERROR();
break;
case AWS_IOT_EVT_FOTA_ERROR:
LOG_INF("AWS_IOT_EVT_FOTA_ERROR");
break;
default:
LOG_WRN("Unknown AWS IoT event type: %d", evt->type);
break;
}
}
static int app_topics_subscribe(void)
{
int err;
static const struct mqtt_topic topic_list[] = {
{
.topic.utf8 = MY_CUSTOM_TOPIC_1,
.topic.size = strlen(MY_CUSTOM_TOPIC_1),
.qos = MQTT_QOS_1_AT_LEAST_ONCE,
},
{
.topic.utf8 = MY_CUSTOM_TOPIC_2,
.topic.size = strlen(MY_CUSTOM_TOPIC_2),
.qos = MQTT_QOS_1_AT_LEAST_ONCE,
}
};
err = aws_iot_application_topics_set(topic_list, ARRAY_SIZE(topic_list));
if (err) {
LOG_ERR("aws_iot_application_topics_set, error: %d", err);
return err;
}
return 0;
}
static int aws_iot_client_init(void)
{
int err;
err = aws_iot_init(aws_iot_event_handler);
if (err) {
LOG_ERR("AWS IoT library could not be initialized, error: %d", err);
return err;
}
/* Add application specific non-shadow topics to the AWS IoT library.
* These topics will be subscribed to when connecting to the broker.
*/
err = app_topics_subscribe();
if (err) {
LOG_ERR("Adding application specific topics failed, error: %d", err);
return err;
}
return 0;
}
int app_aws_client_init()
{
int err;
err = aws_iot_client_init();
if (err) {
LOG_ERR("aws_iot_client_init, error: %d", err);
return err;
}
}
int app_aws_init()
{
LOG_INF("The AWS IoT sample started, version: %s", CONFIG_AWS_IOT_SAMPLE_APP_VERSION);
int err;
/* Get unique hardware ID, can be used as AWS IoT MQTT broker device/client ID. */
err = hw_id_get(hw_id, ARRAY_SIZE(hw_id));
if (err) {
LOG_ERR("Failed to retrieve hardware ID, error: %d", err);
return err;
}
LOG_INF("Hardware ID: %s", hw_id);
const struct aws_iot_config config = {
.client_id = hw_id,
};
LOG_INF("Connecting to AWS IoT");
int rc, i = 0;
while (i++ < 10 && !connected) {
err = aws_iot_connect(&config);
k_msleep(500);
if (err == -EAGAIN) {
LOG_INF("Connection attempt timed out");
k_msleep(300);
} else if (err) {
LOG_ERR("aws_iot_connect, error: %d", err);
return err;
}
}
}
Main.c
#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;
}
.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=10240 CONFIG_MAIN_STACK_SIZE=10240 #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_SOCKETS=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_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="xxx.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
And my output
now output shows that main thread failed but in my .conf file you can see I have allocated alot of space for heap and main thread as well and it still fails. I am lost at this part.
UPDATE:
I solved this issue, in .conf file I had to turn of CONFIG_NET_SOCKETS_OFFLOAD for some reason this was causing the issue and making system go into MPU fault
Now I am facing the issue that nrf9160 is not connecting to AWS IOT
