NTN Support and Application Feasibility on nRF9151

RE: NTN Support and Application Feasibility on nRF9151

Benjamin — Wed, 18 Feb 2026 08:20:16 GMT

Yes, but I am referring to a modem trace. We'll need it to see the full picture. You can find instructions for enabling it in the DevAcademy. Please upload the file here so we can inspect it.

RE: NTN Support and Application Feasibility on nRF9151

Priyesh Shahi — Tue, 17 Feb 2026 11:41:25 GMT

Yes that's why i was thinking that it may be not ntn but the cellular. I have already added the code above.

RE: NTN Support and Application Feasibility on nRF9151

Benjamin — Tue, 17 Feb 2026 11:10:09 GMT

Hi Priyesh,
That sounds strange indeed. If the modem is moved more than 400m during or in between connections you need to update the location. This can be done externally by using the %LOCAITON command or internally using a procedure involving the GPS. What exact firmware are you using?

Could you share a modem trace? That will help us see what exactly is going on.

Best regards,
Benjamin

RE: NTN Support and Application Feasibility on nRF9151

Priyesh Shahi — Tue, 17 Feb 2026 04:35:04 GMT

Hi Benjamin,

Thank you for the clarification regarding AT+COPS?.

In my testing, I set the location of the room where the board was initially operating, and NTN connectivity worked there as expected. However, I then moved approximately 30 km away from that location, and the device continued to connect successfully using the same previously configured location.

This is where my confusion arises — how is the device able to connect to NTN with an incorrect location configured? Does the modem internally determine or refine its location even if the %LOCATION value is not accurate? Or is the configured location only used as an initial hint for acquisition?

Best regards,

Priyesh

RE: NTN Support and Application Feasibility on nRF9151

Benjamin — Mon, 16 Feb 2026 13:16:22 GMT

Hi,
You could use AT+COPS? to check what type of network you are connected to. The value for NTN NB-IoT is 14.

I guess you are referring to the %LOCATION set command? What specific questions do you have?

Best regards,
Benjamin

RE: NTN Support and Application Feasibility on nRF9151

Priyesh Shahi — Mon, 16 Feb 2026 08:46:03 GMT

Hi Benjamin,

The #PING function was not working initially. However, I made a few changes to the code. Up to the connection stage, I used AT commands, and for the remaining operations I utilized functions from the socket library and CoAP library. After these modifications, it worked successfully, and I am now able to send payloads to my CoAP server.

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

#include <string.h>
#include <zephyr/kernel.h>
#include <stdio.h>
#include <stdlib.h>
#include <nrf_modem_at.h>
#include <modem/nrf_modem_lib.h>
#include <modem/at_monitor.h>
#include <modem/modem_info.h>

#include <stdio.h>
#include <ncs_version.h>

#include <zephyr/kernel.h>
#include <zephyr/net/socket.h>

#include <zephyr/logging/log.h>
#include <modem/nrf_modem_lib.h>
#include <modem/lte_lc.h>

#include <zephyr/random/random.h>
#include <zephyr/net/coap.h>

#include <modem/ntn.h>

#define SEND_REQ_THREAD_STACK_SIZE 1024
#define SEND_REQ_THREA_PRIORITY 5

/* Define the macros for the CoAP version and message length */
#define APP_COAP_VERSION 1
#define APP_COAP_MAX_MSG_LEN 1280

K_SEM_DEFINE(con_sem, 0, 1);

/* Declare the buffer coap_buf to receive the response. */
static uint8_t coap_buf[APP_COAP_MAX_MSG_LEN];

/* Define the CoAP message token next_token */
static uint16_t next_token;

static int sock;
static struct sockaddr_storage server;

K_SEM_DEFINE(cereg_sem, 0, 1);

uint8_t response[128] = {0};

LOG_MODULE_REGISTER(main, LOG_LEVEL_INF);

AT_MONITOR(cmd_rsp, ANY, cmd_mon, ACTIVE);

/* AT monitor for network notifications */
AT_MONITOR(network, "CEREG", cereg_mon);

static int cereg_status;
enum cereg_status {
	NO_NETWORK = 0,
	HOME = 1,
	SEARCHING = 2,
	DENIED = 3,
	UNKNOWN = 4,
	ROAMING = 5,
	UICC_FAILURE = 90
};

static const char *cereg_str_get(enum cereg_status status)
{
	switch (status) {
	case NO_NETWORK:
		return "no network";
	case HOME:
		return "home";
	case SEARCHING:
		return "searching";
	case DENIED:
		return "denied";
	case UNKNOWN:
		return "unknown";
	case ROAMING:
		return "roaming";
	case UICC_FAILURE:
		return "UICC failure";
	default:
		return NULL;
	}
}

static void cereg_mon(const char *notif)
{
	const char *cereg_status_str;

	cereg_status = atoi(notif + strlen("+CEREG: "));
	cereg_status_str = cereg_str_get(cereg_status);

	if (!cereg_status_str) {
		LOG_ERR("Network registration status unknown: %d", cereg_status);
		return;
	}

	LOG_INF("Network registration status: %s", cereg_status_str);

	if ((cereg_status == HOME) || (cereg_status == ROAMING)) {
		k_sem_give(&cereg_sem);
	}
}

static void cmd_mon(const char *notif)
{
	LOG_INF("%s", notif);
}

/**@brief Resolves the configured hostname. */
static int server_resolve(void)
{
	int err;
	struct addrinfo *result;
	struct addrinfo hints = {
		.ai_family = AF_INET,
		.ai_socktype = SOCK_DGRAM};
	char ipv4_addr[NET_IPV4_ADDR_LEN];

	err = getaddrinfo(CONFIG_COAP_SERVER_HOSTNAME, NULL, &hints, &result);
	if (err != 0)
	{
		LOG_ERR("ERROR: getaddrinfo failed %d", err);
		return -EIO;
	}

	if (result == NULL)
	{
		LOG_ERR("ERROR: Address not found");
		return -ENOENT;
	}

	/* IPv4 Address. */
	struct sockaddr_in *server4 = ((struct sockaddr_in *)&server);

	server4->sin_addr.s_addr =
		((struct sockaddr_in *)result->ai_addr)->sin_addr.s_addr;
	server4->sin_family = AF_INET;
	server4->sin_port = htons(CONFIG_COAP_SERVER_PORT);

	inet_ntop(AF_INET, &server4->sin_addr.s_addr, ipv4_addr,
			  sizeof(ipv4_addr));
	LOG_INF("IPv4 Address found %s", ipv4_addr);

	/* Free the address. */
	freeaddrinfo(result);

	return 0;
}

/**@brief Initialize the CoAP client */
static int client_init(void)
{
	int err;

	sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	if (sock < 0)
	{
		LOG_ERR("Failed to create CoAP socket: %d.", errno);
		return -errno;
	}

	err = connect(sock, (struct sockaddr *)&server,
				  sizeof(struct sockaddr_in));
	if (err < 0)
	{
		LOG_ERR("Connect failed : %d", errno);
		return -errno;
	}

	LOG_INF("Successfully connected to server");

	/* Generate a random token after the socket is connected */
	next_token = sys_rand32_get();

	k_sem_give(&con_sem);

	return 0;
}

/**@brief Send CoAP POST request. */
static int client_post_send(void)
{
	int err;
	struct coap_packet request;

	next_token = sys_rand32_get();

	/* Initialize the CoAP packet and append the resource path */
	err = coap_packet_init(&request, coap_buf, sizeof(coap_buf),
						   APP_COAP_VERSION, COAP_TYPE_CON,
						   sizeof(next_token), (uint8_t *)&next_token,
						   COAP_METHOD_POST, coap_next_id());
	if (err < 0)
	{
		LOG_ERR("Failed to create CoAP request, %d", err);
		return err;
	}

	err = coap_packet_append_option(&request, COAP_OPTION_URI_HOST,
									(uint8_t *)CONFIG_COAP_SERVER_HOSTNAME,
									strlen(CONFIG_COAP_SERVER_HOSTNAME));
	if (err < 0)
	{
		LOG_ERR("Failed to encode CoAP option, %d", err);
		return err;
	}

	err = coap_packet_append_option(&request, COAP_OPTION_URI_PATH,
									(uint8_t *)CONFIG_COAP_TX_RESOURCE,
									strlen(CONFIG_COAP_TX_RESOURCE));
	if (err < 0)
	{
		LOG_ERR("Failed to encode CoAP option, %d", err);
		return err;
	}

	/* Add payload marker */
	err = coap_packet_append_payload_marker(&request);
	if (err < 0)
	{
		LOG_ERR("Failed to append payload marker, %d", err);
		return err;
	}

	/* Format and append as payload */
	char payload[64];

	int len = snprintf(payload, sizeof(payload), "1234567890123456789012345678901");
	if (len < 0 || len >= sizeof(payload))
	{
		LOG_ERR("Failed to format counter payload");
		return -EINVAL;
	}

	err = coap_packet_append_payload(&request, (uint8_t *)payload, len);
	if (err < 0)
	{
		LOG_ERR("Failed to append payload, %d", err);
		return err;
	}

	err = send(sock, request.data, request.offset, 0);
	if (err < 0)
	{
		LOG_ERR("Failed to send CoAP request, %d", errno);
		return -errno;
	}

	LOG_INF("CoAP POST request sent: Token 0x%04x", next_token);

	return 0;
}

/**@brief Handles responses from the remote CoAP server. */
static int client_handle_response(uint8_t *buf, int received)
{
	struct coap_packet reply;
	uint8_t token[8];
	uint16_t token_len;
	const uint8_t *payload;
	uint16_t payload_len;
	uint8_t temp_buf[128];
	/* Parse the received CoAP packet */
	int err = coap_packet_parse(&reply, buf, received, NULL, 0);
	if (err < 0)
	{
		LOG_ERR("Malformed response received: %d", err);
		return err;
	}

	/* Confirm the token in the response matches the token sent */
	token_len = coap_header_get_token(&reply, token);
	if ((token_len != sizeof(next_token)) ||
		(memcmp(&next_token, token, sizeof(next_token)) != 0))
	{
		LOG_ERR("Invalid token received: 0x%02x%02x",
				token[1], token[0]);
		return 0;
	}

	/* Retrieve the payload and confirm it's nonzero */
	payload = coap_packet_get_payload(&reply, &payload_len);

	if (payload_len > 0)
	{
		snprintf(temp_buf, MIN(payload_len + 1, sizeof(temp_buf)), "%s", payload);
	}
	else
	{
		strcpy(temp_buf, "EMPTY");
	}

	/* Log the header code, token and payload of the response */
	LOG_INF("CoAP response: Code 0x%x, Token 0x%02x%02x, Payload: %s",
			coap_header_get_code(&reply), token[1], token[0], (char *)temp_buf);

	return 0;
}

int main(void)
{
	int err;

	int received;

	/* Register NTN handler (safe even if you start in TN mode) */
	// ntn_register_handler(app_ntn_event_handler);

	LOG_INF("AT Monitor sample started");

	err = nrf_modem_lib_init();
	if (err)
	{
		LOG_ERR("Modem library initialization failed, error: %d", err);
		return 0;
	}

	err = nrf_modem_at_cmd(response, sizeof(response), "AT+CFUN=0");
	if (err)
	{
		LOG_ERR("Failed to read AT+CFUN=0, err %d", err);
		return 0;
	}

	LOG_INF("%s", response);
	k_msleep(1000);
	err = nrf_modem_at_cmd(response, sizeof(response), "AT%%XFACTORYRESET=0");
	if (err)
	{
		LOG_ERR("Failed to read xfactoryreset, err %d", err);
		return 0;
	}

	LOG_INF("%s", response);
	k_msleep(1000);
	err = nrf_modem_at_cmd(response, sizeof(response), "AT%%XSYSTEMMODE=0,0,0,0,1");
	if (err)
	{
		LOG_ERR("Failed to read XSYSTEMMODE, err %d", err);
		return 0;
	}

	LOG_INF("%s", response);
	k_msleep(1000);
	err = nrf_modem_at_cmd(response, sizeof(response), "AT%%XBANDLOCK=2,,\"255,256\"");
	if (err)
	{
		LOG_ERR("Failed to read XBANDLOCK, err %d", err);
		return 0;
	}

	LOG_INF("%s", response);
	k_msleep(1000);
	err = nrf_modem_at_cmd(response, sizeof(response), "AT%%LOCATION=2,\"36.33144938\",\"-119.292130\",\"0\",0,0");
	if (err)
	{
		LOG_ERR("Failed to read LOCATION, err %d", err);
		return 0;
	}

	LOG_INF("%s", response);
	k_msleep(1000);
	err = nrf_modem_at_cmd(response, sizeof(response), "AT+CGDCONT=0,\"IP\",\"data.mono\"");
	if (err)
	{
		LOG_ERR("Failed to read CGDCONT, err %d", err);
		return 0;
	}

	LOG_INF("%s", response);
	k_msleep(1000);
	err = nrf_modem_at_cmd(response, sizeof(response), "AT%%MDMEV=2");
	if (err)
	{
		LOG_ERR("Failed to read MDMEV, err %d", err);
		return 0;
	}

	LOG_INF("%s", response);
	k_msleep(1000);
	err = nrf_modem_at_cmd(response, sizeof(response), "AT+CSCON=3");
	if (err)
	{
		LOG_ERR("Failed to read CSCON, err %d", err);
		return 0;
	}

	LOG_INF("%s", response);
	k_msleep(1000);

	err = nrf_modem_at_cmd(response, sizeof(response), "AT+CNEC=24");
	if (err)
	{
		LOG_ERR("Failed to read CEREG, err %d", err);
		return 0;
	}

	LOG_INF("%s", response);
	k_msleep(1000);

	err = nrf_modem_at_cmd(response, sizeof(response), "AT+CEREG=5");
	if (err)
	{
		LOG_ERR("Failed to read CEREG, err %d", err);
		return 0;
	}

	LOG_INF("%s", response);
	k_msleep(1000);

	err = nrf_modem_at_cmd(response, sizeof(response), "AT+CFUN=1");
	if (err)
	{
		LOG_ERR("Failed to read CEREG, err %d", err);
		return 0;
	}

	LOG_INF("%s", response);

	LOG_INF("Waiting for network");
	err = k_sem_take(&cereg_sem, K_SECONDS(200));

	if ((cereg_status == HOME) || (cereg_status == ROAMING)) {
		LOG_INF("Network connection ready");
	} else {
		if (err == -EAGAIN) {
			LOG_ERR("Network connection timed out");
		}
		LOG_WRN("Continuing without network");
	}

	k_msleep(1000);

	if (server_resolve() != 0)
	{
		LOG_ERR("Failed to resolve server name");
		return 0;
	}

	if (client_init() != 0)
	{
		LOG_ERR("Failed to initialize client");
		return 0;
	}

	while (1)
	{
		/* Receive response from the CoAP server */
		received = recv(sock, coap_buf, sizeof(coap_buf), 0);

		if (received < 0)
		{
			LOG_ERR("Socket error: %d, exit", errno);
			break;
		}
		else if (received == 0)
		{
			LOG_INF("Empty datagram");
			continue;
		}

		/* Parse the received CoAP packet */
		err = client_handle_response(coap_buf, received);
		if (err < 0)
		{
			LOG_ERR("Invalid response, exit");
			break;
		}
	}

	(void)close(sock);

	return 0;
}

void send_req_thread(void *arg1, void *arg2, void *arg3)
{
	k_sem_take(&con_sem, K_FOREVER);
	while (1)
	{
		client_post_send();
		k_sleep(K_SECONDS(30));
	}
}

K_THREAD_DEFINE(send_req, SEND_REQ_THREAD_STACK_SIZE, send_req_thread, NULL, NULL, NULL,
				SEND_REQ_THREA_PRIORITY, 0, 0);

How would I confirm whether the network used to send the payload was exclusively NTN. I tested this in two different locations: first while inside a room, where it still connected successfully, and then approximately 30 km away, where it continued to connect without any issues.

Could you please advise how I can confirm that the connection was established specifically over NTN? Additionally, could you explain how the set location functionality works in this context?

Kind regards,
Priyesh shahi

RE: NTN Support and Application Feasibility on nRF9151

Benjamin — Fri, 13 Feb 2026 10:25:02 GMT

Hi Priyesh,

The AT#XPING (and other # style commands) are native to the Serial Modem application. They will not work on regular samples.

For the failing sample, what exact CoAP sample are you referring to?

Regards,
Benjamin

RE: NTN Support and Application Feasibility on nRF9151

Priyesh Shahi — Tue, 10 Feb 2026 05:29:55 GMT

I also tried with at monitor sample, where i modified commands.

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

#include <string.h>
#include <zephyr/kernel.h>
#include <stdio.h>
#include <stdlib.h>
#include <nrf_modem_at.h>
#include <modem/nrf_modem_lib.h>
#include <modem/at_monitor.h>
#include <modem/modem_info.h>

AT_MONITOR(cmd_rsp, ANY, cmd_mon, ACTIVE);

uint8_t response[128] = {0};

static void cmd_mon(const char *notif)
{

	printk("%s\n", notif);
}

int main(void)
{
	int err;

	printk("AT Monitor sample started\n");

	err = nrf_modem_lib_init();
	if (err)
	{
		printk("Modem library initialization failed, error: %d\n", err);
		return 0;
	}

	err = nrf_modem_at_cmd(response, sizeof(response), "AT+CFUN=0");
	if (err)
	{
		printk("Failed to read AT+CFUN=0, err %d\n", err);
		return 0;
	}

	printk("%s\n", response);
	k_msleep(1000);
	err = nrf_modem_at_cmd(response, sizeof(response), "AT%%XFACTORYRESET=0");
	if (err)
	{
		printk("Failed to read xfactoryreset, err %d\n", err);
		return 0;
	}

	printk("%s\n", response);
	k_msleep(1000);
	err = nrf_modem_at_cmd(response, sizeof(response), "AT%%XSYSTEMMODE=0,0,0,0,1");
	if (err)
	{
		printk("Failed to read XSYSTEMMODE, err %d\n", err);
		return 0;
	}

	printk("%s\n", response);
	k_msleep(1000);
	err = nrf_modem_at_cmd(response, sizeof(response), "AT%%XBANDLOCK=2,,\"255,256\"");
	if (err)
	{
		printk("Failed to read XBANDLOCK, err %d\n", err);
		return 0;
	}

	printk("%s\n", response);
	k_msleep(1000);
	err = nrf_modem_at_cmd(response, sizeof(response), "AT%%LOCATION=2,\"36.33144938\",\"-119.292130\",\"0\",0,0");
	if (err)
	{
		printk("Failed to read LOCATION, err %d\n", err);
		return 0;
	}

	printk("%s\n", response);
	k_msleep(1000);
	err = nrf_modem_at_cmd(response, sizeof(response), "AT+CGDCONT=0,\"IP\",\"data.mono\"");
	if (err)
	{
		printk("Failed to read CGDCONT, err %d\n", err);
		return 0;
	}

	printk("%s\n", response);
	k_msleep(1000);
	err = nrf_modem_at_cmd(response, sizeof(response), "AT%MDMEV=2");
	if (err)
	{
		printk("Failed to read MDMEV, err %d\n", err);
		return 0;
	}

	printk("%s\n", response);
	k_msleep(1000);
	err = nrf_modem_at_cmd(response, sizeof(response), "AT+CSCON=3");
	if (err)
	{
		printk("Failed to read CSCON, err %d\n", err);
		return 0;
	}

	printk("%s\n", response);
	k_msleep(1000);

	err = nrf_modem_at_cmd(response, sizeof(response), "AT+CNEC=24");
	if (err)
	{
		printk("Failed to read CEREG, err %d\n", err);
		return 0;
	}

	printk("%s\n", response);
	k_msleep(1000);

	err = nrf_modem_at_cmd(response, sizeof(response), "AT+CEREG=5");
	if (err)
	{
		printk("Failed to read CEREG, err %d\n", err);
		return 0;
	}

	printk("%s\n", response);
	k_msleep(1000);

	err = nrf_modem_at_cmd(response, sizeof(response), "AT+CFUN=1");
	if (err)
	{
		printk("Failed to read CEREG, err %d\n", err);
		return 0;
	}

	printk("%s\n", response);
	k_msleep(200000);

	// err = nrf_modem_at_cmd(response, sizeof(response), "AT#XPING=\"8.8.8.8\",32,30000,4,1000");
	// if (err)
	// {
	// 	printk("Failed to read XPING, err %d\n", err);
	// }

	// printk("%s\n", response);

	while (true)
	{
		/* code */
		k_msleep(10000);
		err = nrf_modem_at_cmd(response, sizeof(response), "AT%%XMONITOR");
		if (err)
		{
			printk("Failed to read CEREG, err %d\n", err);
			return 0;
		}

		printk("%s\n", response);
	}
}

RE: NTN Support and Application Feasibility on nRF9151

Priyesh Shahi — Tue, 10 Feb 2026 05:23:00 GMT

devzone.nordicsemi.com/.../ntn_5F00_log.txt devzone.nordicsemi.com/.../serial_2D00_terminal_2D00_09022026_5F00_211807.txt

earlier i was able to ping with these commands, but now even that is failing.

RE: NTN Support and Application Feasibility on nRF9151

Achim Kraus — Mon, 09 Feb 2026 13:00:18 GMT

[quote userid="129185" url="~/f/nordic-q-a/126266/ntn-support-and-application-feasibility-on-nrf9151/560633"]is there anything that I should change so that it connects to network.[/quote]

I'm not sure, but I don't see, that you select band 256 and 255, do you?

AT%XBANDLOCK=2,,\"255,256\"

RE: NTN Support and Application Feasibility on nRF9151

Priyesh Shahi — Mon, 09 Feb 2026 11:06:22 GMT

I will address CoAP timing later. In this case, the issue appears earlier, as the device does not seem to reach a connected state in NTN mode. The modem keeps requesting location updates, but the application does not progress beyond this, unlike in LTE mode where the same sample works. Therefore, this seems related to NTN attachment or modem state rather than CoAP behavior.

is there anything that I should change so that it connects to network.

RE: NTN Support and Application Feasibility on nRF9151

Achim Kraus — Mon, 09 Feb 2026 10:13:44 GMT

CoAP in general assumes a default timeout, which is based on constrained networks.

But NTN is even "more constraint". In my experience, at least the first message exchange (request/response) takes up to 30s (sometimes even 50s) after the device is RRC active and registered in the network. Follow-up message may be faster (10-15s) but there will be also cases, where more time is needed. I use in the meantime 50s ACK timeout.

RE: NTN Support and Application Feasibility on nRF9151

Priyesh Shahi — Mon, 09 Feb 2026 10:02:34 GMT

I am working with an nRF9151 SMA DK using nRF Connect SDK v3.2.1 and testing NTN connectivity. When using the precompiled Eval HEX and issuing AT commands, the device is able to register on the NTN network, successfully ping external hosts, and establish UDP communication with a server. This indicates that basic NTN registration and IP connectivity are functioning as expected.

However, while using AT commands, I was not able to construct a valid CoAP payload in hexadecimal format suitable for transmission over NTN. To address this, I switched to the CoAP client sample from the Nordic DevAcademy exercise and modified it to enable NTN, configure the required NTN settings, and provide device location using ntn_location_set() together with an NTN event handler.

The modified CoAP application builds and flashes successfully, and there are no compile-time or obvious runtime errors. When running this application in LTE mode, the CoAP sample behaves as expected and is able to connect to the server and exchange data. When switching the same application to NTN mode, however, the device does not establish the connection.

Given that raw UDP communication over NTN works via AT commands and the same CoAP sample works correctly over LTE, I would like to understand whether there are additional requirements or limitations when using CoAP over NTN on the nRF9151. Specifically, are there any required socket, CoAP, or modem configurations that differ between LTE and NTN, or any known constraints that would prevent the DevAcademy CoAP sample from working over NTN without further modification?

is there anything that I should add in this code? I am using modem firmware from sma dk eval web page.

code

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

#include <stdio.h>
#include <ncs_version.h>

#include <zephyr/kernel.h>
#include <zephyr/net/socket.h>

#include <zephyr/logging/log.h>
#include <modem/nrf_modem_lib.h>
#include <modem/lte_lc.h>

#include <zephyr/random/random.h>
#include <zephyr/net/coap.h>

#include <modem/ntn.h>

#define SEND_REQ_THREAD_STACK_SIZE 1024
#define SEND_REQ_THREA_PRIORITY 5

/* Define the macros for the CoAP version and message length */
#define APP_COAP_VERSION 1
#define APP_COAP_MAX_MSG_LEN 1280

K_SEM_DEFINE(con_sem, 0, 1);

/* Declare the buffer coap_buf to receive the response. */
static uint8_t coap_buf[APP_COAP_MAX_MSG_LEN];

/* Define the CoAP message token next_token */
static uint16_t next_token;

static int sock;
static struct sockaddr_storage server;

static uint8_t test_counter = 0;

K_SEM_DEFINE(lte_connected, 0, 1);

LOG_MODULE_REGISTER(main, LOG_LEVEL_INF);

/**@brief Resolves the configured hostname. */
static int server_resolve(void)
{
        int err;
        struct addrinfo *result;
        struct addrinfo hints = {
            .ai_family = AF_INET,
            .ai_socktype = SOCK_DGRAM};
        char ipv4_addr[NET_IPV4_ADDR_LEN];

        err = getaddrinfo(CONFIG_COAP_SERVER_HOSTNAME, NULL, &hints, &result);
        if (err != 0)
        {
                LOG_ERR("ERROR: getaddrinfo failed %d\n", err);
                return -EIO;
        }

        if (result == NULL)
        {
                LOG_ERR("ERROR: Address not found\n");
                return -ENOENT;
        }

        /* IPv4 Address. */
        struct sockaddr_in *server4 = ((struct sockaddr_in *)&server);

        server4->sin_addr.s_addr =
            ((struct sockaddr_in *)result->ai_addr)->sin_addr.s_addr;
        server4->sin_family = AF_INET;
        server4->sin_port = htons(CONFIG_COAP_SERVER_PORT);

        inet_ntop(AF_INET, &server4->sin_addr.s_addr, ipv4_addr,
                  sizeof(ipv4_addr));
        LOG_INF("IPv4 Address found %s\n", ipv4_addr);

        /* Free the address. */
        freeaddrinfo(result);

        return 0;
}

/**@brief Initialize the CoAP client */
static int client_init(void)
{
        int err;

        sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
        if (sock < 0)
        {
                LOG_ERR("Failed to create CoAP socket: %d.\n", errno);
                return -errno;
        }

        err = connect(sock, (struct sockaddr *)&server,
                      sizeof(struct sockaddr_in));
        if (err < 0)
        {
                LOG_ERR("Connect failed : %d\n", errno);
                return -errno;
        }

        LOG_INF("Successfully connected to server");

        /* Generate a random token after the socket is connected */
        next_token = sys_rand32_get();

        k_sem_give(&con_sem);

        return 0;
}

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;
                }
                LOG_INF("Network registration status: %s",
                        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_RRC_UPDATE:
                LOG_INF("RRC mode: %s", evt->rrc_mode == LTE_LC_RRC_MODE_CONNECTED ? "Connected" : "Idle");
                break;
        default:
                break;
        }
}

static int modem_configure(void)
{
        int err;

        LOG_INF("Initializing modem library");
        err = nrf_modem_lib_init();
        if (err)
        {
                LOG_ERR("Failed to initialize the modem library, error: %d", err);
                return err;
        }
        lte_lc_system_mode_set(LTE_LC_SYSTEM_MODE_NTN_NBIOT, LTE_LC_SYSTEM_MODE_PREFER_AUTO);

        LOG_INF("Connecting to LTE network");
        err = lte_lc_connect_async(lte_handler);
        if (err)
        {
                LOG_ERR("Error in lte_lc_connect_async, error: %d", err);
                return err;
        }

        k_sem_take(&lte_connected, K_FOREVER);
        LOG_INF("Connected to LTE network");

        return 0;
}

/**@brief Send CoAP POST request. */
static int client_post_send(void)
{
        int err;
        struct coap_packet request;

        next_token = sys_rand32_get();

        /* Initialize the CoAP packet and append the resource path */
        err = coap_packet_init(&request, coap_buf, sizeof(coap_buf),
                               APP_COAP_VERSION, COAP_TYPE_CON,
                               sizeof(next_token), (uint8_t *)&next_token,
                               COAP_METHOD_POST, coap_next_id());
        if (err < 0)
        {
                LOG_ERR("Failed to create CoAP request, %d\n", err);
                return err;
        }

        err = coap_packet_append_option(&request, COAP_OPTION_URI_HOST,
                                        (uint8_t *)CONFIG_COAP_SERVER_HOSTNAME,
                                        strlen(CONFIG_COAP_SERVER_HOSTNAME));
        if (err < 0)
        {
                LOG_ERR("Failed to encode CoAP option, %d\n", err);
                return err;
        }

        err = coap_packet_append_option(&request, COAP_OPTION_URI_PATH,
                                        (uint8_t *)CONFIG_COAP_TX_RESOURCE,
                                        strlen(CONFIG_COAP_TX_RESOURCE));
        if (err < 0)
        {
                LOG_ERR("Failed to encode CoAP option, %d\n", err);
                return err;
        }

        /* Add payload marker */
        err = coap_packet_append_payload_marker(&request);
        if (err < 0)
        {
                LOG_ERR("Failed to append payload marker, %d\n", err);
                return err;
        }

        /* Format and append test_counter as payload */
        char payload[64];

        int len = snprintf(payload, sizeof(payload), "0000000000000000000000000000000");
        if (len < 0 || len >= sizeof(payload))
        {
                LOG_ERR("Failed to format counter payload");
                return -EINVAL;
        }

        err = coap_packet_append_payload(&request, (uint8_t *)payload, len);
        if (err < 0)
        {
                LOG_ERR("Failed to append payload, %d\n", err);
                return err;
        }

        err = send(sock, request.data, request.offset, 0);
        if (err < 0)
        {
                LOG_ERR("Failed to send CoAP request, %d\n", errno);
                return -errno;
        }

        LOG_INF("CoAP POST request sent: Token 0x%04x\n", next_token);

        return 0;
}

/**@brief Handles responses from the remote CoAP server. */
static int client_handle_response(uint8_t *buf, int received)
{
        struct coap_packet reply;
        uint8_t token[8];
        uint16_t token_len;
        const uint8_t *payload;
        uint16_t payload_len;
        uint8_t temp_buf[128];
        /* Parse the received CoAP packet */
        int err = coap_packet_parse(&reply, buf, received, NULL, 0);
        if (err < 0)
        {
                LOG_ERR("Malformed response received: %d\n", err);
                return err;
        }

        /* Confirm the token in the response matches the token sent */
        token_len = coap_header_get_token(&reply, token);
        if ((token_len != sizeof(next_token)) ||
            (memcmp(&next_token, token, sizeof(next_token)) != 0))
        {
                LOG_ERR("Invalid token received: 0x%02x%02x\n",
                        token[1], token[0]);
                return 0;
        }

        /* Retrieve the payload and confirm it's nonzero */
        payload = coap_packet_get_payload(&reply, &payload_len);

        if (payload_len > 0)
        {
                snprintf(temp_buf, MIN(payload_len + 1, sizeof(temp_buf)), "%s", payload);
        }
        else
        {
                strcpy(temp_buf, "EMPTY");
        }

        /* Log the header code, token and payload of the response */
        LOG_INF("CoAP response: Code 0x%x, Token 0x%02x%02x, Payload: %s\n",
                coap_header_get_code(&reply), token[1], token[0], (char *)temp_buf);

        return 0;
}

/* Example location structure – exact type is defined by the NTN API
 * (not fully shown in the provided docs). Adjust to the real type.
 */
struct app_location
{
        double lat;
        double lon;
        float accuracy_m;
};

/* Stub: get location from external GNSS or other source */
static int app_get_location(struct app_location *loc)
{
        /* TODO: Implement real location acquisition */
        loc->lat = 36.331449;
        loc->lon = -119.292130;
        loc->accuracy_m = 200.0f;
        return 0;
}

/* Convert app_location to NTN library location type and call ntn_location_set().
 * The docs state that validity time must be longer than the interval between updates.[[NTN usage](https://docs.nordicsemi.com/bundle/ncs-latest/page/nrf/libraries/modem/ntn.html#usage)]
 */
static int app_ntn_provide_location(uint32_t validity_time_s)
{
        struct app_location loc;
        int err = app_get_location(&loc);
        if (err)
        {
                LOG_ERR("Failed to get location: %d", err);
                return err;
        }

        err = ntn_location_set(loc.lat, loc.lon, 12, validity_time_s);
        if (err)
        {
                LOG_ERR("ntn_location_set failed: %d", err);
        }
        else
        {
                LOG_INF("NTN location updated, valid for %u s", validity_time_s);
        }

        return err;
}

/* NTN event handler – called when modem needs location updates.[[NTN usage](https://docs.nordicsemi.com/bundle/ncs-latest/page/nrf/libraries/modem/ntn.html#usage)] */
static void app_ntn_event_handler(const struct ntn_evt *evt)
{
        switch (evt->type)
        {
        case NTN_EVT_LOCATION_REQUEST:
                LOG_INF("NTN location request");

                /* Decide update interval based on max device speed, as suggested in docs.
                 * Example: 200 m accuracy, 120 km/h => update at least every 6 s.[[NTN usage](https://docs.nordicsemi.com/bundle/ncs-latest/page/nrf/libraries/modem/ntn.html#usage)]
                 */
                app_ntn_provide_location(60000); /* validity_time_s >= update interval */
                break;

        default:
                LOG_DBG("Unhandled NTN event type: %d", evt->type);
                break;
        }
}

int main(void)
{
        int err;
        int received;

        /* Register NTN handler (safe even if you start in TN mode) */
        ntn_register_handler(app_ntn_event_handler);

        err = modem_configure();
        if (err)
        {
                LOG_ERR("Failed to configure the modem");
                return 0;
        }

        if (server_resolve() != 0)
        {
                LOG_INF("Failed to resolve server name");
                return 0;
        }

        if (client_init() != 0)
        {
                LOG_INF("Failed to initialize client");
                return 0;
        }

        while (1)
        {
                /* Receive response from the CoAP server */
                received = recv(sock, coap_buf, sizeof(coap_buf), 0);

                if (received < 0)
                {
                        LOG_ERR("Socket error: %d, exit\n", errno);
                        break;
                }
                else if (received == 0)
                {
                        LOG_INF("Empty datagram\n");
                        continue;
                }

                /* Parse the received CoAP packet */
                err = client_handle_response(coap_buf, received);
                if (err < 0)
                {
                        LOG_ERR("Invalid response, exit\n");
                        break;
                }
        }

        (void)close(sock);

        return 0;
}

void send_req_thread(void *arg1, void *arg2, void *arg3)
{
        k_sem_take(&con_sem, K_FOREVER);
        while (1)
        {
                client_post_send();
                k_sleep(K_SECONDS(10));
        }
}

K_THREAD_DEFINE(send_req, SEND_REQ_THREAD_STACK_SIZE, send_req_thread, NULL, NULL, NULL,
                SEND_REQ_THREA_PRIORITY, 0, 0);

RE: NTN Support and Application Feasibility on nRF9151

Priyesh Shahi — Thu, 08 Jan 2026 10:51:08 GMT

Thanks for the clarification on the SIM and network operator requirements.

regards,
Priyesh

RE: NTN Support and Application Feasibility on nRF9151

Benjamin — Thu, 08 Jan 2026 10:14:39 GMT

[quote user="Priyesh Shahi"]And also we need a special eSIM/SIM for NTN, different from standard cellular NB-IoT?[/quote]

No, the nRF9151 supports switching between terrestrial and non-terrestrial radio access. You could use the same SIM card if that is what you are asking. However, you need a network operator that supports NTN.

Regards,
Benjamin

RE: NTN Support and Application Feasibility on nRF9151

Achim Kraus — Thu, 08 Jan 2026 06:33:02 GMT

[quote userid="129185" url="~/f/nordic-q-a/126266/ntn-support-and-application-feasibility-on-nrf9151/558220"]Achim mentioned adding NTN support using AT commands. [/quote]

That was referring to NCS 3.1.0. With NCS 3.2.0 that's included in the nrf/lib/lte_link_control.

RE: NTN Support and Application Feasibility on nRF9151

Priyesh Shahi — Thu, 08 Jan 2026 04:33:11 GMT

Benjamin,

Thanks for confirming CoAP/custom payloads work over NTN.

Achim mentioned adding NTN support using AT commands. Is there a library or code example for this, or is it a manual AT command configuration?

And also we need a special eSIM/SIM for NTN, different from standard cellular NB-IoT?

Appreciate the guidance.

Regards,
Priyesh

RE: NTN Support and Application Feasibility on nRF9151

Benjamin — Wed, 07 Jan 2026 13:51:37 GMT

Yes, CoAP or other custom payloads are supported.

This is NB-IoT over satellite rather than terrestrial cell towers. You can now access several satellite-based cellular networks in much the same way as traditional LTE-M or NB-IoT networks. Also see the answer from Achim Kraus.

Regards,
Benjamin

RE: NTN Support and Application Feasibility on nRF9151

Priyesh Shahi — Wed, 07 Jan 2026 12:20:51 GMT

Hi Benjamin,

Thanks for the info.

Quick question:

Can we connect to a CoAP server over NTN like we do on cellular, or is NTN only for location updates?
Is custom payload upload supported beyond basic asset tracking?

Regards ,
Priyesh

RE: NTN Support and Application Feasibility on nRF9151

Benjamin — Tue, 30 Dec 2025 11:05:59 GMT

Hi Priyesh,
To fill out some more information not already answered by Achim:

[quote user=""]Which nRF Connect SDK versions include sample applications or support for NTN on nRF9151?[/quote]

The NCS version you need is v3.2.0.

We recommend starting with either of this two options:

The Serial Modem Application (modem only apporach, AT commands)
Asset Tracker Template configured for satellite connectivity.

Note: To ensure NTN support is correctly implemented, please refer to our dedicated NTN use case doc and NTN and TN use case doc, as the standard template is not configured for NTN by default.

[quote user=""]If official samples are not yet available, is there a roadmap or expected timeline for when they might be provided?[/quote]

Please reach out to the regional sales manager for your area as we cannot talk about roadmap on DevZone.

[quote user=""]What type of antenna is required or recommended for NTN operation on the nRF9151?[/quote]

We recommend reaching out to our antenna solution partners. They are equipped to provide detailed guidance on the most suitable antenna for your specific application.

NTN NB-IoT require optimal link conditions, and the choice of antenna depends on multiple factors, including whether the application supports both LTE and NTN or NTN alone, as well as the physical constraints of the product.

For applications targeting both LTE and NTN, it is essential to select a wideband antenna that can meet the performance and form factor requirements of both technologies. The antenna must support a broad frequency range to satisfy the performance criteria of LTE networks and the relevant satellite operators.

The nRF9151 SMA DK includes Taoglas (LTE/NTN/NR+) and Kyocera (GNSS) antennas.

[quote user=""]If not, could you please advise on the current status and roadmap for NTN support on nRF9151?[/quote]

The alpha version of the NTN modem FW is now public and can be downloaded here. This firmware is only for nRF9151 LACA A1 SiP.

Regards,
Benjamin

RE: NTN Support and Application Feasibility on nRF9151

Achim Kraus — Fri, 26 Dec 2025 08:34:47 GMT

I checked NCS 3.2.1 for NTN support and it's now there, see xsystemmode.

RE: NTN Support and Application Feasibility on nRF9151

Achim Kraus — Tue, 23 Dec 2025 07:54:00 GMT

Though I'm an other user, that's just my experience:

AFAIK, there is still no NCS support, but to add that (extend some link control function with new values), was on my side a work of two afternoons. The new AT-cmds and/or parameter and/or parameter-values are documented.

You will need a SIM card, that supports some NTN provider, and considering that, you may also check and consider the (much) higher costs.

I use CoAP/DTLS 1.2 CID over NTN (own device DTLS stack (Eclipse/tinydtls) to relax the timing (timeout to 30s), Eclipse/Californium (also with relaxed timing). Depending on antenna, boards and what ever, it works, but sometimes the modem requires a couple of retransmissions (not sure, if the messages are lost before they billed or after ;-) ). The overhead of IP/UDP/DTLS 1.2 CID/CoAP is about 100 extra bytes. If you want to use an ACK or CoAP response, you will need a second 100 bytes for that message. Using tinydtls allows you also to offload the dtls session from the socket, so that works pretty well to have an "handshake on TN" and the switch to "NTN". If that's a good idea depends on your usage. Statically located without TN requires to do some handshakes over NTN, with DTLS 1.2 CID, they are rare.

I run that now since September. with an send interval of 9h.

Alternatively you may use a VPN from your provider to your server or maybe OSCORE, if you have a implementation for that.

Hope that gives you a first impression.