Hello,
I tried to mix AWS_FOTA sample with GPS from asset_tracker (see code first screenshoot) and I get that error (see second screenshoot). Do someone have an idea please ?
I get this error message
Hello,
I tried to mix AWS_FOTA sample with GPS from asset_tracker (see code first screenshoot) and I get that error (see second screenshoot). Do someone have an idea please ?
I get this error message
Hello,
can you please paste your entire code here using the insert code option instead of posting a screenshot of it?
Hello,
can you please paste your entire code here using the insert code option instead of posting a screenshot of it?
/*
* Copyright (c) 2019 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: LicenseRef-BSD-5-Clause-Nordic
*/
#include <zephyr.h>
#include <stdio.h>
#include <bsd.h>
#include <lte_lc.h>
#include <at_cmd.h>
#include <at_notif.h>
#include <net/mqtt.h>
#include <net/socket.h>
#include <net/bsdlib.h>
#include <net/aws_fota.h>
#include <dfu/mcuboot.h>
#include <misc/reboot.h>
#include <gps.h>
#include "gps_controller.h"
#define CONFIG_MQTT_PUB_TOPIC "Test"
#define CONFIG_GPS_CONTROL_FIX_COUNT 1
#if defined(CONFIG_USE_NRF_CLOUD)
#define NRF_CLOUD_SECURITY_TAG 16842753
#endif
#if defined(CONFIG_BSD_LIBRARY)
#include "nrf_inbuilt_key.h"
#endif
#if defined(CONFIG_PROVISION_CERTIFICATES)
#include "certificates.h"
#endif
#if !defined(CONFIG_CLOUD_CLIENT_ID)
#define IMEI_LEN 15
#define CLIENT_ID_LEN (IMEI_LEN + 4)
#else
#define CLIENT_ID_LEN (sizeof(CONFIG_CLOUD_CLIENT_ID) - 1)
#endif
static u8_t client_id_buf[CLIENT_ID_LEN+1];
/* Buffers for MQTT client. */
static u8_t rx_buffer[CONFIG_MQTT_MESSAGE_BUFFER_SIZE];
static u8_t tx_buffer[CONFIG_MQTT_MESSAGE_BUFFER_SIZE];
static u8_t payload_buf[CONFIG_MQTT_PAYLOAD_BUFFER_SIZE];
/* MQTT Broker details. */
static struct sockaddr_storage broker_storage;
/* File descriptor */
static struct pollfd fds;
/* Set to true when application should teardown and reboot */
static bool do_reboot;
#if defined(CONFIG_BSD_LIBRARY)
/**@brief Recoverable BSD library error. */
void bsd_recoverable_error_handler(uint32_t err)
{
printk("bsdlib recoverable error: %u\n", err);
}
#endif /* defined(CONFIG_BSD_LIBRARY) */
/* Topic for updating shadow topic with version number */
#define AWS "$aws/things/"
#define UPDATE_DELTA_TOPIC AWS "%s/shadow/update"
#define SHADOW_STATE_UPDATE \
"{\"state\":{\"reported\":{\"nrfcloud__dfu_v1__app_v\":\"%s\"}}}"
static int update_device_shadow_version(struct mqtt_client *const client)
{
struct mqtt_publish_param param;
char update_delta_topic[strlen(AWS) + strlen("/shadow/update") +
CLIENT_ID_LEN];
u8_t shadow_update_payload[CONFIG_DEVICE_SHADOW_PAYLOAD_SIZE];
int ret = snprintf(update_delta_topic,
sizeof(update_delta_topic),
UPDATE_DELTA_TOPIC,
client->client_id.utf8);
u32_t update_delta_topic_len = ret;
if (ret >= sizeof(update_delta_topic)) {
return -ENOMEM;
} else if (ret < 0) {
return ret;
}
ret = snprintf(shadow_update_payload,
sizeof(shadow_update_payload),
SHADOW_STATE_UPDATE,
CONFIG_APP_VERSION);
u32_t shadow_update_payload_len = ret;
if (ret >= sizeof(shadow_update_payload)) {
return -ENOMEM;
} else if (ret < 0) {
return ret;
}
param.message.topic.qos = MQTT_QOS_1_AT_LEAST_ONCE;
param.message.topic.topic.utf8 = update_delta_topic;
param.message.topic.topic.size = update_delta_topic_len;
param.message.payload.data = shadow_update_payload;
param.message.payload.len = shadow_update_payload_len;
param.message_id = sys_rand32_get();
param.dup_flag = 0;
param.retain_flag = 0;
return mqtt_publish(client, ¶m);
}
/**@brief Function to print strings without null-termination. */
static void data_print(u8_t *prefix, u8_t *data, size_t len)
{
char buf[len + 1];
memcpy(buf, data, len);
buf[len] = 0;
printk("%s%s\n", prefix, buf);
}
/**@brief Function to read the published payload.
*/
static int publish_get_payload(struct mqtt_client *c,
u8_t *write_buf,
size_t length)
{
u8_t *buf = write_buf;
u8_t *end = buf + length;
if (length > sizeof(payload_buf)) {
return -EMSGSIZE;
}
while (buf < end) {
int ret = mqtt_read_publish_payload_blocking(c, buf, end - buf);
if (ret < 0) {
return ret;
} else if (ret == 0) {
return -EIO;
}
buf += ret;
}
return 0;
}
static int data_publish(struct mqtt_client *c, enum mqtt_qos qos,
u8_t *data, size_t len)
{
struct mqtt_publish_param param;
param.message.topic.qos = qos;
param.message.topic.topic.utf8 = CONFIG_MQTT_PUB_TOPIC;
param.message.topic.topic.size = strlen(CONFIG_MQTT_PUB_TOPIC);
param.message.payload.data = data;
param.message.payload.len = len;
param.message_id = sys_rand32_get();
param.dup_flag = 0;
param.retain_flag = 0;
data_print("Publishing: ", data, len);
printk("to topic: %s len: %u\n",
CONFIG_MQTT_PUB_TOPIC,
(unsigned int)strlen(CONFIG_MQTT_PUB_TOPIC));
return mqtt_publish(c, ¶m);
}
/**@brief MQTT client event handler */
void mqtt_evt_handler(struct mqtt_client * const c,
const struct mqtt_evt *evt)
{
int err;
err = aws_fota_mqtt_evt_handler(c, evt);
if (err > 0) {
/* Event handled by FOTA library so we can skip it */
return;
} else if (err < 0) {
printk("aws_fota_mqtt_evt_handler: Failed! %d\n", err);
}
switch (evt->type) {
case MQTT_EVT_CONNACK:
if (evt->result != 0) {
printk("MQTT connect failed %d\n", evt->result);
break;
}
printk("[%s:%d] MQTT client connected!\n", __func__, __LINE__);
#if !defined(CONFIG_USE_NRF_CLOUD)
err = update_device_shadow_version(c);
if (err) {
printk("Unable to update device shadow err: %d\n", err);
}
#endif
break;
case MQTT_EVT_DISCONNECT:
printk("[%s:%d] MQTT client disconnected %d\n", __func__,
__LINE__, evt->result);
break;
case MQTT_EVT_PUBLISH: {
const struct mqtt_publish_param *p = &evt->param.publish;
printk("[%s:%d] MQTT PUBLISH result=%d len=%d\n", __func__,
__LINE__, evt->result, p->message.payload.len);
err = publish_get_payload(c,
payload_buf,
p->message.payload.len);
if (err) {
printk("mqtt_read_publish_payload: Failed! %d\n", err);
printk("Disconnecting MQTT client...\n");
err = mqtt_disconnect(c);
if (err) {
printk("Could not disconnect: %d\n", err);
}
}
if (p->message.topic.qos == MQTT_QOS_1_AT_LEAST_ONCE) {
const struct mqtt_puback_param ack = {
.message_id = p->message_id
};
/* Send acknowledgment. */
err = mqtt_publish_qos1_ack(c, &ack);
if (err) {
printk("unable to ack\n");
}
}
data_print("Received: ", payload_buf, p->message.payload.len);
break;
}
case MQTT_EVT_PUBACK:
if (evt->result != 0) {
printk("MQTT PUBACK error %d\n", evt->result);
break;
}
printk("[%s:%d] PUBACK packet id: %u\n", __func__, __LINE__,
evt->param.puback.message_id);
break;
case MQTT_EVT_SUBACK:
if (evt->result != 0) {
printk("MQTT SUBACK error %d\n", evt->result);
break;
}
printk("[%s:%d] SUBACK packet id: %u\n", __func__, __LINE__,
evt->param.suback.message_id);
char * test = "test";
err = data_publish(c, MQTT_QOS_1_AT_LEAST_ONCE,
test, strlen(test));
if (err) {
printk("data_publish failed\n");
}
break;
default:
printk("[%s:%d] default: %d\n", __func__, __LINE__,
evt->type);
break;
}
}
/**@brief Resolves the configured hostname and
* initializes the MQTT broker structure
*/
static void broker_init(const char *hostname)
{
int err;
struct addrinfo *result;
struct addrinfo *addr;
struct addrinfo hints = {
.ai_family = AF_INET,
.ai_socktype = SOCK_STREAM
};
err = getaddrinfo(hostname, NULL, &hints, &result);
if (err) {
printk("ERROR: getaddrinfo failed %d\n", err);
return;
}
addr = result;
err = -ENOENT;
while (addr != NULL) {
/* IPv4 Address. */
if (addr->ai_addrlen == sizeof(struct sockaddr_in)) {
struct sockaddr_in *broker =
((struct sockaddr_in *)&broker_storage);
broker->sin_addr.s_addr =
((struct sockaddr_in *)addr->ai_addr)
->sin_addr.s_addr;
broker->sin_family = AF_INET;
broker->sin_port = htons(CONFIG_MQTT_BROKER_PORT);
printk("IPv4 Address 0x%08x\n",
broker->sin_addr.s_addr);
break;
} else if (addr->ai_addrlen == sizeof(struct sockaddr_in6)) {
/* IPv6 Address. */
struct sockaddr_in6 *broker =
((struct sockaddr_in6 *)&broker_storage);
memcpy(broker->sin6_addr.s6_addr,
((struct sockaddr_in6 *)addr->ai_addr)
->sin6_addr.s6_addr,
sizeof(struct in6_addr));
broker->sin6_family = AF_INET6;
broker->sin6_port = htons(CONFIG_MQTT_BROKER_PORT);
printk("IPv6 Address");
break;
} else {
printk("error: ai_addrlen = %u should be %u or %u\n",
(unsigned int)addr->ai_addrlen,
(unsigned int)sizeof(struct sockaddr_in),
(unsigned int)sizeof(struct sockaddr_in6));
}
addr = addr->ai_next;
break;
}
/* Free the address. */
freeaddrinfo(result);
}
#if defined(CONFIG_PROVISION_CERTIFICATES)
#warning Not for prodcution use. This should only be used once to provisioning the certificates please deselect the provision certificates configuration and compile again.
#define MAX_OF_2 MAX(sizeof(CLOUD_CA_CERTIFICATE),\
sizeof(CLOUD_CLIENT_PRIVATE_KEY))
#define MAX_LEN MAX(MAX_OF_2, sizeof(CLOUD_CLIENT_PUBLIC_CERTIFICATE))
static u8_t certificates[][MAX_LEN] = {{CLOUD_CA_CERTIFICATE},
{CLOUD_CLIENT_PRIVATE_KEY},
{CLOUD_CLIENT_PUBLIC_CERTIFICATE} };
static const size_t cert_len[] = {
sizeof(CLOUD_CA_CERTIFICATE) - 1, sizeof(CLOUD_CLIENT_PRIVATE_KEY) - 1,
sizeof(CLOUD_CLIENT_PUBLIC_CERTIFICATE) - 1
};
static int provision_certificates(void)
{
int err;
printk("************************* WARNING *************************\n");
printk("%s called do not use this in production!\n", __func__);
printk("This will store the certificates in readable flash and leave\n");
printk("them exposed on modem_traces. Only use this once for\n");
printk("provisioning certificates for development to reduce flash tear."
"\n");
printk("************************* WARNING *************************\n");
nrf_sec_tag_t sec_tag = CONFIG_CLOUD_CERT_SEC_TAG;
nrf_key_mgnt_cred_type_t cred[] = {
NRF_KEY_MGMT_CRED_TYPE_CA_CHAIN,
NRF_KEY_MGMT_CRED_TYPE_PRIVATE_CERT,
NRF_KEY_MGMT_CRED_TYPE_PUBLIC_CERT,
};
/* Delete certificates */
for (nrf_key_mgnt_cred_type_t type = 0; type < 3; type++) {
err = nrf_inbuilt_key_delete(sec_tag, type);
printk("nrf_inbuilt_key_delete(%u, %d) => result=%d\n",
sec_tag, type, err);
}
/* Write certificates */
for (nrf_key_mgnt_cred_type_t type = 0; type < 3; type++) {
err = nrf_inbuilt_key_write(sec_tag, cred[type],
certificates[type], cert_len[type]);
printk("nrf_inbuilt_key_write => result=%d\n", err);
}
return 0;
}
#endif
static int client_id_get(char *id_buf)
{
#if !defined(CONFIG_CLOUD_CLIENT_ID)
enum at_cmd_state at_state;
char imei_buf[IMEI_LEN + 5];
int err = at_cmd_write("AT+CGSN", imei_buf, (IMEI_LEN + 5), &at_state);
if (err) {
printk("Error when trying to do at_cmd_write: %d, at_state: %d",
err, at_state);
}
snprintf(id_buf, CLIENT_ID_LEN + 1, "nrf-%s", imei_buf);
#else
memcpy(id_buf, CONFIG_CLOUD_CLIENT_ID, CLIENT_ID_LEN + 1);
#endif /* !defined(NRF_CLOUD_CLIENT_ID) */
return 0;
}
/**@brief Initialize the MQTT client structure */
static int client_init(struct mqtt_client *client, char *hostname)
{
mqtt_client_init(client);
broker_init(hostname);
int ret = client_id_get(client_id_buf);
printk("client_id: %s\n", client_id_buf);
if (ret != 0) {
return ret;
}
/* MQTT client configuration */
client->broker = &broker_storage;
client->evt_cb = mqtt_evt_handler;
client->client_id.utf8 = client_id_buf;
client->client_id.size = strlen(client_id_buf);
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);
/* MQTT transport configuration */
client->transport.type = MQTT_TRANSPORT_SECURE;
static sec_tag_t sec_tag_list[] = {
#ifdef CONFIG_USE_NRF_CLOUD
NRF_CLOUD_SECURITY_TAG
#else
CONFIG_CLOUD_CERT_SEC_TAG
#endif
};
struct mqtt_sec_config *tls_config = &(client->transport).tls.config;
tls_config->peer_verify = 2;
tls_config->cipher_list = NULL;
tls_config->cipher_count = 0;
tls_config->sec_tag_count = ARRAY_SIZE(sec_tag_list);
tls_config->sec_tag_list = sec_tag_list;
tls_config->hostname = hostname;
return 0;
}
/**@brief Initialize the file descriptor structure used by poll. */
static int fds_init(struct mqtt_client *c)
{
fds.fd = c->transport.tls.sock;
fds.events = POLLIN;
return 0;
}
/**@brief Configures modem to provide LTE link.
*
* Blocks until link is successfully established.
*/
static void modem_configure(void)
{
#if defined(CONFIG_LTE_LINK_CONTROL)
BUILD_ASSERT_MSG(!IS_ENABLED(CONFIG_LTE_AUTO_INIT_AND_CONNECT),
"This sample does not support auto init and connect");
int err;
err = at_notif_init();
__ASSERT(err == 0, "AT Notify could not be initialized.");
err = at_cmd_init();
__ASSERT(err == 0, "AT CMD could not be established.");
printk("LTE Link Connecting ...\n");
err = lte_lc_init_and_connect();
__ASSERT(err == 0, "LTE link could not be established.");
printk("LTE Link Connected!\n");
#endif
}
static void aws_fota_cb_handler(enum aws_fota_evt_id evt)
{
switch (evt) {
case AWS_FOTA_EVT_DONE:
printk("AWS_FOTA_EVT_DONE, rebooting to apply update.\n");
do_reboot = true;
break;
case AWS_FOTA_EVT_ERROR:
printk("AWS_FOTA_EVT_ERROR\n");
break;
}
}
// GPS ---------------------------------------
static struct gps_data gps_data;
static char nmea_frame[256] = "";
unsigned char gps_running = 1;
static void gps_trigger_handler(struct device *dev, struct gps_trigger *trigger)
{
static u32_t fix_count = 0;
ARG_UNUSED(trigger);
if (++fix_count < CONFIG_GPS_CONTROL_FIX_COUNT) {
return;
}
fix_count = 0;
gps_sample_fetch(dev);
gps_channel_get(dev, GPS_CHAN_NMEA, &gps_data);
snprintf(nmea_frame, sizeof(nmea_frame), "%s", gps_data.nmea.buf);
gps_control_stop(K_NO_WAIT);
gps_running = 0;
}
void main(void)
{
nrf_gnss_data_frame_t gps_data;
u8_t cnt = 0;
int err;
/* The mqtt client struct */
struct mqtt_client client;
printk("MQTT AWS Jobs FOTA Sample, version: %s\n", CONFIG_APP_VERSION);
printk("Initializing bsdlib\n");
err = bsdlib_init();
switch (err) {
case MODEM_DFU_RESULT_OK:
printk("Modem firmware update successful!\n");
printk("Modem will run the new firmware after reboot\n");
//k_thread_suspend(k_current_get());
sys_reboot(SYS_REBOOT_COLD);
break;
case MODEM_DFU_RESULT_UUID_ERROR:
case MODEM_DFU_RESULT_AUTH_ERROR:
printk("Modem firmware update failed\n");
printk("Modem will run non-updated firmware on reboot.\n");
sys_reboot(SYS_REBOOT_COLD);
break;
case MODEM_DFU_RESULT_HARDWARE_ERROR:
case MODEM_DFU_RESULT_INTERNAL_ERROR:
printk("Modem firmware update failed\n");
printk("Fatal error.\n");
sys_reboot(SYS_REBOOT_COLD);
break;
case -1:
printk("Could not initialize bsdlib.\n");
printk("Fatal error.\n");
sys_reboot(SYS_REBOOT_COLD);
return;
default:
break;
}
printk("Initialized bsdlib\n");
#if defined(CONFIG_PROVISION_CERTIFICATES)
provision_certificates();
#endif /* CONFIG_PROVISION_CERTIFICATES */
modem_configure();
client_init(&client, CONFIG_MQTT_BROKER_HOSTNAME);
err = aws_fota_init(&client, CONFIG_APP_VERSION, aws_fota_cb_handler);
if (err != 0) {
printk("ERROR: aws_fota_init %d\n", err);
return;
}
err = mqtt_connect(&client);
if (err != 0) {
printk("ERROR: mqtt_connect %d\n", err);
return;
}
err = fds_init(&client);
if (err != 0) {
printk("ERROR: fds_init %d\n", err);
return;
}
/* All initializations were successful mark image as working so that we
* will not revert upon reboot.
*/
boot_write_img_confirmed();
gps_control_init(gps_trigger_handler);
while (1) {
if (gps_running == 0)
{
err = poll(&fds, 1, K_MSEC(500)/*K_SECONDS(CONFIG_MQTT_KEEPALIVE)*/);
if (err < 0) {
printk("ERROR: poll %d\n", errno);
break;
}
err = mqtt_live(&client);
if (err != 0) {
printk("ERROR: mqtt_live %d\n", err);
break;
}
if ((fds.revents & POLLIN) == POLLIN) {
err = mqtt_input(&client);
if (err != 0) {
printk("ERROR: mqtt_input %d\n", err);
break;
}
}
if ((fds.revents & POLLERR) == POLLERR) {
printk("POLLERR\n");
break;
}
if ((fds.revents & POLLNVAL) == POLLNVAL) {
printk("POLLNVAL\n");
break;
}
gps_control_start(K_SECONDS(1));
gps_running = 1;
}
else
{
k_sleep(K_MSEC(500));
}
if (do_reboot) {
/* Teardown */
mqtt_disconnect(&client);
sys_reboot(0);
}
}
printk("Disconnecting MQTT client...\n");
err = mqtt_disconnect(&client);
if (err) {
printk("Could not disconnect MQTT client. Error: %d\n", err);
}
}
LTE connection and GPS can't be run simultaneously, unless PSM has also been set. This example shows how to run both LTE and GPS concurrently.