AWS IoT how change the messagge type 1?

RE: AWS IoT how change the messagge type 1?

tracking — Wed, 26 May 2021 20:40:47 GMT

Hi Heidi!

Ok, no problem, thanks for your help!

Best regards,

Julio

RE: AWS IoT how change the messagge type 1?

Heidi — Wed, 26 May 2021 11:20:11 GMT

Hi! I see.

This is a bit out of my expertise and also very unrelated to your original inquiry. Could you please make a new ticket about this and you will be assigned an engineer who can answer it.

Best regards,

Heidi

RE: AWS IoT how change the messagge type 1?

tracking — Thu, 20 May 2021 21:03:19 GMT

Hi Heidi!

I proved the AT%XMONITOR with my code and show me this values:

I understand that

active time: "00000010" means four seconds to pass of connected mode to idle mode

periodic tau ext: "00011111" means 10 minutes x 31 = 310 minutes, I don´t understand with accuracy what controls this time

periodic tau: "01011111" means 10 hours x 31 = 310 hours, this time is the time between ubication updates of modem, but this update is't a message to cloud it is only to network knows the modem location

RE: AWS IoT how change the messagge type 1?

Heidi — Thu, 13 May 2021 19:38:39 GMT

[quote user="tracking"]which function have each of them?[/quote]

The active timer determines the duration during which the device remains reachable for mobile terminated transactions on the transition from connected to idle mode.

The periodic TAU timer determines how often the device will send a periodic tracking update to the network

The extended periodic TAU timer just allows for a longer periodic TAU timer.

[quote user="tracking"]can I control them?[/quote]

You can request values from the network using +CPSMS but the network can give you different values than what you requested.

[quote user="tracking"]there are any relation whit these values?[/quote]

Yes, LTE_PSM_REQ_RPTAU is the requested periodic TAU and LTE_PSM_REQ_RAT is the requested active time.

[quote user="tracking"]other question, in aws_iot sample I modified the time between publications to 300 (kconfig file), but the modem stil change connect and idle mode each 60 seconds, what more must I change to give more time to gps?[/quote]

60 seconds? From the %XMONITOR results, it says the periodic TAU is 36 minutes? Did you change these configurations?

You will need to change the PSM configurations to give more time to the GPS.

RE: AWS IoT how change the messagge type 1?

tracking — Mon, 10 May 2021 00:55:39 GMT

Hi!

I read this documentation, but I stil without undertand these times:

[quote userid="82276" url="~/f/nordic-q-a/73312/aws-iot-how-change-the-messagge-type-1/307956#307956"]

Active-Time: 11100000 - deactivated

Periodic-TAU-ext: 11100000 - deactivated

Periodic-TAU: 01001001 - 36 minutes

[/quote]

which function have each of them?

can I control them?

there are any relation whit these values? (autoconf.h agps sample)

other question, in aws_iot sample I modified the time between publications to 300 (kconfig file), but the modem stil change connect and idle mode each 60 seconds, what more must I change to give more time to gps?

thanks in advance

RE: AWS IoT how change the messagge type 1?

Heidi — Mon, 03 May 2021 13:32:37 GMT

Hi!

So, you can find the documentation for the %XMONITOR AT Command here. From your result, we see

Active-Time: 11100000 - deactivated

Periodic-TAU-ext: 11100000 - deactivated

Periodic-TAU: 01001001 - 36 minutes

[quote user="tracking"]which one is the modification? I had undertood that with this line (L348) the modem change to psm o mode idle when the pakage was transmitted and in this condition the gps can work.[/quote]

Yes, L348 is the modification you need to add to the modem_configure() function in the AWS IoT sample to request PSM. And preferably the following four lines to catch any errors.

[quote user="tracking"]yes, I include gps driver, but I don't know what cosiderations I must have with Cmakelists, Kconfig, prj.conf and other files [/quote]

Then you go into these files in the AGPS sample and you see if there are any GPS-related considerations that you should include in your sample. prj.conf L52 adds CONFIG_NRF9160_GPS=y to enable the GPS driver so you should include this as well.

RE: AWS IoT how change the messagge type 1?

tracking — Fri, 30 Apr 2021 15:35:14 GMT

thanks for that, but I don't find how interprete the result

[quote userid="82276" url="~/f/nordic-q-a/73312/aws-iot-how-change-the-messagge-type-1/307545#307545"]You can use AT%XMONITOR to read the Active Time and Periodic TAU set by the network.[/quote]

[quote userid="82276" url="~/f/nordic-q-a/73312/aws-iot-how-change-the-messagge-type-1/307545#307545"]Yes, you can use the modem_configure() in the AWS IoT sample, but you need to modify it to request PSM (L348).[/quote]

which one is the modification? I had undertood that with this line (L348) the modem change to psm o mode idle when the pakage was transmitted and in this condition the gps can work.

[quote userid="82276" url="~/f/nordic-q-a/73312/aws-iot-how-change-the-messagge-type-1/307545#307545"]Did you include the GPS driver (L13)?[/quote]

yes, I include gps driver, but I don't know what cosiderations I must have with Cmakelists, Kconfig, prj.conf and other files

[quote userid="82276" url="~/f/nordic-q-a/73312/aws-iot-how-change-the-messagge-type-1/307545#307545"]Can I see your main.c file?[/quote]

yes, of course

/*
 * Copyright (c) 2020 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-BSD-5-Clause-Nordic
 */

#include <zephyr.h>
#include <stdio.h>
#include <stdlib.h>
#if defined(CONFIG_BSD_LIB)
#include <modem/lte_lc.h>
#include <modem/bsdlib.h>
#include <modem/at_cmd.h>
#include <modem/at_notif.h>
#include <modem/modem_info.h>
#include <bsd.h>
#endif
#include <net/aws_iot.h>
#include <power/reboot.h>
#include <date_time.h>
#include <dfu/mcuboot.h>
#include <cJSON.h>
#include <cJSON_os.h>
#include <drivers/gps.h>//corresponds to gps 
//#include <logging/log.h>//corresponds to gps

BUILD_ASSERT(!IS_ENABLED(CONFIG_LTE_AUTO_INIT_AND_CONNECT),
		"This sample does not support LTE auto-init and connect");

#define APP_TOPICS_COUNT CONFIG_AWS_IOT_APP_SUBSCRIPTION_LIST_COUNT

/* Timeout in seconds in which the application will wait for an initial event
 * from the date time library.
 */
#define DATE_TIME_TIMEOUT_S 15

static struct k_delayed_work shadow_update_work;
static struct k_delayed_work connect_work;
static struct k_delayed_work shadow_update_version_work;
static struct k_delayed_work gps_start_work;//corresponds to gps
static struct k_delayed_work reboot_work;//corresponds to gps
static const struct device *gps_dev;//corresponds to gps

K_SEM_DEFINE(lte_connected, 0, 1);
K_SEM_DEFINE(date_time_obtained, 0, 1);

//**************** INICIO FUNCIONES DE GPS ***********************
static void gps_start_work_fn(struct k_work *work)
{
	int err;
	struct gps_config gps_cfg = {
		.nav_mode = GPS_NAV_MODE_PERIODIC,
		.power_mode = GPS_POWER_MODE_DISABLED,
		.timeout = 120,
		.interval = 240,
		.priority = true,
	};

	ARG_UNUSED(work);//#define ARG_UNUSED(x) (void)(x) in gcc.h seems is to avoid warning when  
                          //argument is void que no tire warning si el argumento work no está

	err = gps_start(gps_dev, &gps_cfg);//loads api on device and initialize wiht gps_cfg configuration 
	if (err) {
		//LOG_ERR("Failed to start GPS, error: %d", err);//error in __log_level I don't know why
                printk("Failed to start GPS, error: %d", err);
		return;
	}

	//LOG_INF("Periodic GPS search started with interval %d s, timeout %d s",  
	//	gps_cfg.interval, gps_cfg.timeout);
        printk("Periodic GPS search started with interval %d s, timeout %d s",  
		gps_cfg.interval, gps_cfg.timeout);
}
static void reboot_work_fn(struct k_work *work)
{
	//LOG_WRN("Rebooting in 2 seconds...");
        printk("Rebooting in 2 seconds...");
	k_sleep(K_SECONDS(2));
	sys_reboot(0);
}
static void print_pvt_data(struct gps_pvt *pvt_data)
{
	char buf[300];
	size_t len;

	len = snprintf(buf, sizeof(buf),
		      "\r\n\tLongitude:  %f\r\n\t"
		      "Latitude:   %f\r\n\t"
		      "Altitude:   %f\r\n\t"
		      "Speed:      %f\r\n\t"
		      "Heading:    %f\r\n\t"
		      "Date:       %02u-%02u-%02u\r\n\t"
		      "Time (UTC): %02u:%02u:%02u\r\n",
		      pvt_data->longitude, pvt_data->latitude,
		      pvt_data->altitude, pvt_data->speed, pvt_data->heading,
		      pvt_data->datetime.day, pvt_data->datetime.month,
		      pvt_data->datetime.year, pvt_data->datetime.hour,
		      pvt_data->datetime.minute, pvt_data->datetime.seconds);
	if (len < 0) {
		printk("Could not construct PVT print");
	} else {
		//printk("%s", log_strdup(buf));//I don't copy this function, I think is not important now
	}
}
static uint64_t start_search_timestamp;
static uint64_t fix_timestamp;
static void gps_handler(const struct device *dev, struct gps_event *evt)
{
	ARG_UNUSED(dev);

	switch (evt->type) {
	case GPS_EVT_SEARCH_STARTED:
		//LOG_INF("GPS_EVT_SEARCH_STARTED");
                printk("GPS_EVT_SEARCH_STARTED");
		start_search_timestamp = k_uptime_get();
		break;
	case GPS_EVT_SEARCH_STOPPED:
		//LOG_INF("GPS_EVT_SEARCH_STOPPED");
                printk("GPS_EVT_SEARCH_STOPPED");
		break;
	case GPS_EVT_SEARCH_TIMEOUT:
		//LOG_INF("GPS_EVT_SEARCH_TIMEOUT");
                printk("GPS_EVT_SEARCH_TIMEOUT");
		break;
	case GPS_EVT_OPERATION_BLOCKED:
		//LOG_INF("GPS_EVT_OPERATION_BLOCKED");
                printk("GPS_EVT_OPERATION_BLOCKED");
		break;
	case GPS_EVT_OPERATION_UNBLOCKED:
		//LOG_INF("GPS_EVT_OPERATION_UNBLOCKED");
                printk("GPS_EVT_OPERATION_UNBLOCKED");
		break;
	//case GPS_EVT_AGPS_DATA_NEEDED://this case is not used because do the conection but with nrfcloud
	//	//LOG_INF("GPS_EVT_AGPS_DATA_NEEDED");
        //          printk("GPS_EVT_AGPS_DATA_NEEDED");
	//	on_agps_needed(evt->agps_request);
	//	break;
	//case GPS_EVT_PVT://print status satelite, now I think is not important, I will add when gps initiates correctly 
	//	print_satellite_stats(&evt->pvt);
	//	break;
	case GPS_EVT_PVT_FIX:
		fix_timestamp = k_uptime_get();

		printk("---------       FIX       ---------");
		printk("Time to fix: %d seconds",
			(uint32_t)(fix_timestamp - start_search_timestamp) / 1000);
		print_pvt_data(&evt->pvt);
		printk("-----------------------------------");
		break;
	//case GPS_EVT_NMEA_FIX://this case create and send the messagge but to nrfcloud
	//	send_nmea(evt->nmea.buf);
	//	break;
	default:
		break;
	}
}

//**************** FIN FUNCIONES DE GPS ***********************
static int json_add_obj(cJSON *parent, const char *str, cJSON *item)
{
	cJSON_AddItemToObject(parent, str, item);

	return 0;
}

static int json_add_str(cJSON *parent, const char *str, const char *item)
{
	cJSON *json_str;

	json_str = cJSON_CreateString(item);
	if (json_str == NULL) {
		return -ENOMEM;
	}

	return json_add_obj(parent, str, json_str);
}

static int json_add_number(cJSON *parent, const char *str, double item)
{
	cJSON *json_num;

	json_num = cJSON_CreateNumber(item);
	if (json_num == NULL) {
		return -ENOMEM;
	}

	return json_add_obj(parent, str, json_num);
}

static int shadow_update(bool version_number_include)
{
	int err;
	char *message;
	int64_t message_ts;
	int16_t bat_voltage = 0;

	err = date_time_now(&message_ts);
	if (err) {
		printk("date_time_now, error: %d\n", err);
		return err;
	}

#if defined(CONFIG_BSD_LIBRARY)
	/* Request battery voltage data from the modem. */
	err = modem_info_short_get(MODEM_INFO_BATTERY, &bat_voltage);
	if (err != sizeof(bat_voltage)) {
		printk("modem_info_short_get, error: %d\n", err);
		return err;
	}
#endif

	cJSON *root_obj = cJSON_CreateObject();
	cJSON *state_obj = cJSON_CreateObject();
	cJSON *reported_obj = cJSON_CreateObject();

	if (root_obj == NULL || state_obj == NULL || reported_obj == NULL) {
		cJSON_Delete(root_obj);
		cJSON_Delete(state_obj);
		cJSON_Delete(reported_obj);
		err = -ENOMEM;
		return err;
	}

	if (version_number_include) {
		err = json_add_str(reported_obj, "app_version",
				    CONFIG_APP_VERSION);
	} else {
		err = 0;
	}

	err += json_add_number(reported_obj, "batv", bat_voltage);
	err += json_add_number(reported_obj, "ts", message_ts);
	err += json_add_obj(state_obj, "reported", reported_obj);
	err += json_add_obj(root_obj, "state", state_obj);

	if (err) {
		printk("json_add, error: %d\n", err);
		goto cleanup;
	}

	message = cJSON_Print(root_obj);
	if (message == NULL) {
		printk("cJSON_Print, error: returned NULL\n");
		err = -ENOMEM;
		goto cleanup;
	}

	struct aws_iot_data tx_data = {
		.qos = MQTT_QOS_0_AT_MOST_ONCE,
		.topic.type = AWS_IOT_SHADOW_TOPIC_UPDATE,
		.ptr = message,
		.len = strlen(message)
	};

	printk("Publishing: %s to AWS IoT broker\n", message);

	err = aws_iot_send(&tx_data);
	if (err) {
		printk("aws_iot_send, error: %d\n", err);
	}

	cJSON_FreeString(message);

cleanup:

	cJSON_Delete(root_obj);

	return err;
}

static void connect_work_fn(struct k_work *work)
{
	int err;

	err = aws_iot_connect(NULL);
	if (err) {
		printk("aws_iot_connect, error: %d\n", err);
	}

	printk("Next connection retry in %d seconds\n",
	       CONFIG_CONNECTION_RETRY_TIMEOUT_SECONDS);

	k_delayed_work_submit(&connect_work,
			K_SECONDS(CONFIG_CONNECTION_RETRY_TIMEOUT_SECONDS));
}

static void shadow_update_work_fn(struct k_work *work)
{
	int err;

	err = shadow_update(false);
	if (err) {
		printk("shadow_update, error: %d\n", err);
	}

	printk("Next data publication in %d seconds\n",
	       CONFIG_PUBLICATION_INTERVAL_SECONDS);

	k_delayed_work_submit(&shadow_update_work,
			      K_SECONDS(CONFIG_PUBLICATION_INTERVAL_SECONDS));
}

static void shadow_update_version_work_fn(struct k_work *work)
{
	int err;

	err = shadow_update(true);
	if (err) {
		printk("shadow_update, error: %d\n", err);
	}
}

static void print_received_data(const char *buf, const char *topic,
				size_t topic_len)
{
	char *str = NULL;
	cJSON *root_obj = NULL;

	root_obj = cJSON_Parse(buf);
	if (root_obj == NULL) {
		printk("cJSON Parse failure");
		return;
	}

	str = cJSON_Print(root_obj);
	if (str == NULL) {
		printk("Failed to print JSON object");
		goto clean_exit;
	}

	printf("Data received from AWS IoT console:\nTopic: %.*s\nMessage: %s\n",
	       topic_len, topic, str);

	cJSON_FreeString(str);

clean_exit:
	cJSON_Delete(root_obj);
}

void aws_iot_event_handler(const struct aws_iot_evt *const evt)
{
	switch (evt->type) {
	case AWS_IOT_EVT_CONNECTING:
		printk("AWS_IOT_EVT_CONNECTING\n");
		break;
	case AWS_IOT_EVT_CONNECTED:
		printk("AWS_IOT_EVT_CONNECTED\n");

		k_delayed_work_cancel(&connect_work);

		if (evt->data.persistent_session) {
			printk("Persistent session enabled\n");
		}

#if defined(CONFIG_BSD_LIBRARY)
		/** Successfully connected to AWS IoT broker, mark image as
		 *  working to avoid reverting to the former image upon reboot.
		 */
		boot_write_img_confirmed();
#endif

		/** Send version number to AWS IoT broker to verify that the
		 *  FOTA update worked.
		 */
		k_delayed_work_submit(&shadow_update_version_work, K_NO_WAIT);

		/** Start sequential shadow data updates.
		 */
		k_delayed_work_submit(&shadow_update_work,
				K_SECONDS(CONFIG_PUBLICATION_INTERVAL_SECONDS));

#if defined(CONFIG_BSD_LIBRARY)
		int err = lte_lc_psm_req(true);
		if (err) {
			printk("Requesting PSM failed, error: %d\n", err);
		}
#endif
		break;
	case AWS_IOT_EVT_READY:
		printk("AWS_IOT_EVT_READY\n");
		break;
	case AWS_IOT_EVT_DISCONNECTED:
		printk("AWS_IOT_EVT_DISCONNECTED\n");
		k_delayed_work_cancel(&shadow_update_work);

		if (k_delayed_work_pending(&connect_work)) {
			break;
		}

		k_delayed_work_submit(&connect_work, K_NO_WAIT);
		break;
	case AWS_IOT_EVT_DATA_RECEIVED:
		printk("AWS_IOT_EVT_DATA_RECEIVED\n");
		print_received_data(evt->data.msg.ptr, evt->data.msg.topic.str,
				    evt->data.msg.topic.len);
		break;
	case AWS_IOT_EVT_FOTA_START:
		printk("AWS_IOT_EVT_FOTA_START\n");
		break;
	case AWS_IOT_EVT_FOTA_ERASE_PENDING:
		printk("AWS_IOT_EVT_FOTA_ERASE_PENDING\n");
		printk("Disconnect LTE link or reboot\n");
#if defined(CONFIG_BSD_LIBRARY)
		err = lte_lc_offline();
		if (err) {
			printk("Error disconnecting from LTE\n");
		}
#endif
		break;
	case AWS_IOT_EVT_FOTA_ERASE_DONE:
		printk("AWS_FOTA_EVT_ERASE_DONE\n");
		printk("Reconnecting the LTE link");
#if defined(CONFIG_BSD_LIBRARY)
		err = lte_lc_connect();
		if (err) {
			printk("Error connecting to LTE\n");
		}
#endif
		break;
	case AWS_IOT_EVT_FOTA_DONE:
		printk("AWS_IOT_EVT_FOTA_DONE\n");
		printk("FOTA done, rebooting device\n");
		aws_iot_disconnect();
		sys_reboot(0);
		break;
	case AWS_IOT_EVT_FOTA_DL_PROGRESS:
		printk("AWS_IOT_EVT_FOTA_DL_PROGRESS, (%d%%)",
		       evt->data.fota_progress);
	case AWS_IOT_EVT_ERROR:
		printk("AWS_IOT_EVT_ERROR, %d\n", evt->data.err);
		break;
	default:
		printk("Unknown AWS IoT event type: %d\n", evt->type);
		break;
	}
}

static void work_init(void)
{
	k_delayed_work_init(&shadow_update_work, shadow_update_work_fn);
	k_delayed_work_init(&connect_work, connect_work_fn);
	k_delayed_work_init(&shadow_update_version_work,
			    shadow_update_version_work_fn);
        //add threads correponding to gps control 
	k_delayed_work_init(&gps_start_work, gps_start_work_fn);
	k_delayed_work_init(&reboot_work, reboot_work_fn);
}

#if defined(CONFIG_BSD_LIBRARY)
static void lte_handler(const struct lte_lc_evt *const evt)
{
	switch (evt->type) {
	case LTE_LC_EVT_NW_REG_STATUS:
		if ((evt->nw_reg_status != LTE_LC_NW_REG_REGISTERED_HOME) &&
		     (evt->nw_reg_status != LTE_LC_NW_REG_REGISTERED_ROAMING)) {
			break;
		}

		printk("Network registration status: %s\n",
			evt->nw_reg_status == LTE_LC_NW_REG_REGISTERED_HOME ?
			"Connected - home network" : "Connected - roaming");

		k_sem_give(&lte_connected);
		break;
	case LTE_LC_EVT_PSM_UPDATE:
		printk("PSM parameter update: TAU: %d, Active time: %d\n",
			evt->psm_cfg.tau, evt->psm_cfg.active_time);
		break;
	case LTE_LC_EVT_EDRX_UPDATE: {
		char log_buf[60];
		ssize_t len;

		len = snprintf(log_buf, sizeof(log_buf),
			       "eDRX parameter update: eDRX: %f, PTW: %f",
			       evt->edrx_cfg.edrx, evt->edrx_cfg.ptw);
		if (len > 0) {
			printk("%s\n", log_buf);
		}
		break;
	}
	case LTE_LC_EVT_RRC_UPDATE:
		printk("RRC mode: %s\n",
			evt->rrc_mode == LTE_LC_RRC_MODE_CONNECTED ?
			"Connected" : "Idle");
		break;
	case LTE_LC_EVT_CELL_UPDATE:
		printk("LTE cell changed: Cell ID: %d, Tracking area: %d\n",
			evt->cell.id, evt->cell.tac);
		break;
	default:
		break;
	}
}

static void modem_configure(void)
{
	int err;

	if (IS_ENABLED(CONFIG_LTE_AUTO_INIT_AND_CONNECT)) {
		/* Do nothing, modem is already configured and LTE connected. */
	} else {
		err = lte_lc_init_and_connect_async(lte_handler);
		if (err) {
			printk("Modem could not be configured, error: %d\n",
				err);
			return;
		}
	}
}

static void at_configure(void)
{
	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.");
}

static void bsd_lib_modem_dfu_handler(void)
{
	int err;

	err = bsdlib_init();

	switch (err) {
	case MODEM_DFU_RESULT_OK:
		printk("Modem update suceeded, reboot\n");
		sys_reboot(SYS_REBOOT_COLD);
		break;
	case MODEM_DFU_RESULT_UUID_ERROR:
	case MODEM_DFU_RESULT_AUTH_ERROR:
		printk("Modem update failed, error: %d\n", err);
		printk("Modem will use old firmware\n");
		sys_reboot(SYS_REBOOT_COLD);
		break;
	case MODEM_DFU_RESULT_HARDWARE_ERROR:
	case MODEM_DFU_RESULT_INTERNAL_ERROR:
		printk("Modem update malfunction, error: %d, reboot\n", err);
		sys_reboot(SYS_REBOOT_COLD);
		break;
	default:
		break;
	}

	at_configure();
}
#endif

static int app_topics_subscribe(void)
{
	int err;
	char custom_topic[75] = "my-custom-topic/example";
	char custom_topic_2[75] = "my-custom-topic/example_2";

	const struct aws_iot_topic_data topics_list[APP_TOPICS_COUNT] = {
		[0].str = custom_topic,
		[0].len = strlen(custom_topic),
		[1].str = custom_topic_2,
		[1].len = strlen(custom_topic_2)
	};

	err = aws_iot_subscription_topics_add(topics_list,
					      ARRAY_SIZE(topics_list));
	if (err) {
		printk("aws_iot_subscription_topics_add, error: %d\n", err);
	}

	return err;
}

static void date_time_event_handler(const struct date_time_evt *evt)
{
	switch (evt->type) {
	case DATE_TIME_OBTAINED_MODEM:
		printk("DATE_TIME_OBTAINED_MODEM\n");
		break;
	case DATE_TIME_OBTAINED_NTP:
		printk("DATE_TIME_OBTAINED_NTP\n");
		break;
	case DATE_TIME_OBTAINED_EXT:
		printk("DATE_TIME_OBTAINED_EXT\n");
		break;
	case DATE_TIME_NOT_OBTAINED:
		printk("DATE_TIME_NOT_OBTAINED\n");
		break;
	default:
		break;
	}

	/** Do not depend on obtained time, continue upon any event from the
	 *  date time library.
	 */
	k_sem_give(&date_time_obtained);
}

void main(void)
{
	int err;

	printk("The AWS IoT sample started, version: %s\n", CONFIG_APP_VERSION);

	cJSON_Init();

#if defined(CONFIG_BSD_LIBRARY)
	bsd_lib_modem_dfu_handler();
#endif

	err = aws_iot_init(NULL, aws_iot_event_handler);
	if (err) {
		printk("AWS IoT library could not be initialized, error: %d\n",
		       err);
	}

	/** Subscribe to customizable non-shadow specific topics
	 *  to AWS IoT backend.
	 */
	err = app_topics_subscribe();
	if (err) {
		printk("Adding application specific topics failed, error: %d\n",
			err);
	}

	work_init();//tiene agragados dos hilos correspondientes a gps
#if defined(CONFIG_BSD_LIBRARY)
	modem_configure();

	err = modem_info_init();
	if (err) {
		printk("Failed initializing modem info module, error: %d\n",
			err);
	}
//**************** START GPS FUNCTIONS **************
       
        gps_dev = device_get_binding("NRF9160_GPS");//binding gps with nrf9160
        if (gps_dev == NULL) {
		printk("Could not get binding to nRF9160 GPS");
	}

	err = gps_init(gps_dev, gps_handler);//initializes gps (gps_dev) and the actions control id by gps_handler
	if (err) {
		printk("Could not initialize GPS, error: %d", err);
	}
//**************** END GPS FUNCTION **************
	
        k_sem_take(&lte_connected, K_FOREVER);
#endif


	date_time_update_async(date_time_event_handler);

	err = k_sem_take(&date_time_obtained, K_SECONDS(DATE_TIME_TIMEOUT_S));
	if (err) {
		printk("Date time, no callback event within %d seconds\n",
			DATE_TIME_TIMEOUT_S);
	}

	k_delayed_work_submit(&connect_work, K_NO_WAIT);
}

RE: AWS IoT how change the messagge type 1?

Heidi — Thu, 29 Apr 2021 15:55:50 GMT

[quote user="tracking"]how can I know the timers set by the network where my UE is conneted?[/quote]

You can use AT%XMONITOR to read the Active Time and Periodic TAU set by the network.

Yes, you can use the modem_configure() in the AWS IoT sample, but you need to modify it to request PSM (L348).

Did you include the GPS driver (L13)? Can I see your main.c file?

RE: AWS IoT how change the messagge type 1?

tracking — Tue, 27 Apr 2021 21:46:42 GMT

Hi Heidi!

[quote userid="82276" url="~/f/nordic-q-a/73312/aws-iot-how-change-the-messagge-type-1/306268#306268"]The modem will go in and out of Power Saving Mode by itself, based on the timers set by the network[/quote]

how can I know the timers set by the network where my UE is conneted?

[quote userid="82276" url="~/f/nordic-q-a/73312/aws-iot-how-change-the-messagge-type-1/305824#305824"]Then once the modem has been configured (L398) and the device binding for the nRF9160 GPS is complete (L405)[/quote]

I have drawbacks in this part, I add the gsp_handler() and gps_init() of agps sample to aws_iot sample, omitting only cloud connection code, but at run time show this message:

I try to read about what is binding operation but don't find documentation about this, the modem_configure(); in aws_iot (L372) is the same that agps (L336), I mean, can the gps work with the modem_configure(); of aws_iot?

edit: I tried to debug but I don't know how to verify or control the binding function

RE: AWS IoT how change the messagge type 1?

Heidi — Thu, 22 Apr 2021 09:41:45 GMT

The modem will go in and out of Power Saving Mode by itself, based on the timers set by the network. That's not something the application has any control of. When the UE is in PSM, the GPS will be able to function and get a fix.

It's important to request a time long enough for the GPS to be able to get a fix though. AT+CPSMS is used to request these parameters from the network. Be aware that you are free the request any values from the network, but the network can set different values.

RE: AWS IoT how change the messagge type 1?

tracking — Wed, 21 Apr 2021 21:35:51 GMT

Hi!

Thank you very much I understand better now the gps manage, however I don't undertand the modem manage because in L348 require psm mode but then don't go out of psm mode again.

In documentation I find that gps works better with modem en PSM and eDRX mode but when I wanna transmit how I active the modem to connect and transmit?

RE: AWS IoT how change the messagge type 1?

Heidi — Tue, 20 Apr 2021 11:34:42 GMT

Hi, let's start in the main file.

work_init() is called (L396) which calls

k_delayed_work_init(&gps_start_work, gps_start_work_fn); (L332)

This initializes the work item gps_start_work as a delayed work item with the handler gps_start_work_fn(), which configures and starts the GPS.

Then once the modem has been configured (L398) and the device binding for the nRF9160 GPS is complete (L405), the GPS is initialized (L411), which the device from the binding (gps_dev) and a gps_handler() that's defined earlier.

err = gps_init(gps_dev, gps_handler); is defined in nrf/include/drivers/gps.h L366.

RE: AWS IoT how change the messagge type 1?

tracking — Mon, 19 Apr 2021 23:46:50 GMT

Hi Heidi

Thank for your recomendation, I have a doubt whit AGPS sample, where is the recursivity or the interrup to take the gps data? I don't understand that part

RE: AWS IoT how change the messagge type 1?

Heidi — Mon, 12 Apr 2021 11:07:17 GMT

Hi!

work_init() initializes three delayed work items (shadow_update_work, connect_work and shadow_update_version_work) prior to their first use (see: Zephyr: Submitting a Delayed Work Item).

nrf_modem_lib_dfu_handler() initializes the nRF Modem Libary (formerly called BSD Lib) which is the library used to run the modem on the nRF9160 SiP (see nrf_modem_lib.h#L24-L48 for a full description). It then has a switch case for the error code from the function. Lastly, it initializes the AT Cmd and AT Notif libraries.

I linked the meaning of the errors in my previous comment. EINVAL (22) is invalid argument. If you want to know why that function is returning this, you can take a look at where it is used in the code and the function definition (see lte_lc.c#811-L1871).

Looks like the sample already requests to set the modem in PSM mode (see main.c#L250), so you don't have to think about this. Try integrating a GPS handler and GPS init function like in the AGPS sample.

RE: AWS IoT how change the messagge type 1?

tracking — Wed, 07 Apr 2021 22:10:38 GMT

Hi Heidi!

I can see the errors thanks for that, now analazing the aws_iot sample to know how implement PSM or eDRX mode and I don´t undestand the work_init() function, how works k_delayed_work_init()?

I undertand that in main.c transmition is in L497, but just after this line can I put LTE modem in PSM or eDRX mode and then activate GPS?

edition I: I don't undertand what nrf_modem_lib_dfu_handler() does and what is the meaninig of this #define MODEM_DFU_RESULT_OK 0x5500001u?

edition II: how I can find the errors meaning? i.e. this function lte_lc_func_mode_get() return -22, but I can't find its meaning

RE: AWS IoT how change the messagge type 1?

Heidi — Wed, 07 Apr 2021 11:22:54 GMT

Hi!

The errors are defined in newlib's errno.h:

#define EBADF 9 /* Bad file number */

You are correct, the GPS and LTE functionality of the modem cannot work concurrently. So you can either put the modem in offline mode every time you want to use the GPS, though we do not recommend this method because the UE will disconnect from the network and has to go through the attach process every time you turn the modem back on which takes time and increases the current consumption of the application.

Instead, you can find out of your network supports PSM or eDRX and then put the modem in one of these modes before activating the GPS.

RE: AWS IoT how change the messagge type 1?

tracking — Sat, 03 Apr 2021 01:27:01 GMT

Hi Heidi

thanks for your response, I identify the lines you mention and I've saw the GPS sample and joint the samples in one, over aws iot sample I put the gps sample functions, the project compiles but in terminal show this

I don't know what is err:9, I searched but i could not find and the failed to initializa modem I supose that is due to GPS and LTE cannot work concurrently, where I can find information about this manage

RE: AWS IoT how change the messagge type 1?

Heidi — Mon, 29 Mar 2021 15:15:52 GMT

Hi!

Here are the relevant lines when modifying what message to post to AWS IoT.

In L108-L109, the data (battery voltage and date and time) is added to the JSON objects. Here is where you would instead add the GPS data.

Then the object is made into a message string in L118.

L125-L130 is where the struct that is used to transmit packages in the AWS IoT library is created.

And it is published in L134.

You will also need to add GPS functionality in the sample, as this is not included. Use the GPS sample in NCS as a reference. Remember that GPS and LTE cannot work concurrently so you will either need to put the modem in PSM mode or turn it off before activating the GPS.

Best regards,

Heidi