add hex format

Signed-off-by: Juha Ylinen <juha.ylinen@nordicsemi.no>

Author: juhaylinen

app/src/sm_at_coap.c

@@ -93,6 +93,7 @@ struct coap_request {
 	 * each subsequent block request to the host's pull rate.
 	 */
 	bool manual_rx;                 /* true: manual pull mode enabled */
+	bool hex_rx;                    /* true: deliver response payload as ASCII hex string */
 	uint8_t *rx_buf;                /* Block-sized buffer (CONFIG_COAP_CLIENT_BLOCK_SIZE) */
 	size_t rx_buf_filled;           /* Bytes currently in rx_buf[] */
 	struct k_sem rx_consumed;       /* Given by AT#XCOAPCDATA; taken by coap_callback */
@@ -144,6 +145,21 @@ static void coap_send_status(struct coap_request *req)
 		    (int)req->bytes_sent);
 }
 
+static void coap_data_send_hex(struct modem_pipe *pipe, const uint8_t *buf, size_t len)
+{
+	char hex_buf[257];
+	size_t chunk = (sizeof(hex_buf) - 1) / 2;
+	size_t done = 0;
+
+	while (done < len) {
+		size_t n = MIN(chunk, len - done);
+		size_t sz = bin2hex(buf + done, n, hex_buf, sizeof(hex_buf));
+
+		data_send(pipe, hex_buf, sz);
+		done += n;
+	}
+}
+
 static void coap_send_data(struct coap_request *req, const uint8_t *payload, size_t payload_len)
 {
 	if (!payload || payload_len == 0) {
@@ -153,7 +169,11 @@ static void coap_send_data(struct coap_request *req, const uint8_t *payload, siz
 	urc_send_to(req->pipe, "\r\n#XCOAPCDATA: %d,%d,%d\r\n", req->fd,
 		    (int)req->bytes_sent, (int)payload_len);
 	req->bytes_sent += payload_len;
-	data_send(req->pipe, payload, payload_len);
+	if (req->hex_rx) {
+		coap_data_send_hex(req->pipe, payload, payload_len);
+	} else {
+		data_send(req->pipe, payload, payload_len);
+	}
 }
 
 /* Notify host that a response block is ready to pull in manual receive mode. */
@@ -537,16 +557,16 @@ static int coap_datamode_callback(uint8_t op, const uint8_t *data, int len, uint
 }
 
 /**
- * AT#XCOAPCREQ=<handle>,<path>,<method>[,<auto_reception>[,<confirmable>
- *               [,<content_format>[,<payload_len>[,<opt_num>,<opt_val>...]]]]]
+ * AT#XCOAPCREQ=<handle>,<path>,<method>[,<auto_reception>[,<hex_format>
+ *               [,<confirmable>[,<content_format>[,<payload_len>[,<opt_num>,<opt_val>...]]]]]]
  * AT#XCOAPCREQ=?
  *
  * Send a CoAP request over the AT socket identified by <handle>.
  * The socket must already be created with AT#XSOCKET and connected with AT#XCONNECT.
  * Returns OK immediately; the response is delivered asynchronously.
  *
  * Auto receive mode (auto_reception=1, default):
- *   #XCOAPCDATA: <handle>,<received_bytes>,<len>\r\n<raw bytes>
+ *   #XCOAPCDATA: <handle>,<received_bytes>,<len>\r\n<raw bytes or hex string>
  *   #XCOAPCSTAT: <handle>,<status>,<total_bytes>
  *
  * Manual receive mode (auto_reception=0):
@@ -558,20 +578,21 @@ static int coap_datamode_callback(uint8_t op, const uint8_t *data, int len, uint
  * <path>:           URI path string (quoted)
  * <method>:         1=GET, 2=POST, 3=PUT, 4=DELETE, 5=FETCH, 6=PATCH, 7=iPATCH
  * <auto_reception>: 1=automatic (default), 0=manual; host pulls body via AT#XCOAPCDATA.
+ * <hex_format>:     0=binary (default), 1=hex string (each byte as two ASCII hex chars).
  * <confirmable>:    0=NON-confirmable (default), 1=CON-confirmable
  * <content_format>: CoAP content format integer (default 0 = text/plain)
  * <payload_len>:    Optional payload length in bytes; if > 0, the command returns OK
  *                   and the device enters data mode to receive the raw payload bytes.
  * <opt_num>:        CoAP option number (decimal integer, e.g. 35 for Proxy-Uri).
  *                   Must be followed by <opt_val>. Zero or more pairs may be appended.
- * <opt_val>:        Option value (quoted string). Decoded as hex bytes when the string
- *                   is non-empty, even-length, and all hex digits (e.g. "3c" -> 0x3c);
+ * <opt_val>:        Option value (quoted string). A value prefixed with "0x" or "0X"
+ *                   is decoded as raw hex bytes (e.g. "0x3c" -> 0x3c);
  *                   otherwise used verbatim as a UTF-8 string.
  *
  * Examples:
  *   AT#XCOAPCREQ=0,"/path",1
- *   AT#XCOAPCREQ=0,"proxy",1,1,1,0,0,35,"https://host/path"
- *   AT#XCOAPCREQ=0,"/obs",1,1,1,0,0,6,"00",17,"3c"
+ *   AT#XCOAPCREQ=0,"proxy",1,1,0,1,0,0,35,"https://host/path"
+ *   AT#XCOAPCREQ=0,"/obs",1,1,0,1,0,0,6,"0x00",17,"0x3c"
  */
 SM_AT_CMD_CUSTOM(xcoapreq, "AT#XCOAPCREQ", handle_at_coap_req);
 STATIC int handle_at_coap_req(enum at_parser_cmd_type cmd_type, struct at_parser *parser,
@@ -586,6 +607,7 @@ STATIC int handle_at_coap_req(enum at_parser_cmd_type cmd_type, struct at_parser
 		const char *path;
 		size_t path_len;
 		int auto_reception = 1;
+		int hex_format = 0;
 		int confirmable = 0;
 		int content_format = COAP_CONTENT_FORMAT_TEXT_PLAIN;
 		int payload_len = 0;
@@ -635,25 +657,36 @@ STATIC int handle_at_coap_req(enum at_parser_cmd_type cmd_type, struct at_parser
 		}
 
 		if (param_count > 5) {
-			ret = at_parser_num_get(parser, 5, &confirmable);
+			ret = at_parser_num_get(parser, 5, &hex_format);
 			if (ret) {
 				return ret;
 			}
-			if (confirmable != 0 && confirmable != 1) {
-				LOG_ERR("Invalid confirmable value: %d", confirmable);
+			if (hex_format != 0 && hex_format != 1) {
+				LOG_ERR("Invalid hex_format value: %d", hex_format);
 				return -EINVAL;
 			}
 		}
 
 		if (param_count > 6) {
-			ret = at_parser_num_get(parser, 6, &content_format);
+			ret = at_parser_num_get(parser, 6, &confirmable);
 			if (ret) {
 				return ret;
 			}
+			if (confirmable != 0 && confirmable != 1) {
+				LOG_ERR("Invalid confirmable value: %d", confirmable);
+				return -EINVAL;
+			}
 		}
 
 		if (param_count > 7) {
-			ret = at_parser_num_get(parser, 7, &payload_len);
+			ret = at_parser_num_get(parser, 7, &content_format);
+			if (ret) {
+				return ret;
+			}
+		}
+
+		if (param_count > 8) {
+			ret = at_parser_num_get(parser, 8, &payload_len);
 			if (ret) {
 				return ret;
 			}
@@ -677,6 +710,7 @@ STATIC int handle_at_coap_req(enum at_parser_cmd_type cmd_type, struct at_parser
 		memcpy(req->path, path, path_len);
 		req->path[path_len] = '\0';
 		req->manual_rx = !auto_reception;
+		req->hex_rx = (bool)hex_format;
 
 		if (req->manual_rx) {
 			req->rx_buf = malloc(CONFIG_COAP_CLIENT_BLOCK_SIZE);
@@ -686,21 +720,25 @@ STATIC int handle_at_coap_req(enum at_parser_cmd_type cmd_type, struct at_parser
 			}
 		}
 
-		/* Parse option pairs (<opt_num>, <opt_val>) starting at param 8.
-		 * <opt_val> is decoded as hex bytes when it is a non-empty, even-length
-		 * all-hex-digits string; otherwise it is used verbatim as a UTF-8 string.
+		/* Parse option pairs (<opt_num>, <opt_val>) starting at param 9.
+		 * Param 8 is <payload_len>; it must be present (explicitly 0) when options
+		 * follow.  Omitting <payload_len> shifts every option one position left, which
+		 * always produces an odd option-param count and is caught below.
+		 *
+		 * <opt_val> is decoded as raw bytes when prefixed with "0x"/"0X"
+		 * (e.g. "0x3c" → 1 byte 0x3c); otherwise used verbatim as a UTF-8 string.
 		 * Examples:
-		 *   ...,35,"https://host/path"  → Proxy-Uri (option 35, text value)
-		 *   ...,17,"3c"                 → Accept: application/cbor (1 byte 0x3c)
-		 *   ...,6,"00",17,"3c"          → Observe + Accept
+		 *   ...,0,0,35,"coap://host/path"   payload_len=0, Proxy-Uri (text)
+		 *   ...,0,0,17,"0x3c"               payload_len=0, Accept: application/cbor
+		 *   ...,0,0,6,"0x00",17,"0x3c"      payload_len=0, Observe + Accept
 		 */
-		if (param_count > 8 && ((param_count - 8) & 1U)) {
-			LOG_ERR("Odd number of option params; each opt_num must be paired "
-				"with an opt_val");
+		if (param_count > 9 && ((param_count - 9) & 1U)) {
+			LOG_ERR("Odd number of option params after payload_len "
+				"(missing payload_len=0 before options, or unpaired opt_num/opt_val)");
 			ret = -EINVAL;
 			goto cleanup_req;
 		}
-		for (uint32_t i = 8; (i + 1) < param_count; i += 2) {
+		for (uint32_t i = 9; (i + 1) < param_count; i += 2) {
 			const char *val_str;
 			size_t val_len;
 			size_t decoded_len;
@@ -773,8 +811,8 @@ STATIC int handle_at_coap_req(enum at_parser_cmd_type cmd_type, struct at_parser
 
 	case AT_PARSER_CMD_TYPE_TEST:
 		rsp_send("\r\n#XCOAPCREQ: <handle>,<path>,<method>"
-			 "[,<auto_reception>[,<confirmable>[,<content_format>"
-			 "[,<payload_len>[,<opt_num>,<opt_val>...]]]]]\r\n");
+			 "[,<auto_reception>[,<hex_format>[,<confirmable>[,<content_format>"
+			 "[,<payload_len>[,<opt_num>,<opt_val>...]]]]]]]\r\n");
 		ret = 0;
 		break;
 
@@ -923,7 +961,11 @@ STATIC int handle_at_coap_data(enum at_parser_cmd_type cmd_type, struct at_parse
 		rsp_send("\r\n#XCOAPCDATA: %d,%d,%d\r\n", handle, (int)req->bytes_sent,
 			 (int)send_len);
 		req->bytes_sent += send_len;
-		data_send(req->pipe, req->rx_buf, send_len);
+		if (req->hex_rx) {
+			coap_data_send_hex(req->pipe, req->rx_buf, send_len);
+		} else {
+			data_send(req->pipe, req->rx_buf, send_len);
+		}
 		req->rx_buf_filled -= send_len;
 
 		if (req->rx_buf_filled > 0) {

doc/app/at_coap.rst

@@ -38,7 +38,7 @@ Syntax
 
 ::
 
-   AT#XCOAPCREQ=<handle>,<path>,<method>[,<auto_reception>[,<confirmable>[,<content_format>[,<payload_len>[,<opt_num_1>,<opt_val_1>[,<opt_num_2>,<opt_val_2>[...]]]]]]]
+   AT#XCOAPCREQ=<handle>,<path>,<method>[,<auto_reception>[,<hex_format>[,<confirmable>[,<content_format>[,<payload_len>[,<opt_num_1>,<opt_val_1>[,<opt_num_2>,<opt_val_2>[...]]]]]]]]
 
 * The ``<handle>`` parameter is an integer.
   It identifies the connected socket handle returned by ``AT#XSOCKET`` and connected by ``AT#XCONNECT``.
@@ -66,6 +66,18 @@ Syntax
     The firmware buffers each response block and emits ``#XCOAPCHEAD``.
     The host must then retrieve the block using ``AT#XCOAPCDATA``.
 
+* The ``<hex_format>`` parameter is an optional integer.
+  It controls the encoding used to deliver response payload bytes to the host.
+  It can accept the following values:
+
+  * ``0`` - Binary (default).
+    Response payload bytes are forwarded to the host as raw binary.
+  * ``1`` - Hex string.
+    Response payload bytes are encoded as a lower-case ASCII hex string before delivery.
+    Each raw byte becomes two hex characters.
+    The ``<length>`` field in ``#XCOAPCDATA`` URCs and responses always reports the raw byte count.
+    The actual data transmitted to the host is ``2×<length>`` ASCII hex characters.
+
 * The ``<confirmable>`` parameter is an optional integer.
   It can accept the following values:
 
@@ -82,8 +94,15 @@ Syntax
   * ``60`` - application/cbor.
 
 * The ``<payload_len>`` parameter is an optional integer.
-  When ``0`` or omitted, no request payload is sent and the command returns ``OK`` immediately.
+  When ``0`` or omitted and no option pairs follow, no request payload is sent and the command returns ``OK`` immediately.
   A positive integer specifies the total payload length in bytes; the command then returns ``OK`` and enters data mode.
+
+  .. note::
+
+     When option pairs follow, ``<payload_len>`` must be written explicitly.
+     Use ``0`` if no payload is needed.
+     Omitting it shifts the option pairs one position left, which always causes the command to return ``ERROR``.
+
   The host must send exactly this many bytes as the request payload.
   Data mode exits and ``#XDATAMODE: 0`` is reported when all bytes have been consumed.
   Data mode is the only mechanism for supplying the payload — there is no inline parameter alternative.
@@ -98,6 +117,7 @@ Syntax
     Each subsequent block is sent as more data arrives, so the server exchange runs concurrently with the host's serial upload.
 
 * The ``<opt_num_X>,<opt_val_X>`` parameters are optional CoAP option pairs.
+  When present, ``<payload_len>`` must also be present as the positional separator before the first pair.
   ``<opt_num_X>`` is a decimal integer option number.
   ``<opt_val_X>`` is a quoted string.
   A value prefixed with ``0x`` or ``0X`` is decoded as raw hex bytes (for example ``"0x3c"`` → byte ``0x3c``).
@@ -127,14 +147,17 @@ Unsolicited notification
 
    #XCOAPCDATA: <handle>,<offset>,<length>
 
-The notification line is terminated with ``\r\n`` and the raw response bytes follow immediately with no additional separator.
+The notification line is terminated with ``\r\n`` and the response data follows immediately with no additional separator.
+In binary mode (default), the data is ``<length>`` raw bytes.
+In hex mode (``<hex_format>=1``), the data is ``2×<length>`` lower-case ASCII hex characters.
 
 * The ``<handle>`` parameter is an integer.
   It identifies the socket.
 * The ``<offset>`` parameter is an integer.
   It contains the number of response bytes already delivered before this block.
 * The ``<length>`` parameter is an integer.
-  It contains the number of response bytes in this block.
+  It contains the raw byte count of the response data in this block.
+  In hex mode (``<hex_format>=1``), the payload following the header line is ``2×<length>`` ASCII hex characters.
 
 ``#XCOAPCHEAD`` is emitted in manual mode for each received response block.
 
@@ -147,7 +170,8 @@ The notification line is terminated with ``\r\n`` and the raw response bytes fol
 * The ``<code>`` parameter is an integer.
   It contains the CoAP response code for this block.
 * The ``<block_len>`` parameter is an integer.
-  It contains the number of bytes in the buffered block.
+  It contains the raw byte count of the buffered block.
+  In hex mode (``<hex_format>=1``), ``AT#XCOAPCDATA`` will deliver ``2×<block_len>`` ASCII hex characters.
   The host must call ``AT#XCOAPCDATA`` to retrieve this block before the next one arrives.
 
 ``#XCOAPCSTAT`` is emitted when the request completes, fails, or is cancelled
@@ -163,7 +187,8 @@ The notification line is terminated with ``\r\n`` and the raw response bytes fol
   CoAP response codes are encoded as ``(class << 5) | detail``.
   For example, ``2.05 Content`` is encoded as ``69`` and ``2.04 Changed`` as ``68``.
 * The ``<total_bytes>`` parameter is an integer.
-  It contains the total number of response payload bytes delivered to the host.
+  It contains the total number of raw response payload bytes received.
+  In hex mode (``<hex_format>=1``), this is the raw byte count, not the number of hex characters delivered.
 
 .. note::
 
@@ -174,7 +199,7 @@ The notification line is terminated with ``\r\n`` and the raw response bytes fol
 Examples
 ~~~~~~~~
 
-CoAP GET (automatic mode):
+CoAP GET (automatic mode, binary):
 
 ::
 
@@ -197,6 +222,18 @@ CoAP GET (automatic mode):
    AT#XCLOSE=0
    OK
 
+CoAP GET (automatic mode, hex-encoded response, ``hex_format=1``):
+
+::
+
+   AT#XCOAPCREQ=0,"/sensors/temperature",1,1,1
+   OK
+
+   #XCOAPCDATA: 0,0,12
+   32332e352043656c73697573
+
+   #XCOAPCSTAT: 0,69,12
+
 CoAP GET (manual mode):
 
 ::
@@ -217,7 +254,7 @@ CoAP POST with JSON payload (``content_format=50`` = ``application/json``):
 
 ::
 
-   AT#XCOAPCREQ=0,"/data",2,1,0,50,13
+   AT#XCOAPCREQ=0,"/data",2,1,0,0,50,13
    OK
    {"value": 42}
    #XDATAMODE: 0
@@ -228,7 +265,7 @@ CoAP GET via proxy with Proxy-Uri option (option 35, value is a plain URI string
 
 ::
 
-   AT#XCOAPCREQ=0,"proxy",1,1,0,0,0,35,"coap://remote-host/resource"
+   AT#XCOAPCREQ=0,"proxy",1,1,0,0,0,0,35,"coap://remote-host/resource"
    OK
 
    #XCOAPCDATA: 0,0,128
@@ -240,7 +277,7 @@ CoAP GET with Observe and Accept options (option 6 = Observe register ``"0x00"``
 
 ::
 
-   AT#XCOAPCREQ=0,"/obs",1,1,1,0,0,6,"0x00",17,"0x3c"
+   AT#XCOAPCREQ=0,"/obs",1,1,0,1,0,0,6,"0x00",17,"0x3c"
    OK
 
    #XCOAPCDATA: 0,0,18
@@ -265,15 +302,15 @@ Response syntax
 
 ::
 
-   #XCOAPCREQ: <handle>,<path>,<method>[,<auto_reception>[,<confirmable>[,<content_format>[,<payload_len>[,<opt_num>,<opt_val>...]]]]]]
+   #XCOAPCREQ: <handle>,<path>,<method>[,<auto_reception>[,<hex_format>[,<confirmable>[,<content_format>[,<payload_len>[,<opt_num>,<opt_val>...]]]]]]
 
 Example
 ~~~~~~~
 
 ::
 
    AT#XCOAPCREQ=?
-   #XCOAPCREQ: <handle>,<path>,<method>[,<auto_reception>[,<confirmable>[,<content_format>[,<payload_len>[,<opt_num>,<opt_val>...]]]]]]
+   #XCOAPCREQ: <handle>,<path>,<method>[,<auto_reception>[,<hex_format>[,<confirmable>[,<content_format>[,<payload_len>[,<opt_num>,<opt_val>...]]]]]]
    OK
 
 CoAP data pull #XCOAPCDATA
@@ -308,9 +345,12 @@ When a block is available
 ::
 
    #XCOAPCDATA: <handle>,<offset>,<length>
-   <length bytes of raw response data>
+   <data>
    OK
 
+In binary mode (default), ``<data>`` is ``<length>`` raw bytes.
+In hex mode (``<hex_format>=1``), ``<data>`` is ``2×<length>`` lower-case ASCII hex characters.
+
 The ``#XCOAPCDATA:`` line is terminated with ``\r\n``.
 ``<length>`` raw response bytes follow immediately with no additional separator.
 ``OK`` follows on its own line after the response bytes.