I’ve been setting up an OpenThread network with multiple OT Sleepy End Devices (SEDs) that periodically transmit sensor data to an IPv4-only CoAP server. To enable communication between the OT devices and the CoAP server, I need the synthesized IPv6 address. To test DNS resolution, I first flashed an nRF54L15-DK with the ot-cli sample, configured the network settings (network key, PAN ID, channel), joined the network as an MTD, and then ran the following command:
> ot dns resolve4 <hostname>
This command returned the synthesized IPv6 address of the CoAP server, indicating that the OpenThread Border Router (OTBR)—which is based on a Raspberry Pi 4 and an nRF52840 dongle—is functioning correctly. Therefore, it appears that NAT64/DNS64 is working as expected.
Then, I used the synthesized IPv6 address to send data to the CoAP server using the code below, and I was able to verify that the data successfully arrived at the server:
#include <stdio.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/logging/log.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/sensor/sht4x.h>
#include <zephyr/net/openthread.h>
#include <openthread/coap.h>
#include <openthread/link.h>
LOG_MODULE_REGISTER(main_app, LOG_LEVEL_INF);
static const struct device* sht_dev = DEVICE_DT_GET(DT_NODELABEL(sht4x));
struct sensor_data {
float relativeHumidity;
float temperature;
};
char myPayloadJson[256] = "";
void coap_init(void) {
otInstance* p_instance = openthread_get_default_instance();
otError error = otCoapStart(p_instance, OT_DEFAULT_COAP_PORT);
if (error != OT_ERROR_NONE) {
LOG_ERR("Failed to start CoAP: %d. (line %i)\n", error, __LINE__);
}
}
static void coap_send_data_response_cb(void* p_context, otMessage* p_message, const otMessageInfo* p_message_info, otError result) {
if (result == OT_ERROR_NONE) {
LOG_INF("Delivery confirmed.\n");
} else {
LOG_WRN("Delivery not confirmed: %d\n", result);
}
}
static void coap_send_data_request(void) {
otError error = OT_ERROR_NONE;
otMessage* myMessage;
otMessageInfo myMessageInfo;
otInstance* myInstance = openthread_get_default_instance();
otIp6Address serverAddress;
otIp6AddressFromString("/*CoAP server ipv6 string here */", &serverAddress);
do {
myMessage = otCoapNewMessage(myInstance, NULL);
if (myMessage == NULL) {
LOG_ERR("Failed to allocate message for CoAP request\n");
return;
}
otCoapMessageInit(myMessage, OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_PUT);
error = otCoapMessageAppendUriPathOptions(myMessage, "put-resource");
if (error != OT_ERROR_NONE) {
break;
}
error = otCoapMessageAppendContentFormatOption(myMessage, OT_COAP_OPTION_CONTENT_FORMAT_JSON);
if (error != OT_ERROR_NONE) {
break;
}
error = otCoapMessageSetPayloadMarker(myMessage);
if (error != OT_ERROR_NONE) {
break;
}
error = otMessageAppend(myMessage, myPayloadJson, strlen(myPayloadJson));
if (error != OT_ERROR_NONE) {
break;
}
memset(&myMessageInfo, 0, sizeof(myMessageInfo));
memcpy(&myMessageInfo.mPeerAddr, &serverAddress, sizeof(serverAddress));
myMessageInfo.mPeerPort = OT_DEFAULT_COAP_PORT;
error = otCoapSendRequest(myInstance, myMessage, &myMessageInfo, coap_send_data_response_cb, NULL);
} while (false);
if (error != OT_ERROR_NONE) {
LOG_ERR("Failed to send CoAP Request: %d. (line %i)\n", error, __LINE__);
otMessageFree(myMessage);
} else {
LOG_INF("CoAP data transmitted. (line %i)\n", __LINE__);
}
}
int main(void) {
struct sensor_data data;
struct sensor_value temp, humidity;
int ret;
if (device_init(sht_dev) || !device_is_ready(sht_dev)) {
LOG_ERR("I2C device \"%s\" not found or not ready (line %i)", sht_dev->name, __LINE__);
return 0;
}
/* Init CoAP */
coap_init();
while (1) {
ret = sensor_sample_fetch(sht_dev);
if (!ret) {
sensor_channel_get(sht_dev, SENSOR_CHAN_AMBIENT_TEMP, &temp);
sensor_channel_get(sht_dev, SENSOR_CHAN_HUMIDITY, &humidity);
LOG_INF("Temp: %d.%06d C, RH: %d.%06d%%", temp.val1, temp.val2, humidity.val1, humidity.val2);
} else {
LOG_ERR("Sensor read failed: %d", ret);
}
// Create the payload to transmit via OpenThread
data.temperature = sensor_value_to_float(&temp);
data.relativeHumidity = sensor_value_to_float(&humidity);
snprintf(myPayloadJson, sizeof(myPayloadJson),
"{\"relativeHumidity\":%.1f,\"temperature\":%.1f}",
(double)data.relativeHumidity, (double)data.temperature);
if (ret >= 0) {
LOG_INF("JSON Output: %s\n", myPayloadJson);
} else {
LOG_ERR("JSON encoding failed: %d. (line %i)\n", ret, __LINE__);
}
coap_send_data_request();
/* Go Sleep */
k_sleep(K_SECONDS(10));
}
}
However, since I have multiple devices, it becomes inconvenient when the CoAP server’s IPv4 address changes. In that case, I have to manually check the new synthesized IPv6 address, hardcode it into the firmware, and re-flash all devices — which is quite tedious. To solve this, I’d like to implement a DNS query directly on the OT SED devices so they can dynamically retrieve the IPv6 address. Since the ot-cli sample is capable of performing this query, it indicates that such functionality should be possible to implement.
I inspected the ncs ot-cli sample repository but couldn’t determine which source files correspond to each CLI command, making it difficult to replicate the implementation. How does the build system for this sample work? Does it use the official Google OpenThread repository? I was able to locate the code executed for the dns resolve4 command there:
I tried implementing the DNS query using my nRF Connect SDK application (using NCS v3.1). The application builds successfully, but when I run it, I don’t receive any response. My implementation is shown below:
main.c
#include <stdint.h>
#include <stdio.h>
#include <zephyr/device.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#include <openthread/thread.h>
#include <openthread/instance.h>
#include <openthread/ip6.h>
#include <openthread/dns.h>
#include <openthread/dns_client.h>
#include <zephyr/net/openthread.h>
#define OPENTHREAD_CONFIG_DNS_CLIENT_ENABLE
#define OPENTHREAD_CONFIG_DNS_CLIENT_DEFAULT_NAT64_ENABLE
#define OPENTHREAD_CONFIG_IP6_ENABLE
LOG_MODULE_REGISTER(main_app, LOG_LEVEL_INF);
void handle_dns_response(otError aResult, const otDnsAddressResponse* aResponse, void* aContext) {
if (aResult == OT_ERROR_NONE && aResponse) {
otIp6Address address;
uint32_t ttl;
uint16_t index = 0;
// Iterate over all addresses in the response
while (otDnsAddressResponseGetAddress(aResponse, index, &address, &ttl) == OT_ERROR_NONE) {
char buf[OT_IP6_ADDRESS_STRING_SIZE];
otIp6AddressToString(&address, buf, sizeof(buf));
LOG_INF("Synthesized IPv6: %s (TTL: %" PRIu32 "). (line %i)", buf, ttl, __LINE__);
// ...
index++;
}
} else {
LOG_ERR("DNS resolution failed: %d. (line %i)", aResult, __LINE__);
}
}
void query_dns_address(otInstance* ot) {
// otDnsQueryConfig config = {0};
otError error;
const otDnsQueryConfig* queryConfig = otDnsClientGetDefaultConfig(ot);
if (queryConfig != NULL) {
char buf[OT_IP6_ADDRESS_STRING_SIZE];
otIp6AddressToString(&queryConfig->mServerSockAddr.mAddress, buf, sizeof(buf));
LOG_INF("NAT64 Server Addr: %s. (line %i)", buf, __LINE__);
} else {
LOG_WRN("No DNS query config available. (line %i)", __LINE__);
}
error = otDnsClientResolveIp4Address(ot, "time.google.com", handle_dns_response, NULL, queryConfig);
switch (error) {
case OT_ERROR_NONE:
LOG_INF("Query sent successfully. aCallback will be invoked to report the status. (line %i)", __LINE__);
break;
case OT_ERROR_NO_BUFS:
LOG_INF("Insufficient buffer to prepare and send query. (line %i)", __LINE__);
break;
case OT_ERROR_INVALID_ARGS:
LOG_INF("The host name is not valid format or NAT64 is not enabled in config. (line %i)", __LINE__);
break;
case OT_ERROR_INVALID_STATE:
LOG_INF("Cannot send query since Thread interface is not up. (line %i)", __LINE__);
break;
}
}
int main(void) {
otInstance* instance = openthread_get_default_instance();
if (instance == NULL) {
LOG_INF("Failed to get default OpenThread instance");
return -1;
}
while (1) {
for (int i = 0; i < 5000; i++) {
LOG_INF("%i", i);
/* Check OT Role */
otDeviceRole role = otThreadGetDeviceRole(openthread_get_default_instance());
switch (role) {
case OT_DEVICE_ROLE_DISABLED:
LOG_INF("The Thread stack is disabled.");
break;
case OT_DEVICE_ROLE_DETACHED:
LOG_INF("Not currently participating in a Thread network/partition.");
break;
case OT_DEVICE_ROLE_CHILD:
LOG_INF("The Thread Child role.");
break;
case OT_DEVICE_ROLE_ROUTER:
LOG_INF("The Thread Router role.");
break;
case OT_DEVICE_ROLE_LEADER:
LOG_INF("The Thread Leader role.");
break;
}
query_dns_address(instance);
k_sleep(K_SECONDS(10));
}
}
return 0;
}
prj.conf:
# STACKS CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE=2048 CONFIG_MAIN_STACK_SIZE=4096 CONFIG_CBPRINTF_FP_SUPPORT=y CONFIG_PM_DEVICE=y CONFIG_PM_DEVICE_RUNTIME=y # RTT CONFIG_USE_SEGGER_RTT=y # LOGS CONFIG_LOG=y CONFIG_LOG_BACKEND_RTT=y CONFIG_LOG_BACKEND_RTT_BUFFER=0 CONFIG_SENSOR_LOG_LEVEL_DBG=y # OpenThread (Generic) CONFIG_NETWORKING=y CONFIG_OPENTHREAD=y CONFIG_NET_IPV6=y CONFIG_NET_L2_OPENTHREAD=y CONFIG_OPENTHREAD_THREAD_VERSION_1_3=y CONFIG_OPENTHREAD_COAP=y CONFIG_OPENTHREAD_MANUAL_START=n CONFIG_OPENTHREAD_DNS_CLIENT=y CONFIG_DNS_RESOLVER=y CONFIG_OPENTHREAD_SNTP_CLIENT=y # OpenThread Sleep-End-Device CONFIG_OPENTHREAD_MTD=y #CONFIG_OPENTHREAD_MTD_SED=y #CONFIG_OPENTHREAD_POLL_PERIOD=30000 # OpenThread Network identity CONFIG_OPENTHREAD_NETWORK_NAME="my-ot" CONFIG_OPENTHREAD_CHANNEL=12 CONFIG_OPENTHREAD_PANID=43537 CONFIG_OPENTHREAD_XPANID="de:e2:27:71:01:3c:35:26" CONFIG_OPENTHREAD_NETWORKKEY="00:11:22:33:44:55:66:77:88:99:aa:bb:cc:dd:ee:ff" # Enable UDP since SNTP uses UDP CONFIG_NET_UDP=y # Enable IPv6 (Thread uses IPv6) CONFIG_NET_IPV6=y # Enable sockets if you plan to use BSD socket APIs CONFIG_NET_SOCKETS=y # Increase networking stack size (important for OpenThread apps) CONFIG_NET_TX_STACK_SIZE=2048 CONFIG_NET_RX_STACK_SIZE=2048
RTT Logs:
[00:01:20.063,012] <inf> main_app: 8 [00:01:20.063,020] <inf> main_app: The Thread Child role. [00:01:20.063,119] <inf> main_app: NAT64 Server Addr: 2001:4860:4860:0:0:0:0:8888. (line 50) [00:01:20.063,414] <inf> main_app: Query sent successfully. aCallback will be invoked to report the status. (line 59) [00:01:28.062,251] <err> main_app: DNS resolution failed: 28. (line 37) [00:01:30.063,492] <inf> main_app: 9 [00:01:30.063,501] <inf> main_app: The Thread Child role. [00:01:30.063,599] <inf> main_app: NAT64 Server Addr: 2001:4860:4860:0:0:0:0:8888. (line 50) [00:01:30.063,894] <inf> main_app: Query sent successfully. aCallback will be invoked to report the status. (line 59) [00:01:38.064,683] <err> main_app: DNS resolution failed: 28. (line 37) [00:01:40.063,971] <inf> main_app: 10 [00:01:40.063,980] <inf> main_app: The Thread Child role. [00:01:40.064,079] <inf> main_app: NAT64 Server Addr: 2001:4860:4860:0:0:0:0:8888. (line 50) [00:01:40.064,374] <inf> main_app: Query sent successfully. aCallback will be invoked to report the status. (line 59) [00:01:48.064,107] <err> main_app: DNS resolution failed: 28. (line 37) [00:01:50.064,452] <inf> main_app: 11 [00:01:50.064,460] <inf> main_app: The Thread Child role. [00:01:50.064,559] <inf> main_app: NAT64 Server Addr: 2001:4860:4860:0:0:0:0:8888. (line 50) [00:01:50.064,854] <inf> main_app: Query sent successfully. aCallback will be invoked to report the status. (line 59) [00:01:58.064,491] <err> main_app: DNS resolution failed: 28. (line 37) [00:02:00.060,795] <dbg> temp_nrf5_mpsl: temp_nrf5_mpsl_sample_fetch: sample: 119 [00:02:00.060,808] <dbg> temp_nrf5_mpsl: temp_nrf5_mpsl_channel_get: Temperature:29,750000 [00:02:00.064,929] <inf> main_app: 12 [00:02:00.064,934] <inf> main_app: The Thread Child role. [00:02:00.065,032] <inf> main_app: NAT64 Server Addr: 2001:4860:4860:0:0:0:0:8888. (line 50) [00:02:00.065,327] <inf> main_app: Query sent successfully. aCallback will be invoked to report the status. (line 59) [00:02:08.064,907] <err> main_app: DNS resolution failed: 28. (line 37)
I'm getting the hard-coded default Google DNS from the OpenThread library instead of my local DNS64 server address (e.g., fd84:...). I know the local NAT64/DNS64 is working because when I use the ot-cli sample, I get the correct synthesized IPv6 addresses.
Are there any guidelines on what I might be missing and how to generate the synthesized IPv6 address in the firmware?
