https://devzone.nordicsemi.com/f/nordic-q-a/87116/apply-the-heartbeat-publication-and-subscription-to-serial-interface-of-nrf5-sdk-for-meshIn our cases, Serial interface needs to support Heartbeat of Configuration Server. But configuration server&#39;s heartbeat handler is not support serial interface and serial interface has no method using heartbeat server. Therefore, I made it possibleen-USTelligent Community 13Wed, 20 Apr 2022 07:08:35 GMThttps://devzone.nordicsemi.com/thread/363758?ContentTypeID=1Wed, 20 Apr 2022 07:08:35 GMT137ad170-7792-4731-bb38-c0d22fbe4515:c233da8c-ab7f-46e4-9a9b-a580b95cdee8TOT0Ro<p>The post has some problem of code format, so uploaded again.</p> <p></p> <p><pre class="ui-code" data-mode="text">diff --git a/nrf5_SDK_for_Mesh_v5.0.0_src/scripts/interactive_pyaci/aci/aci_cmd.py b/nrf5_SDK_for_Mesh_v5.0.0_src/scripts/interactive_pyaci/aci/aci_cmd.py index f7f92f3b..8fa50048 100644 --- a/nrf5_SDK_for_Mesh_v5.0.0_src/scripts/interactive_pyaci/aci/aci_cmd.py +++ b/nrf5_SDK_for_Mesh_v5.0.0_src/scripts/interactive_pyaci/aci/aci_cmd.py @@ -968,6 +968,70 @@ class NetStateGet(CommandPacket): __data = bytearray() super(NetStateGet, self).__init__(0xAF, __data) +class HBPublicationGet(CommandPacket): + &quot;&quot;&quot;Gets the Heartbeat Publication state&quot;&quot;&quot; + def __init__(self): + __data = bytearray() + super(HBPublicationGet, self).__init__(0xB0, __data) + +class HBPublicationSet(CommandPacket): + &quot;&quot;&quot;Sets the Heartbeat Publication state + + Parameters + ---------- + dst : uint16_t + The destination to send heartbeat messages. + count : uint32_t + How many messages to send. + period : uint32_t + What interval to send messages. + ttl : uint8_t + Initial TTL. + features : uint16_t + The features that trigger sending messages when changed. + netkey_index : uint16_t + The global NetKey Index of the Netkey used to send. + + Return + ------ + NRF_ERROR_INVALID_DATA : + Invalid netkey_index. + Check that A netkey is added corresponding the netkey_index in device + &quot;&quot;&quot; + def __init__(self, dst, count, period, ttl, features, netkey_index): + __data = bytearray() + __data += struct.pack(&quot;&lt;H&quot;, dst) + __data += struct.pack(&quot;&lt;I&quot;, count) + __data += struct.pack(&quot;&lt;I&quot;, period) + __data += struct.pack(&quot;&lt;B&quot;, ttl) + __data += struct.pack(&quot;&lt;H&quot;, features) + __data += struct.pack(&quot;&lt;H&quot;, netkey_index) + super(HBPublicationSet, self).__init__(0xB1, __data) + +class HBSubscriptionGet(CommandPacket): + &quot;&quot;&quot;Gets the Heartbeat Subscription state&quot;&quot;&quot; + def __init__(self): + __data = bytearray() + super(HBSubscriptionGet, self).__init__(0xB2, __data) + +class HBSubscriptionSet(CommandPacket): + &quot;&quot;&quot;Sets the Heartbeat Subscription state + + Parameters + ---------- + src : uint16_t + The unicast source address for messages a node shall process. + dst : uint16_t + The destination to send heartbeat messages. + period : uint32_t + The number of seconds left for processing messages. + &quot;&quot;&quot; + def __init__(self, src, dst, period): + __data = bytearray() + __data += struct.pack(&quot;&lt;H&quot;, src) + __data += struct.pack(&quot;&lt;H&quot;, dst) + __data += struct.pack(&quot;&lt;I&quot;, period) + super(HBSubscriptionSet, self).__init__(0xB3, __data) class JumpToBootloader(CommandPacket): &quot;&quot;&quot;Immediately jump to bootloader mode.&quot;&quot;&quot; @@ -1740,6 +1804,29 @@ class NetStateGetRsp(ResponsePacket): __data[&quot;next_seqnum_block&quot;], = struct.unpack(&quot;&lt;I&quot;, raw_data[7:11]) super(NetStateGetRsp, self).__init__(&quot;NetStateGet&quot;, 0xAF, __data) +class HBPublicationGetRsp(ResponsePacket): + &quot;&quot;&quot;Response to a(n) HBPublicationGet command.&quot;&quot;&quot; + def __init__(self, raw_data): + __data = {} + __data[&quot;dst&quot;], = struct.unpack(&quot;&lt;H&quot;, raw_data[0:2]) + __data[&quot;count_log&quot;], = struct.unpack(&quot;&lt;B&quot;, raw_data[2:3]) + __data[&quot;period_log&quot;], = struct.unpack(&quot;&lt;B&quot;, raw_data[3:4]) + __data[&quot;ttl&quot;], = struct.unpack(&quot;&lt;B&quot;, raw_data[4:5]) + __data[&quot;features&quot;], = struct.unpack(&quot;&lt;H&quot;, raw_data[5:7]) + __data[&quot;netkey_index&quot;], = struct.unpack(&quot;&lt;H&quot;, raw_data[7:9]) + super(HBPublicationGetRsp, self).__init__(&quot;HBPublicationGet&quot;, 0xB0, __data) + +class HBSubscriptionGetRsp(ResponsePacket): + &quot;&quot;&quot;Response to a(n) HBSubscriptionGet command.&quot;&quot;&quot; + def __init__(self, raw_data): + __data = {} + __data[&quot;src&quot;], = struct.unpack(&quot;&lt;H&quot;, raw_data[0:2]) + __data[&quot;dst&quot;], = struct.unpack(&quot;&lt;H&quot;, raw_data[2:4]) + __data[&quot;period_log&quot;], = struct.unpack(&quot;&lt;B&quot;, raw_data[4:5]) + __data[&quot;count_log&quot;], = struct.unpack(&quot;&lt;B&quot;, raw_data[5:6]) + __data[&quot;min_hops&quot;], = struct.unpack(&quot;&lt;B&quot;, raw_data[6:7]) + __data[&quot;max_hops&quot;], = struct.unpack(&quot;&lt;B&quot;, raw_data[7:8]) + super(HBSubscriptionGetRsp, self).__init__(&quot;HBSubscriptionGet&quot;, 0xB2, __data) class BankInfoGetRsp(ResponsePacket): &quot;&quot;&quot;Response to a(n) BankInfoGet command.&quot;&quot;&quot; @@ -1930,6 +2017,8 @@ RESPONSE_LUT = { 0xA6: {&quot;object&quot;: AddrPublicationRemoveRsp, &quot;name&quot;: &quot;AddrPublicationRemove&quot;}, 0xAB: {&quot;object&quot;: PacketSendRsp, &quot;name&quot;: &quot;PacketSend&quot;}, 0xAF: {&quot;object&quot;: NetStateGetRsp, &quot;name&quot;: &quot;NetStateGet&quot;}, + 0xB0: {&quot;object&quot;: HBPublicationGetRsp, &quot;name&quot;: &quot;HBPublicationGet&quot;}, + 0xB2: {&quot;object&quot;: HBSubscriptionGetRsp, &quot;name&quot;: &quot;HBSubscriptionGet&quot;}, 0xD4: {&quot;object&quot;: BankInfoGetRsp, &quot;name&quot;: &quot;BankInfoGet&quot;}, 0xD6: {&quot;object&quot;: StateGetRsp, &quot;name&quot;: &quot;StateGet&quot;}, 0xE1: {&quot;object&quot;: ModelPubAddrGetRsp, &quot;name&quot;: &quot;ModelPubAddrGet&quot;}, diff --git a/nrf5_SDK_for_Mesh_v5.0.0_src/mesh/serial/include/serial_cmd.h b/nrf5_SDK_for_Mesh_v5.0.0_src/mesh/serial/include/serial_cmd.h index 11c94a6f..1118e6fc 100644 --- a/nrf5_SDK_for_Mesh_v5.0.0_src/mesh/serial/include/serial_cmd.h +++ b/nrf5_SDK_for_Mesh_v5.0.0_src/mesh/serial/include/serial_cmd.h @@ -155,6 +155,10 @@ #define SERIAL_OPCODE_CMD_MESH_CONFIG_SERVER_BIND (0xAD) /**&lt; Params: @ref serial_cmd_mesh_config_server_devkey_bind_t */ #define SERIAL_OPCODE_CMD_MESH_NET_STATE_SET (0xAE) /**&lt; Params: @ref serial_cmd_mesh_net_state_set_t */ #define SERIAL_OPCODE_CMD_MESH_NET_STATE_GET (0xAF) /**&lt; Params: None. */ +#define SERIAL_OPCODE_CMD_MESH_HB_PUBLICATION_GET (0xB0) /**&lt; Params: None. */ +#define SERIAL_OPCODE_CMD_MESH_HB_PUBLICATION_SET (0xB1) /**&lt; Params: @ref serial_cmd_mesh_hb_publication_set_t */ +#define SERIAL_OPCODE_CMD_MESH_HB_SUBSCRIPTION_GET (0xB2) /**&lt; Params: None. */ +#define SERIAL_OPCODE_CMD_MESH_HB_SUBSCRIPTION_SET (0xB3) /**&lt; Params: @ref serial_cmd_mesh_hb_subscription_set_t */ #define SERIAL_OPCODE_CMD_RANGE_MESH_END (0xBF) /**&lt; MESH range end. */ #define SERIAL_OPCODE_CMD_RANGE_DFU_START (0xD0) /**&lt; DFU range start. */ @@ -518,6 +522,25 @@ typedef struct __attribute((packed)) uint32_t next_seqnum_block; /**&lt; The first sequence number block which is not yet allocated. */ } serial_cmd_mesh_net_state_set_t; +/** Heartbeat publication set command parameters */ +typedef struct __attribute((packed)) +{ + uint16_t dst; /**&lt; The destination to send heartbeat messages.*/ + uint32_t count; /**&lt; How many messages to send.*/ + uint32_t period; /**&lt; What interval to send messages.*/ + uint8_t ttl; /**&lt; Initial TTL.*/ + uint16_t features; /**&lt; The features that trigger sending messages when changed.*/ + uint16_t netkey_index; /**&lt; The global NetKey Index of the Netkey used to send.*/ +} serial_cmd_mesh_hb_publication_set_t; + +/** Heartbeat subscription set command parameters */ +typedef struct __attribute((packed)) +{ + uint16_t src; /**&lt; The unicast source address for messages a node shall process.*/ + uint16_t dst; /**&lt; The destination to receive heartbeat messages.*/ + uint32_t period; /**&lt; The number of seconds left for processing messages.*/ +} serial_cmd_mesh_hb_subscription_set_t; + /** Mesh command parameters. */ typedef union __attribute((packed)) { @@ -549,6 +572,8 @@ typedef union __attribute((packed)) serial_cmd_mesh_packet_send_t packet_send; /**&lt; Packet send parameters. */ serial_cmd_mesh_config_server_devkey_bind_t config_server_devkey_bind; /**&lt; Configuration Server: device key bind parameters. */ serial_cmd_mesh_net_state_set_t net_state_set; /**&lt; Net state set parameters */ + serial_cmd_mesh_hb_publication_set_t hb_publication_set; /**&lt; Heartbeat Publication set parameters */ + serial_cmd_mesh_hb_subscription_set_t hb_subscription_set; /**&lt; Heartbeat Subscription set parameters */ } serial_cmd_mesh_t; /* **** PB-MESH Client **** */ diff --git a/nrf5_SDK_for_Mesh_v5.0.0_src/mesh/serial/include/serial_cmd_rsp.h b/nrf5_SDK_for_Mesh_v5.0.0_src/mesh/serial/include/serial_cmd_rsp.h index 00f4d45b..f1733aa7 100644 --- a/nrf5_SDK_for_Mesh_v5.0.0_src/mesh/serial/include/serial_cmd_rsp.h +++ b/nrf5_SDK_for_Mesh_v5.0.0_src/mesh/serial/include/serial_cmd_rsp.h @@ -309,6 +309,28 @@ typedef struct __attribute((packed)) uint32_t next_seqnum_block; /**&lt; The start of the next unused sequence number block. */ } serial_evt_cmd_rsp_data_net_state_get_t; +/** Command response to @ref SERIAL_OPCODE_CMD_MESH_HB_PUBLICATION_GET with the current heartbeat publication state */ +typedef struct __attribute((packed)) +{ + uint16_t dst; /**&lt; The destination to send heartbeat messages.*/ + uint8_t count_log; /**&lt; How many messages to send.*/ + uint8_t period_log; /**&lt; What interval to send messages.*/ + uint8_t ttl; /**&lt; Initial TTL.*/ + uint16_t features; /**&lt; The features that trigger sending messages when changed.*/ + uint16_t netkey_index; /**&lt; The global NetKey Index of the Netkey used to send.*/ +} serial_evt_cmd_rsp_data_hb_publication_get_t; + +/** Command response to @ref SERIAL_OPCODE_CMD_MESH_HB_SUBSCRIPTION_GET with the current heartbeat subscription state */ +typedef struct __attribute((packed)) +{ + uint16_t src; /**&lt; The unicast source address for messages a node shall process.*/ + uint16_t dst; /**&lt; The destination to receive heartbeat messages.*/ + uint8_t period_log; /**&lt; The number of seconds left for processing messages.*/ + uint8_t count_log; /**&lt; The number of periodical messages received.*/ + uint16_t min_hops; /**&lt; The minimum hops value registered when receiving messages.*/ + uint16_t max_hops; /**&lt; The maximum hops value registered when receiving messages.*/ +} serial_evt_cmd_rsp_data_hb_subscription_get_t; + /** Command response packet. */ typedef struct __attribute((packed)) { @@ -348,7 +370,8 @@ typedef struct __attribute((packed)) serial_evt_cmd_rsp_data_model_init_t model_init; /**&lt; Reserved handle for the initialized model instance. */ serial_evt_cmd_rsp_data_packet_send_t packet_send; /**&lt; Information about the sent packet. */ serial_evt_cmd_rsp_data_net_state_get_t net_state_get; /**&lt; Net state. */ - + serial_evt_cmd_rsp_data_hb_publication_get_t hb_publication_get; /**&lt; Heartbeat Publication States. */ + serial_evt_cmd_rsp_data_hb_subscription_get_t hb_subscription_get; /**&lt; Heartbeat Subscription States. */ } data; /**&lt; Optional command response data. */ } serial_evt_cmd_rsp_t; diff --git a/nrf5_SDK_for_Mesh_v5.0.0_src/mesh/serial/src/serial_handler_mesh.c b/nrf5_SDK_for_Mesh_v5.0.0_src/mesh/serial/src/serial_handler_mesh.c index 655cdcd3..25fd52ff 100644 --- a/nrf5_SDK_for_Mesh_v5.0.0_src/mesh/serial/src/serial_handler_mesh.c +++ b/nrf5_SDK_for_Mesh_v5.0.0_src/mesh/serial/src/serial_handler_mesh.c @@ -54,6 +54,7 @@ #include &quot;mesh_opt_net_state.h&quot; #include &quot;mesh_config_entry.h&quot; #include &quot;mesh_config_listener.h&quot; +#include &quot;heartbeat.h&quot; /* Ensure that we&#39;re mapping the size of the serial parameter to the * dsm_handle_t. If this triggers, someone changed the size of the @@ -488,6 +489,143 @@ static void handle_net_state_get(const serial_packet_t * p_cmd) serial_handler_common_cmd_rsp_nodata_on_error(p_cmd-&gt;opcode, status, (uint8_t *)&amp;rsp, sizeof(rsp)); } +static inline uint8_t heartbeat_pubsub_period_encode(uint32_t period) +{ + if (period == 0) + { + return 0x00; + } + else if (period &lt;= HEARTBEAT_MAX_PERIOD) + { + return (log2_get(period) + 1); + } + else + { + NRF_MESH_ASSERT(false); + return HEARTBEAT_MAX_PERIOD_LOG; + } +} + +static inline uint8_t heartbeat_publication_count_encode(uint32_t count) +{ + if (count &lt;= 1) + { + return count; + } + else if (count &lt;= HEARTBEAT_MAX_COUNT) + { + /* Finding smallest n where 2^(n-1) is greater than or equal to the count value */ + return (log2_get(count - 1) + 1 + 1); + } + else if (count == HEARTBEAT_INF_COUNT) + { + return HEARTBEAT_INF_COUNT_LOG; + } + else + { + NRF_MESH_ASSERT(false); + return HEARTBEAT_MAX_COUNT_LOG; + } +} + +static inline uint8_t heartbeat_subscription_count_encode(uint32_t count) +{ + if (count == 0) + { + return 0x00; + } + else if (count &lt;= HEARTBEAT_MAX_COUNT) + { + /* Finding largest n where 2^(n-1) is less than or equal to the count value */ + return (log2_get(count) + 1); + } + else if (count == HEARTBEAT_INF_COUNT) + { + return HEARTBEAT_INF_COUNT_LOG; + } + else + { + NRF_MESH_ASSERT(false); + return HEARTBEAT_MAX_COUNT_LOG; + } +} + +static void handle_heartbeat_publication_get(const serial_packet_t * p_cmd) +{ + const heartbeat_publication_state_t * p_hb_pub = heartbeat_publication_get(); + serial_evt_cmd_rsp_data_hb_publication_get_t rsp = { + .dst = p_hb_pub-&gt;dst, + .count_log = heartbeat_publication_count_encode(p_hb_pub-&gt;count), + .period_log = heartbeat_pubsub_period_encode(p_hb_pub-&gt;period), + .ttl = p_hb_pub-&gt;ttl, + .features = p_hb_pub-&gt;features, + .netkey_index = p_hb_pub-&gt;netkey_index + }; + serial_cmd_rsp_send(p_cmd-&gt;opcode, SERIAL_STATUS_SUCCESS, (uint8_t *)&amp;rsp, sizeof(rsp)); +} + +static void handle_heartbeat_publication_set(const serial_packet_t * p_cmd) +{ + uint32_t status; + const heartbeat_publication_state_t hb_pub = { + .dst = p_cmd-&gt;payload.cmd.mesh.hb_publication_set.dst, + .count = p_cmd-&gt;payload.cmd.mesh.hb_publication_set.count, + .period = p_cmd-&gt;payload.cmd.mesh.hb_publication_set.period, + .ttl = p_cmd-&gt;payload.cmd.mesh.hb_publication_set.ttl, + .features = p_cmd-&gt;payload.cmd.mesh.hb_publication_set.features, + .netkey_index = p_cmd-&gt;payload.cmd.mesh.hb_publication_set.netkey_index + }; + + /* This is specifically required for INVALID_NETKEY status code */ + if (dsm_net_key_index_to_subnet_handle(p_cmd-&gt;payload.cmd.mesh.hb_publication_set.netkey_index) + == DSM_HANDLE_INVALID) + { + status = NRF_ERROR_INVALID_DATA; + } + else + { + status = heartbeat_publication_set(&amp;hb_pub); + } + serial_handler_common_cmd_rsp_nodata_on_error(p_cmd-&gt;opcode, status, NULL, 0); +} +static void handle_heartbeat_subscription_get(const serial_packet_t * p_cmd) +{ + const heartbeat_subscription_state_t * p_hb_sub = heartbeat_subscription_get(); + serial_evt_cmd_rsp_data_hb_subscription_get_t rsp; + + /* When the Heartbeat Subscription Source or Destination state is set to the unassigned address, + the value of - the Source and Destination fields of the Status message shall be set to the + unassigned address and the values of the CountLog, PeriodLog, MinHops, and MaxHops fields shall + be set to 0x00. Refer to @tagMeshSp section 4.4.1.2.16 */ + if (p_hb_sub-&gt;src == NRF_MESH_ADDR_UNASSIGNED || + p_hb_sub-&gt;dst == NRF_MESH_ADDR_UNASSIGNED) + { + memset(&amp;rsp, 0, sizeof(serial_evt_cmd_rsp_data_hb_subscription_get_t)); + } + else + { + rsp.src = p_hb_sub-&gt;src; + rsp.dst = p_hb_sub-&gt;dst; + rsp.count_log = heartbeat_subscription_count_encode(p_hb_sub-&gt;count); + rsp.period_log = heartbeat_pubsub_period_encode(p_hb_sub-&gt;period); + rsp.min_hops = p_hb_sub-&gt;min_hops; + rsp.max_hops = p_hb_sub-&gt;max_hops; + } + serial_cmd_rsp_send(p_cmd-&gt;opcode, SERIAL_STATUS_SUCCESS, (uint8_t *)&amp;rsp, sizeof(rsp)); +} +static void handle_heartbeat_subscription_set(const serial_packet_t * p_cmd) +{ + uint32_t status; + const heartbeat_subscription_state_t hb_sub = { + .src = p_cmd-&gt;payload.cmd.mesh.hb_subscription_set.src, + .dst = p_cmd-&gt;payload.cmd.mesh.hb_subscription_set.dst, + .period = p_cmd-&gt;payload.cmd.mesh.hb_subscription_set.period, + /* other state values shall remain unchanged, see @tagMeshSp section 4.4.1.2.16 */ + }; + status = heartbeat_subscription_set(&amp;hb_sub); + serial_handler_common_cmd_rsp_nodata_on_error(p_cmd-&gt;opcode, status, NULL, 0); +} + /***************************************************************************** * Static functions *****************************************************************************/ @@ -527,7 +665,11 @@ static const mesh_serial_cmd_handler_t m_handlers[] = {SERIAL_OPCODE_CMD_MESH_STATE_CLEAR, 0, 0, handle_cmd_clear}, {SERIAL_OPCODE_CMD_MESH_CONFIG_SERVER_BIND, sizeof(serial_cmd_mesh_config_server_devkey_bind_t), 0, handle_config_devkey_bind}, {SERIAL_OPCODE_CMD_MESH_NET_STATE_SET, sizeof(serial_cmd_mesh_net_state_set_t), 0, handle_net_state_set}, - {SERIAL_OPCODE_CMD_MESH_NET_STATE_GET, 0, 0, handle_net_state_get} + {SERIAL_OPCODE_CMD_MESH_NET_STATE_GET, 0, 0, handle_net_state_get}, + {SERIAL_OPCODE_CMD_MESH_HB_PUBLICATION_GET, 0, 0, handle_heartbeat_publication_get}, + {SERIAL_OPCODE_CMD_MESH_HB_PUBLICATION_SET, sizeof(serial_cmd_mesh_hb_publication_set_t), 0, handle_heartbeat_publication_set}, + {SERIAL_OPCODE_CMD_MESH_HB_SUBSCRIPTION_GET, 0, 0, handle_heartbeat_subscription_get}, + {SERIAL_OPCODE_CMD_MESH_HB_SUBSCRIPTION_SET, sizeof(serial_cmd_mesh_hb_subscription_set_t), 0, handle_heartbeat_subscription_set} }; static void mesh_config_listener_cb(mesh_config_change_reason_t reason, mesh_config_entry_id_t id, const void * p_entry) </pre></p><div style="clear:both;"></div>