| /* |
| * Copyright (c) 2016, The OpenThread Authors. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. Neither the name of the copyright holder nor the |
| * names of its contributors may be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND |
| * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY |
| * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| /** |
| * @file |
| * This file contains definitions of spinel. |
| */ |
| |
| #ifndef SPINEL_HEADER_INCLUDED |
| #define SPINEL_HEADER_INCLUDED 1 |
| |
| /* |
| * Spinel is a host-controller protocol designed to enable |
| * inter-operation over simple serial connections between general purpose |
| * device operating systems (OS) host and network co-processors (NCP) for |
| * the purpose of controlling and managing the NCP. |
| * |
| * --------------------------------------------------------------------------- |
| * |
| * Frame Format |
| * |
| * A frame is defined simply as the concatenation of |
| * |
| * - A header byte |
| * - A command (up to three bytes) |
| * - An optional command payload |
| * |
| * +---------+--------+-----+-------------+ |
| * | Octets: | 1 | 1-3 | n | |
| * +---------+--------+-----+-------------+ |
| * | Fields: | HEADER | CMD | CMD_PAYLOAD | |
| * +---------+--------+-----+-------------+ |
| * |
| * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| * |
| * Header Format |
| * |
| * The header byte is broken down as follows: |
| * |
| * 0 1 2 3 4 5 6 7 |
| * +---+---+---+---+---+---+---+---+ |
| * | FLG | IID | TID | |
| * +---+---+---+---+---+---+---+---+ |
| * |
| * |
| * The flag field of the header byte ("FLG") is always set to the value |
| * two (or "10" in binary). Any frame received with these bits set to |
| * any other value else MUST NOT be considered a Spinel frame. |
| * |
| * This convention allows Spinel to be line compatible with BTLE HCI. |
| * By defining the first two bit in this way we can disambiguate between |
| * Spinel frames and HCI frames (which always start with either "0x01" |
| * or "0x04") without any additional framing overhead. |
| * |
| * The Interface Identifier (IID) is a number between 0 and 3, which |
| * is associated by the OS with a specific NCP. This allows the protocol |
| * to support up to 4 NCPs under same connection. |
| * |
| * The least significant bits of the header represent the Transaction |
| * Identifier (TID). The TID is used for correlating responses to the |
| * commands which generated them. |
| * |
| * When a command is sent from the host, any reply to that command sent |
| * by the NCP will use the same value for the TID. When the host |
| * receives a frame that matches the TID of the command it sent, it can |
| * easily recognize that frame as the actual response to that command. |
| * |
| * The TID value of zero (0) is used for commands to which a correlated |
| * response is not expected or needed, such as for unsolicited update |
| * commands sent to the host from the NCP. |
| * |
| * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| * |
| * The command identifier is a 21-bit unsigned integer encoded in up to |
| * three bytes using the packed unsigned integer format described below. |
| * Depending on the semantics of the command in question, a payload MAY |
| * be included in the frame. The exact composition and length of the |
| * payload is defined by the command identifier. |
| * |
| * --------------------------------------------------------------------------- |
| * |
| * Data Packing |
| * |
| * Data serialization for properties is performed using a light-weight |
| * data packing format which was loosely inspired by D-Bus. The format |
| * of a serialization is defined by a specially formatted string. |
| * |
| * This packing format is used for notational convenience. While this |
| * string-based data-type format has been designed so that the strings |
| * may be directly used by a structured data parser, such a thing is not |
| * required to implement Spinel. |
| * |
| * Goals: |
| * |
| * - Be lightweight and favor direct representation of values. |
| * - Use an easily readable and memorable format string. |
| * - Support lists and structures. |
| * - Allow properties to be appended to structures while maintaining |
| * backward compatibility. |
| * |
| * Each primitive data-type has an ASCII character associated with it. |
| * Structures can be represented as strings of these characters. For |
| * example: |
| * |
| * - "C": A single unsigned byte. |
| * - "C6U": A single unsigned byte, followed by a 128-bit IPv6 address, |
| * followed by a zero-terminated UTF8 string. |
| * - "A(6)": An array of concatenated IPv6 addresses |
| * |
| * In each case, the data is represented exactly as described. For |
| * example, an array of 10 IPv6 address is stored as 160 bytes. |
| * |
| * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| * |
| * Primitive Types |
| * |
| * +----------+----------------------+---------------------------------+ |
| * | Char | Name | Description | |
| * +----------+----------------------+---------------------------------+ |
| * | "." | DATATYPE_VOID | Empty data type. Used | |
| * | | | internally. | |
| * | "b" | DATATYPE_BOOL | Boolean value. Encoded in | |
| * | | | 8-bits as either 0x00 or 0x01. | |
| * | | | All other values are illegal. | |
| * | "C" | DATATYPE_UINT8 | Unsigned 8-bit integer. | |
| * | "c" | DATATYPE_INT8 | Signed 8-bit integer. | |
| * | "S" | DATATYPE_UINT16 | Unsigned 16-bit integer. | |
| * | "s" | DATATYPE_INT16 | Signed 16-bit integer. | |
| * | "L" | DATATYPE_UINT32 | Unsigned 32-bit integer. | |
| * | "l" | DATATYPE_INT32 | Signed 32-bit integer. | |
| * | "i" | DATATYPE_UINT_PACKED | Packed Unsigned Integer. See | |
| * | | | description below | |
| * | "6" | DATATYPE_IPv6ADDR | IPv6 Address. (Big-endian) | |
| * | "E" | DATATYPE_EUI64 | EUI-64 Address. (Big-endian) | |
| * | "e" | DATATYPE_EUI48 | EUI-48 Address. (Big-endian) | |
| * | "D" | DATATYPE_DATA | Arbitrary data. See related | |
| * | | | section below for details. | |
| * | "d" | DATATYPE_DATA_WLEN | Arbitrary data with prepended | |
| * | | | length. See below for details | |
| * | "U" | DATATYPE_UTF8 | Zero-terminated UTF8-encoded | |
| * | | | string. | |
| * | "t(...)" | DATATYPE_STRUCT | Structured datatype with | |
| * | | | prepended length. | |
| * | "A(...)" | DATATYPE_ARRAY | Array of datatypes. Compound | |
| * | | | type. | |
| * +----------+----------------------+---------------------------------+ |
| * |
| * All multi-byte values are little-endian unless explicitly stated |
| * otherwise. |
| * |
| * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| * |
| * Packed Unsigned Integer |
| * |
| * For certain types of integers, such command or property identifiers, |
| * usually have a value on the wire that is less than 127. However, in |
| * order to not preclude the use of values larger than 255, we would |
| * need to add an extra byte. Doing this would add an extra byte to the |
| * majority of instances, which can add up in terms of bandwidth. |
| * |
| * The packed unsigned integer format is based on the unsigned integer |
| * format in EXI, except that we limit the maximum value to the |
| * largest value that can be encoded into three bytes (2,097,151). |
| * |
| * For all values less than 127, the packed form of the number is simply |
| * a single byte which directly represents the number. For values |
| * larger than 127, the following process is used to encode the value: |
| * |
| * 1. The unsigned integer is broken up into _n_ 7-bit chunks and |
| * placed into _n_ octets, leaving the most significant bit of each |
| * octet unused. |
| * 2. Order the octets from least-significant to most-significant. |
| * (Little-endian) |
| * 3. Clear the most significant bit of the most significant octet. |
| * Set the least significant bit on all other octets. |
| * |
| * Where `n` is the smallest number of 7-bit chunks you can use to |
| * represent the given value. |
| * |
| * Take the value 1337, for example: |
| * |
| * 1337 => 0x0539 |
| * => [39 0A] |
| * => [B9 0A] |
| * |
| * To decode the value, you collect the 7-bit chunks until you find an |
| * octet with the most significant bit clear. |
| * |
| * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| * |
| * Data Blobs |
| * |
| * There are two types for data blobs: "d" and "D". |
| * |
| * - "d" has the length of the data (in bytes) prepended to the data |
| * (with the length encoded as type "S"). The size of the length |
| * field is not included in the length. |
| * - "D" does not have a prepended length: the length of the data is |
| * implied by the bytes remaining to be parsed. It is an error for |
| * "D" to not be the last type in a type in a type signature. |
| * |
| * This dichotomy allows for more efficient encoding by eliminating |
| * redundancy. If the rest of the buffer is a data blob, encoding the |
| * length would be redundant because we already know how many bytes are |
| * in the rest of the buffer. |
| * |
| * In some cases we use "d" even if it is the last field in a type |
| * signature. We do this to allow for us to be able to append |
| * additional fields to the type signature if necessary in the future. |
| * This is usually the case with embedded structs, like in the scan |
| * results. |
| * |
| * For example, let's say we have a buffer that is encoded with the |
| * datatype signature of "CLLD". In this case, it is pretty easy to |
| * tell where the start and end of the data blob is: the start is 9 |
| * bytes from the start of the buffer, and its length is the length of |
| * the buffer minus 9. (9 is the number of bytes taken up by a byte and |
| * two longs) |
| * |
| * The datatype signature "CLLDU" is illegal because we can't determine |
| * where the last field (a zero-terminated UTF8 string) starts. But the |
| * datatype "CLLdU" is legal, because the parser can determine the |
| * exact length of the data blob-- allowing it to know where the start |
| * of the next field would be. |
| * |
| * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| * |
| * Structured Data |
| * |
| * The structure data type ("t(...)") is a way of bundling together |
| * several fields into a single structure. It can be thought of as a |
| * "d" type except that instead of being opaque, the fields in the |
| * content are known. This is useful for things like scan results where |
| * you have substructures which are defined by different layers. |
| * |
| * For example, consider the type signature "Lt(ES)t(6C)". In this |
| * hypothetical case, the first struct is defined by the MAC layer, and |
| * the second struct is defined by the PHY layer. Because of the use of |
| * structures, we know exactly what part comes from that layer. |
| * Additionally, we can add fields to each structure without introducing |
| * backward compatability problems: Data encoded as "Lt(ESU)t(6C)" |
| * (Notice the extra "U") will decode just fine as "Lt(ES)t(6C)". |
| * Additionally, if we don't care about the MAC layer and only care |
| * about the network layer, we could parse as "Lt()t(6C)". |
| * |
| * Note that data encoded as "Lt(ES)t(6C)" will also parse as "Ldd", |
| * with the structures from both layers now being opaque data blobs. |
| * |
| * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| * |
| * Arrays |
| * |
| * An array is simply a concatenated set of _n_ data encodings. For |
| * example, the type "A(6)" is simply a list of IPv6 addresses---one |
| * after the other. The type "A(6E)" likewise a concatenation of IPv6- |
| * address/EUI-64 pairs. |
| * |
| * If an array contains many fields, the fields will often be surrounded |
| * by a structure ("t(...)"). This effectively prepends each item in |
| * the array with its length. This is useful for improving parsing |
| * performance or to allow additional fields to be added in the future |
| * in a backward compatible way. If there is a high certainty that |
| * additional fields will never be added, the struct may be omitted |
| * (saving two bytes per item). |
| * |
| * This specification does not define a way to embed an array as a field |
| * alongside other fields. |
| * |
| * --------------------------------------------------------------------------- |
| * |
| * Spinel definition guideline: |
| * |
| * New NCP firmware should work with an older host driver, i.e., NCP |
| * implementation should remain backward compatible. |
| * |
| * - Existing fields in the format of an already implemented spinel |
| * property or command cannot change. |
| * |
| * - New fields may be appended at the end of the format (or the end of |
| * a struct) as long as the NCP implementation treats the new fields as |
| * optional (i.e., a driver not aware of and therefore not using the |
| * new fields should continue to function as before). |
| * |
| * --------------------------------------------------------------------------- |
| */ |
| |
| #ifdef SPINEL_PLATFORM_HEADER |
| #include SPINEL_PLATFORM_HEADER |
| #else // ifdef SPINEL_PLATFORM_HEADER |
| #include <stdarg.h> |
| #include <stdbool.h> |
| #include <stdint.h> |
| #endif // else SPINEL_PLATFORM_HEADER |
| |
| // ---------------------------------------------------------------------------- |
| |
| #ifndef DOXYGEN_SHOULD_SKIP_THIS |
| |
| #if defined(__GNUC__) |
| #define SPINEL_API_EXTERN extern __attribute__((visibility("default"))) |
| #define SPINEL_API_NONNULL_ALL __attribute__((nonnull)) |
| #define SPINEL_API_WARN_UNUSED_RESULT __attribute__((warn_unused_result)) |
| #endif // ifdef __GNUC__ |
| |
| #endif // ifndef DOXYGEN_SHOULD_SKIP_THIS |
| |
| #ifndef SPINEL_API_EXTERN |
| #define SPINEL_API_EXTERN extern |
| #endif |
| |
| #ifndef SPINEL_API_NONNULL_ALL |
| #define SPINEL_API_NONNULL_ALL |
| #endif |
| |
| #ifndef SPINEL_API_WARN_UNUSED_RESULT |
| #define SPINEL_API_WARN_UNUSED_RESULT |
| #endif |
| |
| // ---------------------------------------------------------------------------- |
| |
| #define SPINEL_PROTOCOL_VERSION_THREAD_MAJOR 4 |
| #define SPINEL_PROTOCOL_VERSION_THREAD_MINOR 3 |
| |
| /** |
| * @def SPINEL_FRAME_MAX_SIZE |
| * |
| * The maximum size of SPINEL frame. |
| * |
| */ |
| #define SPINEL_FRAME_MAX_SIZE 1300 |
| |
| /** |
| * @def SPINEL_FRAME_MAX_COMMAND_HEADER_SIZE |
| * |
| * The maximum size of SPINEL command header. |
| * |
| */ |
| #define SPINEL_FRAME_MAX_COMMAND_HEADER_SIZE 4 |
| |
| /** |
| * @def SPINEL_FRAME_MAX_PAYLOAD_SIZE |
| * |
| * The maximum size of SPINEL command payload. |
| * |
| */ |
| #define SPINEL_FRAME_MAX_COMMAND_PAYLOAD_SIZE (SPINEL_FRAME_MAX_SIZE - SPINEL_FRAME_MAX_COMMAND_HEADER_SIZE) |
| |
| /** |
| * @def SPINEL_ENCRYPTER_EXTRA_DATA_SIZE |
| * |
| * The size of extra data to be allocated for spinel frame buffer, |
| * needed by Spinel Encrypter. |
| * |
| */ |
| #define SPINEL_ENCRYPTER_EXTRA_DATA_SIZE 0 |
| |
| /** |
| * @def SPINEL_FRAME_BUFFER_SIZE |
| * |
| * The size of buffer large enough to fit one whole spinel frame with extra data |
| * needed by Spinel Encrypter. |
| * |
| */ |
| #define SPINEL_FRAME_BUFFER_SIZE (SPINEL_FRAME_MAX_SIZE + SPINEL_ENCRYPTER_EXTRA_DATA_SIZE) |
| |
| /// Macro for generating bit masks using bit index from the spec |
| #define SPINEL_BIT_MASK(bit_index, field_bit_count) ((1 << ((field_bit_count)-1)) >> (bit_index)) |
| |
| // ---------------------------------------------------------------------------- |
| |
| #if defined(__cplusplus) |
| extern "C" { |
| #endif |
| |
| enum |
| { |
| SPINEL_STATUS_OK = 0, ///< Operation has completed successfully. |
| SPINEL_STATUS_FAILURE = 1, ///< Operation has failed for some undefined reason. |
| SPINEL_STATUS_UNIMPLEMENTED = 2, ///< Given operation has not been implemented. |
| SPINEL_STATUS_INVALID_ARGUMENT = 3, ///< An argument to the operation is invalid. |
| SPINEL_STATUS_INVALID_STATE = 4, ///< This operation is invalid for the current device state. |
| SPINEL_STATUS_INVALID_COMMAND = 5, ///< This command is not recognized. |
| SPINEL_STATUS_INVALID_INTERFACE = 6, ///< This interface is not supported. |
| SPINEL_STATUS_INTERNAL_ERROR = 7, ///< An internal runtime error has occurred. |
| SPINEL_STATUS_SECURITY_ERROR = 8, ///< A security/authentication error has occurred. |
| SPINEL_STATUS_PARSE_ERROR = 9, ///< A error has occurred while parsing the command. |
| SPINEL_STATUS_IN_PROGRESS = 10, ///< This operation is in progress. |
| SPINEL_STATUS_NOMEM = 11, ///< Operation prevented due to memory pressure. |
| SPINEL_STATUS_BUSY = 12, ///< The device is currently performing a mutually exclusive operation |
| SPINEL_STATUS_PROP_NOT_FOUND = 13, ///< The given property is not recognized. |
| SPINEL_STATUS_DROPPED = 14, ///< A/The packet was dropped. |
| SPINEL_STATUS_EMPTY = 15, ///< The result of the operation is empty. |
| SPINEL_STATUS_CMD_TOO_BIG = 16, ///< The command was too large to fit in the internal buffer. |
| SPINEL_STATUS_NO_ACK = 17, ///< The packet was not acknowledged. |
| SPINEL_STATUS_CCA_FAILURE = 18, ///< The packet was not sent due to a CCA failure. |
| SPINEL_STATUS_ALREADY = 19, ///< The operation is already in progress. |
| SPINEL_STATUS_ITEM_NOT_FOUND = 20, ///< The given item could not be found. |
| SPINEL_STATUS_INVALID_COMMAND_FOR_PROP = 21, ///< The given command cannot be performed on this property. |
| |
| SPINEL_STATUS_JOIN__BEGIN = 104, |
| |
| /// Generic failure to associate with other peers. |
| /** |
| * This status error should not be used by implementors if |
| * enough information is available to determine that one of the |
| * later join failure status codes would be more accurate. |
| * |
| * \sa SPINEL_PROP_NET_REQUIRE_JOIN_EXISTING |
| * \sa SPINEL_PROP_MESHCOP_JOINER_COMMISSIONING |
| */ |
| SPINEL_STATUS_JOIN_FAILURE = SPINEL_STATUS_JOIN__BEGIN + 0, |
| |
| /// The node found other peers but was unable to decode their packets. |
| /** |
| * Typically this error code indicates that the network |
| * key has been set incorrectly. |
| * |
| * \sa SPINEL_PROP_NET_REQUIRE_JOIN_EXISTING |
| * \sa SPINEL_PROP_MESHCOP_JOINER_COMMISSIONING |
| */ |
| SPINEL_STATUS_JOIN_SECURITY = SPINEL_STATUS_JOIN__BEGIN + 1, |
| |
| /// The node was unable to find any other peers on the network. |
| /** |
| * \sa SPINEL_PROP_NET_REQUIRE_JOIN_EXISTING |
| * \sa SPINEL_PROP_MESHCOP_JOINER_COMMISSIONING |
| */ |
| SPINEL_STATUS_JOIN_NO_PEERS = SPINEL_STATUS_JOIN__BEGIN + 2, |
| |
| /// The only potential peer nodes found are incompatible. |
| /** |
| * \sa SPINEL_PROP_NET_REQUIRE_JOIN_EXISTING |
| */ |
| SPINEL_STATUS_JOIN_INCOMPATIBLE = SPINEL_STATUS_JOIN__BEGIN + 3, |
| |
| /// No response in expecting time. |
| /** |
| * \sa SPINEL_PROP_MESHCOP_JOINER_COMMISSIONING |
| */ |
| SPINEL_STATUS_JOIN_RSP_TIMEOUT = SPINEL_STATUS_JOIN__BEGIN + 4, |
| |
| /// The node succeeds in commissioning and get the network credentials. |
| /** |
| * \sa SPINEL_PROP_MESHCOP_JOINER_COMMISSIONING |
| */ |
| SPINEL_STATUS_JOIN_SUCCESS = SPINEL_STATUS_JOIN__BEGIN + 5, |
| |
| SPINEL_STATUS_JOIN__END = 112, |
| |
| SPINEL_STATUS_RESET__BEGIN = 112, |
| SPINEL_STATUS_RESET_POWER_ON = SPINEL_STATUS_RESET__BEGIN + 0, |
| SPINEL_STATUS_RESET_EXTERNAL = SPINEL_STATUS_RESET__BEGIN + 1, |
| SPINEL_STATUS_RESET_SOFTWARE = SPINEL_STATUS_RESET__BEGIN + 2, |
| SPINEL_STATUS_RESET_FAULT = SPINEL_STATUS_RESET__BEGIN + 3, |
| SPINEL_STATUS_RESET_CRASH = SPINEL_STATUS_RESET__BEGIN + 4, |
| SPINEL_STATUS_RESET_ASSERT = SPINEL_STATUS_RESET__BEGIN + 5, |
| SPINEL_STATUS_RESET_OTHER = SPINEL_STATUS_RESET__BEGIN + 6, |
| SPINEL_STATUS_RESET_UNKNOWN = SPINEL_STATUS_RESET__BEGIN + 7, |
| SPINEL_STATUS_RESET_WATCHDOG = SPINEL_STATUS_RESET__BEGIN + 8, |
| SPINEL_STATUS_RESET__END = 128, |
| |
| SPINEL_STATUS_VENDOR__BEGIN = 15360, |
| SPINEL_STATUS_VENDOR__END = 16384, |
| |
| SPINEL_STATUS_STACK_NATIVE__BEGIN = 16384, |
| SPINEL_STATUS_STACK_NATIVE__END = 81920, |
| |
| SPINEL_STATUS_EXPERIMENTAL__BEGIN = 2000000, |
| SPINEL_STATUS_EXPERIMENTAL__END = 2097152, |
| }; |
| |
| typedef uint32_t spinel_status_t; |
| |
| typedef enum |
| { |
| SPINEL_NET_ROLE_DETACHED = 0, |
| SPINEL_NET_ROLE_CHILD = 1, |
| SPINEL_NET_ROLE_ROUTER = 2, |
| SPINEL_NET_ROLE_LEADER = 3, |
| } spinel_net_role_t; |
| |
| typedef enum |
| { |
| SPINEL_IPV6_ICMP_PING_OFFLOAD_DISABLED = 0, |
| SPINEL_IPV6_ICMP_PING_OFFLOAD_UNICAST_ONLY = 1, |
| SPINEL_IPV6_ICMP_PING_OFFLOAD_MULTICAST_ONLY = 2, |
| SPINEL_IPV6_ICMP_PING_OFFLOAD_ALL = 3, |
| } spinel_ipv6_icmp_ping_offload_mode_t; |
| |
| typedef enum |
| { |
| SPINEL_SCAN_STATE_IDLE = 0, |
| SPINEL_SCAN_STATE_BEACON = 1, |
| SPINEL_SCAN_STATE_ENERGY = 2, |
| SPINEL_SCAN_STATE_DISCOVER = 3, |
| } spinel_scan_state_t; |
| |
| typedef enum |
| { |
| SPINEL_MCU_POWER_STATE_ON = 0, |
| SPINEL_MCU_POWER_STATE_LOW_POWER = 1, |
| SPINEL_MCU_POWER_STATE_OFF = 2, |
| } spinel_mcu_power_state_t; |
| |
| // The `spinel_power_state_t` enumeration and `POWER_STATE` |
| // property are deprecated. Please use `MCU_POWER_STATE` |
| // instead. |
| typedef enum |
| { |
| SPINEL_POWER_STATE_OFFLINE = 0, |
| SPINEL_POWER_STATE_DEEP_SLEEP = 1, |
| SPINEL_POWER_STATE_STANDBY = 2, |
| SPINEL_POWER_STATE_LOW_POWER = 3, |
| SPINEL_POWER_STATE_ONLINE = 4, |
| } spinel_power_state_t; |
| |
| typedef enum |
| { |
| SPINEL_HOST_POWER_STATE_OFFLINE = 0, |
| SPINEL_HOST_POWER_STATE_DEEP_SLEEP = 1, |
| SPINEL_HOST_POWER_STATE_RESERVED = 2, |
| SPINEL_HOST_POWER_STATE_LOW_POWER = 3, |
| SPINEL_HOST_POWER_STATE_ONLINE = 4, |
| } spinel_host_power_state_t; |
| |
| typedef enum |
| { |
| SPINEL_MESHCOP_JOINER_STATE_IDLE = 0, |
| SPINEL_MESHCOP_JOINER_STATE_DISCOVER = 1, |
| SPINEL_MESHCOP_JOINER_STATE_CONNECTING = 2, |
| SPINEL_MESHCOP_JOINER_STATE_CONNECTED = 3, |
| SPINEL_MESHCOP_JOINER_STATE_ENTRUST = 4, |
| SPINEL_MESHCOP_JOINER_STATE_JOINED = 5, |
| } spinel_meshcop_joiner_state_t; |
| |
| enum |
| { |
| SPINEL_NET_FLAG_ON_MESH = (1 << 0), |
| SPINEL_NET_FLAG_DEFAULT_ROUTE = (1 << 1), |
| SPINEL_NET_FLAG_CONFIGURE = (1 << 2), |
| SPINEL_NET_FLAG_DHCP = (1 << 3), |
| SPINEL_NET_FLAG_SLAAC = (1 << 4), |
| SPINEL_NET_FLAG_PREFERRED = (1 << 5), |
| |
| SPINEL_NET_FLAG_PREFERENCE_OFFSET = 6, |
| SPINEL_NET_FLAG_PREFERENCE_MASK = (3 << SPINEL_NET_FLAG_PREFERENCE_OFFSET), |
| }; |
| |
| enum |
| { |
| SPINEL_ROUTE_PREFERENCE_HIGH = (1 << SPINEL_NET_FLAG_PREFERENCE_OFFSET), |
| SPINEL_ROUTE_PREFERENCE_MEDIUM = (0 << SPINEL_NET_FLAG_PREFERENCE_OFFSET), |
| SPINEL_ROUTE_PREFERENCE_LOW = (3 << SPINEL_NET_FLAG_PREFERENCE_OFFSET), |
| }; |
| |
| enum |
| { |
| SPINEL_THREAD_MODE_FULL_NETWORK_DATA = (1 << 0), |
| SPINEL_THREAD_MODE_FULL_THREAD_DEV = (1 << 1), |
| SPINEL_THREAD_MODE_SECURE_DATA_REQUEST = (1 << 2), |
| SPINEL_THREAD_MODE_RX_ON_WHEN_IDLE = (1 << 3), |
| }; |
| |
| enum |
| { |
| SPINEL_GPIO_FLAG_DIR_INPUT = 0, |
| SPINEL_GPIO_FLAG_DIR_OUTPUT = SPINEL_BIT_MASK(0, 8), |
| SPINEL_GPIO_FLAG_PULL_UP = SPINEL_BIT_MASK(1, 8), |
| SPINEL_GPIO_FLAG_PULL_DOWN = SPINEL_BIT_MASK(2, 8), |
| SPINEL_GPIO_FLAG_OPEN_DRAIN = SPINEL_BIT_MASK(2, 8), |
| SPINEL_GPIO_FLAG_TRIGGER_NONE = 0, |
| SPINEL_GPIO_FLAG_TRIGGER_RISING = SPINEL_BIT_MASK(3, 8), |
| SPINEL_GPIO_FLAG_TRIGGER_FALLING = SPINEL_BIT_MASK(4, 8), |
| SPINEL_GPIO_FLAG_TRIGGER_ANY = SPINEL_GPIO_FLAG_TRIGGER_RISING | SPINEL_GPIO_FLAG_TRIGGER_FALLING, |
| }; |
| |
| enum |
| { |
| SPINEL_PROTOCOL_TYPE_BOOTLOADER = 0, |
| SPINEL_PROTOCOL_TYPE_ZIGBEE_IP = 2, |
| SPINEL_PROTOCOL_TYPE_THREAD = 3, |
| }; |
| |
| enum |
| { |
| SPINEL_MAC_PROMISCUOUS_MODE_OFF = 0, ///< Normal MAC filtering is in place. |
| SPINEL_MAC_PROMISCUOUS_MODE_NETWORK = 1, ///< All MAC packets matching network are passed up the stack. |
| SPINEL_MAC_PROMISCUOUS_MODE_FULL = 2, ///< All decoded MAC packets are passed up the stack. |
| }; |
| |
| enum |
| { |
| SPINEL_NCP_LOG_LEVEL_EMERG = 0, |
| SPINEL_NCP_LOG_LEVEL_ALERT = 1, |
| SPINEL_NCP_LOG_LEVEL_CRIT = 2, |
| SPINEL_NCP_LOG_LEVEL_ERR = 3, |
| SPINEL_NCP_LOG_LEVEL_WARN = 4, |
| SPINEL_NCP_LOG_LEVEL_NOTICE = 5, |
| SPINEL_NCP_LOG_LEVEL_INFO = 6, |
| SPINEL_NCP_LOG_LEVEL_DEBUG = 7, |
| }; |
| |
| enum |
| { |
| SPINEL_NCP_LOG_REGION_NONE = 0, |
| SPINEL_NCP_LOG_REGION_OT_API = 1, |
| SPINEL_NCP_LOG_REGION_OT_MLE = 2, |
| SPINEL_NCP_LOG_REGION_OT_ARP = 3, |
| SPINEL_NCP_LOG_REGION_OT_NET_DATA = 4, |
| SPINEL_NCP_LOG_REGION_OT_ICMP = 5, |
| SPINEL_NCP_LOG_REGION_OT_IP6 = 6, |
| SPINEL_NCP_LOG_REGION_OT_MAC = 7, |
| SPINEL_NCP_LOG_REGION_OT_MEM = 8, |
| SPINEL_NCP_LOG_REGION_OT_NCP = 9, |
| SPINEL_NCP_LOG_REGION_OT_MESH_COP = 10, |
| SPINEL_NCP_LOG_REGION_OT_NET_DIAG = 11, |
| SPINEL_NCP_LOG_REGION_OT_PLATFORM = 12, |
| SPINEL_NCP_LOG_REGION_OT_COAP = 13, |
| SPINEL_NCP_LOG_REGION_OT_CLI = 14, |
| SPINEL_NCP_LOG_REGION_OT_CORE = 15, |
| SPINEL_NCP_LOG_REGION_OT_UTIL = 16, |
| SPINEL_NCP_LOG_REGION_OT_BBR = 17, |
| }; |
| |
| enum |
| { |
| SPINEL_MESHCOP_COMMISSIONER_STATE_DISABLED = 0, |
| SPINEL_MESHCOP_COMMISSIONER_STATE_PETITION = 1, |
| SPINEL_MESHCOP_COMMISSIONER_STATE_ACTIVE = 2, |
| }; |
| |
| enum |
| { |
| SPINEL_ADDRESS_CACHE_ENTRY_STATE_CACHED = 0, // Entry is cached and in-use. |
| SPINEL_ADDRESS_CACHE_ENTRY_STATE_SNOOPED = 1, // Entry is created by snoop optimization. |
| SPINEL_ADDRESS_CACHE_ENTRY_STATE_QUERY = 2, // Entry represents an ongoing query for the EID. |
| SPINEL_ADDRESS_CACHE_ENTRY_STATE_RETRY_QUERY = 3, // Entry is in retry mode (a prior query did not a response). |
| }; |
| |
| typedef struct |
| { |
| uint8_t bytes[8]; |
| } spinel_eui64_t; |
| |
| typedef struct |
| { |
| uint8_t bytes[8]; |
| } spinel_net_xpanid_t; |
| |
| typedef struct |
| { |
| uint8_t bytes[16]; |
| } spinel_net_pskc_t; |
| |
| typedef struct |
| { |
| uint8_t bytes[6]; |
| } spinel_eui48_t; |
| |
| typedef struct |
| { |
| uint8_t bytes[16]; |
| } spinel_ipv6addr_t; |
| |
| typedef int spinel_ssize_t; |
| typedef unsigned int spinel_size_t; |
| typedef uint8_t spinel_tid_t; |
| |
| enum |
| { |
| SPINEL_MD_FLAG_TX = 0x0001, //!< Packet was transmitted, not received. |
| SPINEL_MD_FLAG_BAD_FCS = 0x0004, //!< Packet was received with bad FCS |
| SPINEL_MD_FLAG_DUPE = 0x0008, //!< Packet seems to be a duplicate |
| SPINEL_MD_FLAG_ACKED_FP = 0x0010, //!< Packet was acknowledged with frame pending set |
| SPINEL_MD_FLAG_ACKED_SEC = 0x0020, //!< Packet was acknowledged with secure enhance ACK |
| SPINEL_MD_FLAG_RESERVED = 0xFFC2, //!< Flags reserved for future use. |
| }; |
| |
| enum |
| { |
| /** |
| * No-Operation command (Host -> NCP) |
| * |
| * Encoding: Empty |
| * |
| * Induces the NCP to send a success status back to the host. This is |
| * primarily used for liveliness checks. The command payload for this |
| * command SHOULD be empty. |
| * |
| * There is no error condition for this command. |
| * |
| */ |
| SPINEL_CMD_NOOP = 0, |
| |
| /** |
| * Reset NCP command (Host -> NCP) |
| * |
| * Encoding: Empty |
| * |
| * Causes the NCP to perform a software reset. Due to the nature of |
| * this command, the TID is ignored. The host should instead wait |
| * for a `CMD_PROP_VALUE_IS` command from the NCP indicating |
| * `PROP_LAST_STATUS` has been set to `STATUS_RESET_SOFTWARE`. |
| * |
| * The command payload for this command SHOULD be empty. |
| * |
| * If an error occurs, the value of `PROP_LAST_STATUS` will be emitted |
| * instead with the value set to the generated status code for the error. |
| * |
| */ |
| SPINEL_CMD_RESET = 1, |
| |
| /** |
| * Get property value command (Host -> NCP) |
| * |
| * Encoding: `i` |
| * `i` : Property Id |
| * |
| * Causes the NCP to emit a `CMD_PROP_VALUE_IS` command for the |
| * given property identifier. |
| * |
| * The payload for this command is the property identifier encoded |
| * in the packed unsigned integer format `i`. |
| * |
| * If an error occurs, the value of `PROP_LAST_STATUS` will be emitted |
| * instead with the value set to the generated status code for the error. |
| * |
| */ |
| SPINEL_CMD_PROP_VALUE_GET = 2, |
| |
| /** |
| * Set property value command (Host -> NCP) |
| * |
| * Encoding: `iD` |
| * `i` : Property Id |
| * `D` : Value (encoding depends on the property) |
| * |
| * Instructs the NCP to set the given property to the specific given |
| * value, replacing any previous value. |
| * |
| * The payload for this command is the property identifier encoded in the |
| * packed unsigned integer format, followed by the property value. The |
| * exact format of the property value is defined by the property. |
| * |
| * On success a `CMD_PROP_VALUE_IS` command is emitted either for the |
| * given property identifier with the set value, or for `PROP_LAST_STATUS` |
| * with value `LAST_STATUS_OK`. |
| * |
| * If an error occurs, the value of `PROP_LAST_STATUS` will be emitted |
| * with the value set to the generated status code for the error. |
| * |
| */ |
| SPINEL_CMD_PROP_VALUE_SET = 3, |
| |
| /** |
| * Insert value into property command (Host -> NCP) |
| * |
| * Encoding: `iD` |
| * `i` : Property Id |
| * `D` : Value (encoding depends on the property) |
| * |
| * Instructs the NCP to insert the given value into a list-oriented |
| * property without removing other items in the list. The resulting order |
| * of items in the list is defined by the individual property being |
| * operated on. |
| * |
| * The payload for this command is the property identifier encoded in the |
| * packed unsigned integer format, followed by the value to be inserted. |
| * The exact format of the value is defined by the property. |
| * |
| * If the type signature of the property consists of a single structure |
| * enclosed by an array `A(t(...))`, then the contents of value MUST |
| * contain the contents of the structure (`...`) rather than the |
| * serialization of the whole item (`t(...)`). Specifically, the length |
| * of the structure MUST NOT be prepended to value. This helps to |
| * eliminate redundant data. |
| * |
| * On success, either a `CMD_PROP_VALUE_INSERTED` command is emitted for |
| * the given property, or a `CMD_PROP_VALUE_IS` command is emitted of |
| * property `PROP_LAST_STATUS` with value `LAST_STATUS_OK`. |
| * |
| * If an error occurs, the value of `PROP_LAST_STATUS` will be emitted |
| * with the value set to the generated status code for the error. |
| * |
| */ |
| SPINEL_CMD_PROP_VALUE_INSERT = 4, |
| |
| /** |
| * Remove value from property command (Host -> NCP) |
| * |
| * Encoding: `iD` |
| * `i` : Property Id |
| * `D` : Value (encoding depends on the property) |
| |
| * Instructs the NCP to remove the given value from a list-oriented property, |
| * without affecting other items in the list. The resulting order of items |
| * in the list is defined by the individual property being operated on. |
| * |
| * Note that this command operates by value, not by index! |
| * |
| * The payload for this command is the property identifier encoded in the |
| * packed unsigned integer format, followed by the value to be removed. The |
| * exact format of the value is defined by the property. |
| * |
| * If the type signature of the property consists of a single structure |
| * enclosed by an array `A(t(...))`, then the contents of value MUST contain |
| * the contents of the structure (`...`) rather than the serialization of the |
| * whole item (`t(...)`). Specifically, the length of the structure MUST NOT |
| * be prepended to `VALUE`. This helps to eliminate redundant data. |
| * |
| * On success, either a `CMD_PROP_VALUE_REMOVED` command is emitted for the |
| * given property, or a `CMD_PROP_VALUE_IS` command is emitted of property |
| * `PROP_LAST_STATUS` with value `LAST_STATUS_OK`. |
| * |
| * If an error occurs, the value of `PROP_LAST_STATUS` will be emitted |
| * with the value set to the generated status code for the error. |
| * |
| */ |
| SPINEL_CMD_PROP_VALUE_REMOVE = 5, |
| |
| /** |
| * Property value notification command (NCP -> Host) |
| * |
| * Encoding: `iD` |
| * `i` : Property Id |
| * `D` : Value (encoding depends on the property) |
| * |
| * This command can be sent by the NCP in response to a previous command |
| * from the host, or it can be sent by the NCP in an unsolicited fashion |
| * to notify the host of various state changes asynchronously. |
| * |
| * The payload for this command is the property identifier encoded in the |
| * packed unsigned integer format, followed by the current value of the |
| * given property. |
| * |
| */ |
| SPINEL_CMD_PROP_VALUE_IS = 6, |
| |
| /** |
| * Property value insertion notification command (NCP -> Host) |
| * |
| * Encoding:`iD` |
| * `i` : Property Id |
| * `D` : Value (encoding depends on the property) |
| * |
| * This command can be sent by the NCP in response to the |
| * `CMD_PROP_VALUE_INSERT` command, or it can be sent by the NCP in an |
| * unsolicited fashion to notify the host of various state changes |
| * asynchronously. |
| * |
| * The payload for this command is the property identifier encoded in the |
| * packed unsigned integer format, followed by the value that was inserted |
| * into the given property. |
| * |
| * If the type signature of the property specified by property id consists |
| * of a single structure enclosed by an array (`A(t(...))`), then the |
| * contents of value MUST contain the contents of the structure (`...`) |
| * rather than the serialization of the whole item (`t(...)`). Specifically, |
| * the length of the structure MUST NOT be prepended to `VALUE`. This |
| * helps to eliminate redundant data. |
| * |
| * The resulting order of items in the list is defined by the given |
| * property. |
| * |
| */ |
| SPINEL_CMD_PROP_VALUE_INSERTED = 7, |
| |
| /** |
| * Property value removal notification command (NCP -> Host) |
| * |
| * Encoding: `iD` |
| * `i` : Property Id |
| * `D` : Value (encoding depends on the property) |
| * |
| * This command can be sent by the NCP in response to the |
| * `CMD_PROP_VALUE_REMOVE` command, or it can be sent by the NCP in an |
| * unsolicited fashion to notify the host of various state changes |
| * asynchronously. |
| * |
| * Note that this command operates by value, not by index! |
| * |
| * The payload for this command is the property identifier encoded in the |
| * packed unsigned integer format described in followed by the value that |
| * was removed from the given property. |
| * |
| * If the type signature of the property specified by property id consists |
| * of a single structure enclosed by an array (`A(t(...))`), then the |
| * contents of value MUST contain the contents of the structure (`...`) |
| * rather than the serialization of the whole item (`t(...)`). Specifically, |
| * the length of the structure MUST NOT be prepended to `VALUE`. This |
| * helps to eliminate redundant data. |
| * |
| * The resulting order of items in the list is defined by the given |
| * property. |
| * |
| */ |
| SPINEL_CMD_PROP_VALUE_REMOVED = 8, |
| |
| SPINEL_CMD_NET_SAVE = 9, // Deprecated |
| |
| /** |
| * Clear saved network settings command (Host -> NCP) |
| * |
| * Encoding: Empty |
| * |
| * Erases all network credentials and state from non-volatile memory. |
| * |
| * This operation affects non-volatile memory only. The current network |
| * information stored in volatile memory is unaffected. |
| * |
| * The response to this command is always a `CMD_PROP_VALUE_IS` for |
| * `PROP_LAST_STATUS`, indicating the result of the operation. |
| * |
| */ |
| SPINEL_CMD_NET_CLEAR = 10, |
| |
| SPINEL_CMD_NET_RECALL = 11, // Deprecated |
| |
| /** |
| * Host buffer offload is an optional NCP capability that, when |
| * present, allows the NCP to store data buffers on the host processor |
| * that can be recalled at a later time. |
| * |
| * The presence of this feature can be detected by the host by |
| * checking for the presence of the `CAP_HBO` |
| * capability in `PROP_CAPS`. |
| * |
| * This feature is not currently supported on OpenThread. |
| * |
| */ |
| |
| SPINEL_CMD_HBO_OFFLOAD = 12, |
| SPINEL_CMD_HBO_RECLAIM = 13, |
| SPINEL_CMD_HBO_DROP = 14, |
| SPINEL_CMD_HBO_OFFLOADED = 15, |
| SPINEL_CMD_HBO_RECLAIMED = 16, |
| SPINEL_CMD_HBO_DROPPED = 17, |
| |
| /** |
| * Peek command (Host -> NCP) |
| * |
| * Encoding: `LU` |
| * `L` : The address to peek |
| * `U` : Number of bytes to read |
| * |
| * This command allows the NCP to fetch values from the RAM of the NCP |
| * for debugging purposes. Upon success, `CMD_PEEK_RET` is sent from the |
| * NCP to the host. Upon failure, `PROP_LAST_STATUS` is emitted with |
| * the appropriate error indication. |
| * |
| * The NCP MAY prevent certain regions of memory from being accessed. |
| * |
| * This command requires the capability `CAP_PEEK_POKE` to be present. |
| * |
| */ |
| SPINEL_CMD_PEEK = 18, |
| |
| /** |
| * Peek return command (NCP -> Host) |
| * |
| * Encoding: `LUD` |
| * `L` : The address peeked |
| * `U` : Number of bytes read |
| * `D` : Memory content |
| * |
| * This command contains the contents of memory that was requested by |
| * a previous call to `CMD_PEEK`. |
| * |
| * This command requires the capability `CAP_PEEK_POKE` to be present. |
| * |
| */ |
| SPINEL_CMD_PEEK_RET = 19, |
| |
| /** |
| * Poke command (Host -> NCP) |
| * |
| * Encoding: `LUD` |
| * `L` : The address to be poked |
| * `U` : Number of bytes to write |
| * `D` : Content to write |
| * |
| * This command writes the bytes to the specified memory address |
| * for debugging purposes. |
| * |
| * This command requires the capability `CAP_PEEK_POKE` to be present. |
| * |
| */ |
| SPINEL_CMD_POKE = 20, |
| |
| SPINEL_CMD_PROP_VALUE_MULTI_GET = 21, |
| SPINEL_CMD_PROP_VALUE_MULTI_SET = 22, |
| SPINEL_CMD_PROP_VALUES_ARE = 23, |
| |
| SPINEL_CMD_NEST__BEGIN = 15296, |
| SPINEL_CMD_NEST__END = 15360, |
| |
| SPINEL_CMD_VENDOR__BEGIN = 15360, |
| SPINEL_CMD_VENDOR__END = 16384, |
| |
| SPINEL_CMD_EXPERIMENTAL__BEGIN = 2000000, |
| SPINEL_CMD_EXPERIMENTAL__END = 2097152, |
| }; |
| |
| typedef uint32_t spinel_command_t; |
| |
| enum |
| { |
| SPINEL_CAP_LOCK = 1, |
| SPINEL_CAP_NET_SAVE = 2, |
| SPINEL_CAP_HBO = 3, |
| SPINEL_CAP_POWER_SAVE = 4, |
| |
| SPINEL_CAP_COUNTERS = 5, |
| SPINEL_CAP_JAM_DETECT = 6, |
| |
| SPINEL_CAP_PEEK_POKE = 7, |
| |
| SPINEL_CAP_WRITABLE_RAW_STREAM = 8, |
| SPINEL_CAP_GPIO = 9, |
| SPINEL_CAP_TRNG = 10, |
| SPINEL_CAP_CMD_MULTI = 11, |
| SPINEL_CAP_UNSOL_UPDATE_FILTER = 12, |
| SPINEL_CAP_MCU_POWER_STATE = 13, |
| SPINEL_CAP_PCAP = 14, |
| |
| SPINEL_CAP_802_15_4__BEGIN = 16, |
| SPINEL_CAP_802_15_4_2003 = (SPINEL_CAP_802_15_4__BEGIN + 0), |
| SPINEL_CAP_802_15_4_2006 = (SPINEL_CAP_802_15_4__BEGIN + 1), |
| SPINEL_CAP_802_15_4_2011 = (SPINEL_CAP_802_15_4__BEGIN + 2), |
| SPINEL_CAP_802_15_4_PIB = (SPINEL_CAP_802_15_4__BEGIN + 5), |
| SPINEL_CAP_802_15_4_2450MHZ_OQPSK = (SPINEL_CAP_802_15_4__BEGIN + 8), |
| SPINEL_CAP_802_15_4_915MHZ_OQPSK = (SPINEL_CAP_802_15_4__BEGIN + 9), |
| SPINEL_CAP_802_15_4_868MHZ_OQPSK = (SPINEL_CAP_802_15_4__BEGIN + 10), |
| SPINEL_CAP_802_15_4_915MHZ_BPSK = (SPINEL_CAP_802_15_4__BEGIN + 11), |
| SPINEL_CAP_802_15_4_868MHZ_BPSK = (SPINEL_CAP_802_15_4__BEGIN + 12), |
| SPINEL_CAP_802_15_4_915MHZ_ASK = (SPINEL_CAP_802_15_4__BEGIN + 13), |
| SPINEL_CAP_802_15_4_868MHZ_ASK = (SPINEL_CAP_802_15_4__BEGIN + 14), |
| SPINEL_CAP_802_15_4__END = 32, |
| |
| SPINEL_CAP_CONFIG__BEGIN = 32, |
| SPINEL_CAP_CONFIG_FTD = (SPINEL_CAP_CONFIG__BEGIN + 0), |
| SPINEL_CAP_CONFIG_MTD = (SPINEL_CAP_CONFIG__BEGIN + 1), |
| SPINEL_CAP_CONFIG_RADIO = (SPINEL_CAP_CONFIG__BEGIN + 2), |
| SPINEL_CAP_CONFIG__END = 40, |
| |
| SPINEL_CAP_ROLE__BEGIN = 48, |
| SPINEL_CAP_ROLE_ROUTER = (SPINEL_CAP_ROLE__BEGIN + 0), |
| SPINEL_CAP_ROLE_SLEEPY = (SPINEL_CAP_ROLE__BEGIN + 1), |
| SPINEL_CAP_ROLE__END = 52, |
| |
| SPINEL_CAP_NET__BEGIN = 52, |
| SPINEL_CAP_NET_THREAD_1_0 = (SPINEL_CAP_NET__BEGIN + 0), |
| SPINEL_CAP_NET_THREAD_1_1 = (SPINEL_CAP_NET__BEGIN + 1), |
| SPINEL_CAP_NET__END = 64, |
| |
| SPINEL_CAP_OPENTHREAD__BEGIN = 512, |
| SPINEL_CAP_MAC_WHITELIST = (SPINEL_CAP_OPENTHREAD__BEGIN + 0), |
| SPINEL_CAP_MAC_RAW = (SPINEL_CAP_OPENTHREAD__BEGIN + 1), |
| SPINEL_CAP_OOB_STEERING_DATA = (SPINEL_CAP_OPENTHREAD__BEGIN + 2), |
| SPINEL_CAP_CHANNEL_MONITOR = (SPINEL_CAP_OPENTHREAD__BEGIN + 3), |
| SPINEL_CAP_ERROR_RATE_TRACKING = (SPINEL_CAP_OPENTHREAD__BEGIN + 4), |
| SPINEL_CAP_CHANNEL_MANAGER = (SPINEL_CAP_OPENTHREAD__BEGIN + 5), |
| SPINEL_CAP_OPENTHREAD_LOG_METADATA = (SPINEL_CAP_OPENTHREAD__BEGIN + 6), |
| SPINEL_CAP_TIME_SYNC = (SPINEL_CAP_OPENTHREAD__BEGIN + 7), |
| SPINEL_CAP_CHILD_SUPERVISION = (SPINEL_CAP_OPENTHREAD__BEGIN + 8), |
| SPINEL_CAP_POSIX = (SPINEL_CAP_OPENTHREAD__BEGIN + 9), |
| SPINEL_CAP_SLAAC = (SPINEL_CAP_OPENTHREAD__BEGIN + 10), |
| SPINEL_CAP_RADIO_COEX = (SPINEL_CAP_OPENTHREAD__BEGIN + 11), |
| SPINEL_CAP_MAC_RETRY_HISTOGRAM = (SPINEL_CAP_OPENTHREAD__BEGIN + 12), |
| SPINEL_CAP_OPENTHREAD__END = 640, |
| |
| SPINEL_CAP_THREAD__BEGIN = 1024, |
| SPINEL_CAP_THREAD_COMMISSIONER = (SPINEL_CAP_THREAD__BEGIN + 0), |
| SPINEL_CAP_THREAD_TMF_PROXY = (SPINEL_CAP_THREAD__BEGIN + 1), |
| SPINEL_CAP_THREAD_UDP_FORWARD = (SPINEL_CAP_THREAD__BEGIN + 2), |
| SPINEL_CAP_THREAD_JOINER = (SPINEL_CAP_THREAD__BEGIN + 3), |
| SPINEL_CAP_THREAD_BORDER_ROUTER = (SPINEL_CAP_THREAD__BEGIN + 4), |
| SPINEL_CAP_THREAD_SERVICE = (SPINEL_CAP_THREAD__BEGIN + 5), |
| SPINEL_CAP_THREAD__END = 1152, |
| |
| SPINEL_CAP_NEST__BEGIN = 15296, |
| SPINEL_CAP_NEST_LEGACY_INTERFACE = (SPINEL_CAP_NEST__BEGIN + 0), |
| SPINEL_CAP_NEST_LEGACY_NET_WAKE = (SPINEL_CAP_NEST__BEGIN + 1), |
| SPINEL_CAP_NEST_TRANSMIT_HOOK = (SPINEL_CAP_NEST__BEGIN + 2), |
| SPINEL_CAP_NEST__END = 15360, |
| |
| SPINEL_CAP_VENDOR__BEGIN = 15360, |
| SPINEL_CAP_VENDOR__END = 16384, |
| |
| SPINEL_CAP_EXPERIMENTAL__BEGIN = 2000000, |
| SPINEL_CAP_EXPERIMENTAL__END = 2097152, |
| }; |
| |
| typedef uint32_t spinel_capability_t; |
| |
| /** |
| * Property Keys |
| * |
| * The properties are broken up into several sections, each with a |
| * reserved ranges of property identifiers: |
| * |
| * Name | Range (Inclusive) | Description |
| * -------------|--------------------------------|------------------------ |
| * Core | 0x000 - 0x01F, 0x1000 - 0x11FF | Spinel core |
| * PHY | 0x020 - 0x02F, 0x1200 - 0x12FF | Radio PHY layer |
| * MAC | 0x030 - 0x03F, 0x1300 - 0x13FF | MAC layer |
| * NET | 0x040 - 0x04F, 0x1400 - 0x14FF | Network |
| * Thread | 0x050 - 0x05F, 0x1500 - 0x15FF | Thread |
| * IPv6 | 0x060 - 0x06F, 0x1600 - 0x16FF | IPv6 |
| * Stream | 0x070 - 0x07F, 0x1700 - 0x17FF | Stream |
| * MeshCop | 0x080 - 0x08F, 0x1800 - 0x18FF | Thread Mesh Commissioning |
| * OpenThread | 0x1900 - 0x19FF | OpenThread specific |
| * Server | 0x0A0 - 0x0AF | ALOC Service Server |
| * Interface | 0x100 - 0x1FF | Interface (e.g., UART) |
| * PIB | 0x400 - 0x4FF | 802.15.4 PIB |
| * Counter | 0x500 - 0x7FF | Counters (MAC, IP, etc). |
| * RCP | 0x800 - 0x8FF | RCP specific property |
| * Nest | 0x3BC0 - 0x3BFF | Nest (legacy) |
| * Vendor | 0x3C00 - 0x3FFF | Vendor specific |
| * Debug | 0x4000 - 0x43FF | Debug related |
| * Experimental | 2,000,000 - 2,097,151 | Experimental use only |
| * |
| */ |
| enum |
| { |
| /// Last Operation Status |
| /** Format: `i` - Read-only |
| * |
| * Describes the status of the last operation. Encoded as a packed |
| * unsigned integer (see `SPINEL_STATUS_*` for list of values). |
| * |
| * This property is emitted often to indicate the result status of |
| * pretty much any Host-to-NCP operation. |
| * |
| * It is emitted automatically at NCP startup with a value indicating |
| * the reset reason. It is also emitted asynchronously on an error ( |
| * e.g., NCP running out of buffer). |
| * |
| */ |
| SPINEL_PROP_LAST_STATUS = 0, |
| |
| /// Protocol Version |
| /** Format: `ii` - Read-only |
| * |
| * Describes the protocol version information. This property contains |
| * two fields, each encoded as a packed unsigned integer: |
| * `i`: Major Version Number |
| * `i`: Minor Version Number |
| * |
| * The version number is defined by `SPINEL_PROTOCOL_VERSION_THREAD_MAJOR` |
| * and `SPINEL_PROTOCOL_VERSION_THREAD_MINOR`. |
| * |
| * This specification describes major version 4, minor version 3. |
| * |
| */ |
| SPINEL_PROP_PROTOCOL_VERSION = 1, |
| |
| /// NCP Version |
| /** Format: `U` - Read-only |
| * |
| * Contains a string which describes the firmware currently running on |
| * the NCP. Encoded as a zero-terminated UTF-8 string. |
| * |
| */ |
| SPINEL_PROP_NCP_VERSION = 2, |
| |
| /// NCP Network Protocol Type |
| /** Format: 'i' - Read-only |
| * |
| * This value identifies what the network protocol for this NCP. |
| * The valid protocol type values are defined by enumeration |
| * `SPINEL_PROTOCOL_TYPE_*`: |
| * |
| * `SPINEL_PROTOCOL_TYPE_BOOTLOADER` = 0 |
| * `SPINEL_PROTOCOL_TYPE_ZIGBEE_IP` = 2, |
| * `SPINEL_PROTOCOL_TYPE_THREAD` = 3, |
| * |
| * OpenThread NCP supports only `SPINEL_PROTOCOL_TYPE_THREAD` |
| * |
| */ |
| SPINEL_PROP_INTERFACE_TYPE = 3, |
| |
| /// NCP Vendor ID |
| /** Format: 'i` - Read-only |
| * |
| * Vendor ID. Zero for unknown. |
| * |
| */ |
| SPINEL_PROP_VENDOR_ID = 4, |
| |
| /// NCP Capability List |
| /** Format: 'A(i)` - Read-only |
| * |
| * Describes the supported capabilities of this NCP. Encoded as a list of |
| * packed unsigned integers. |
| * |
| * The capability values are specified by SPINEL_CAP_* enumeration. |
| * |
| */ |
| SPINEL_PROP_CAPS = 5, |
| |
| /// NCP Interface Count |
| /** Format: 'C` - Read-only |
| * |
| * Provides number of interfaces. |
| * |
| * Currently always reads as 1. |
| * |
| */ |
| SPINEL_PROP_INTERFACE_COUNT = 6, |
| |
| SPINEL_PROP_POWER_STATE = 7, ///< PowerState [C] (deprecated, use `MCU_POWER_STATE` instead). |
| |
| /// NCP Hardware Address |
| /** Format: 'E` - Read-only |
| * |
| * The static EUI64 address of the device, used as a serial number. |
| * |
| */ |
| SPINEL_PROP_HWADDR = 8, |
| |
| SPINEL_PROP_LOCK = 9, ///< PropLock [b] (not supported) |
| SPINEL_PROP_HBO_MEM_MAX = 10, ///< Max offload mem [S] (not supported) |
| SPINEL_PROP_HBO_BLOCK_MAX = 11, ///< Max offload block [S] (not supported) |
| |
| /// Host Power State |
| /** Format: 'C` |
| * |
| * Describes the current power state of the host. This property is used |
| * by the host to inform the NCP when it has changed power states. The |
| * NCP can then use this state to determine which properties need |
| * asynchronous updates. Enumeration `spinel_host_power_state_t` defines |
| * the valid values (`SPINEL_HOST_POWER_STATE_*`): |
| * |
| * `HOST_POWER_STATE_OFFLINE`: Host is physically powered off and |
| * cannot be woken by the NCP. All asynchronous commands are |
| * squelched. |
| * |
| * `HOST_POWER_STATE_DEEP_SLEEP`: The host is in a low power state |
| * where it can be woken by the NCP but will potentially require more |
| * than two seconds to become fully responsive. The NCP MUST |
| * avoid sending unnecessary property updates, such as child table |
| * updates or non-critical messages on the debug stream. If the NCP |
| * needs to wake the host for traffic, the NCP MUST first take |
| * action to wake the host. Once the NCP signals to the host that it |
| * should wake up, the NCP MUST wait for some activity from the |
| * host (indicating that it is fully awake) before sending frames. |
| * |
| * `HOST_POWER_STATE_RESERVED`: This value MUST NOT be set by the host. If |
| * received by the NCP, the NCP SHOULD consider this as a synonym |
| * of `HOST_POWER_STATE_DEEP_SLEEP`. |
| * |
| * `HOST_POWER_STATE_LOW_POWER`: The host is in a low power state |
| * where it can be immediately woken by the NCP. The NCP SHOULD |
| * avoid sending unnecessary property updates, such as child table |
| * updates or non-critical messages on the debug stream. |
| * |
| * `HOST_POWER_STATE_ONLINE`: The host is awake and responsive. No |
| * special filtering is performed by the NCP on asynchronous updates. |
| * |
| * All other values are RESERVED. They MUST NOT be set by the |
| * host. If received by the NCP, the NCP SHOULD consider the value as |
| * a synonym of `HOST_POWER_STATE_LOW_POWER`. |
| * |
| * After setting this power state, any further commands from the host to |
| * the NCP will cause `HOST_POWER_STATE` to automatically revert to |
| * `HOST_POWER_STATE_ONLINE`. |
| * |
| * When the host is entering a low-power state, it should wait for the |
| * response from the NCP acknowledging the command (with `CMD_VALUE_IS`). |
| * Once that acknowledgment is received the host may enter the low-power |
| * state. |
| * |
| * If the NCP has the `CAP_UNSOL_UPDATE_FILTER` capability, any unsolicited |
| * property updates masked by `PROP_UNSOL_UPDATE_FILTER` should be honored |
| * while the host indicates it is in a low-power state. After resuming to the |
| * `HOST_POWER_STATE_ONLINE` state, the value of `PROP_UNSOL_UPDATE_FILTER` |
| * MUST be unchanged from the value assigned prior to the host indicating |
| * it was entering a low-power state. |
| * |
| */ |
| SPINEL_PROP_HOST_POWER_STATE = 12, |
| |
| /// NCP's MCU Power State |
| /** Format: 'C` |
| * Required capability: CAP_MCU_POWER_SAVE |
| * |
| * This property specifies the desired power state of NCP's micro-controller |
| * (MCU) when the underlying platform's operating system enters idle mode (i.e., |
| * all active tasks/events are processed and the MCU can potentially enter a |
| * energy-saving power state). |
| * |
| * The power state primarily determines how the host should interact with the NCP |
| * and whether the host needs an external trigger (a "poke") to NCP before it can |
| * communicate with the NCP or not. After a reset, the MCU power state MUST be |
| * SPINEL_MCU_POWER_STATE_ON. |
| * |
| * Enumeration `spinel_mcu_power_state_t` defines the valid values |
| * (`SPINEL_MCU_POWER_STATE_*` constants): |
| * |
| * `SPINEL_MCU_POWER_STATE_ON`: NCP's MCU stays on and active all the time. |
| * When the NCP's desired power state is set to this value, host can send |
| * messages to NCP without requiring any "poke" or external triggers. MCU is |
| * expected to stay on and active. Note that the `ON` power state only |
| * determines the MCU's power mode and is not related to radio's state. |
| * |
| * `SPINEL_MCU_POWER_STATE_LOW_POWER`: NCP's MCU can enter low-power |
| * (energy-saving) state. When the NCP's desired power state is set to |
| * `LOW_POWER`, host is expected to "poke" the NCP (e.g., an external trigger |
| * like an interrupt) before it can communicate with the NCP (send a message |
| * to the NCP). The "poke" mechanism is determined by the platform code (based |
| * on NCP's interface to the host). |
| * While power state is set to `LOW_POWER`, NCP can still (at any time) send |
| * messages to host. Note that receiving a message from the NCP does NOT |
| * indicate that the NCP's power state has changed, i.e., host is expected to |
| * continue to "poke" NCP when it wants to talk to the NCP until the power |
| * state is explicitly changed (by setting this property to `ON`). |
| * Note that the `LOW_POWER` power state only determines the MCU's power mode |
| * and is not related to radio's state. |
| * |
| * `SPINEL_MCU_POWER_STATE_OFF`: NCP is fully powered off. |
| * An NCP hardware reset (via a RESET pin) is required to bring the NCP back |
| * to `SPINEL_MCU_POWER_STATE_ON`. RAM is not retained after reset. |
| * |
| */ |
| SPINEL_PROP_MCU_POWER_STATE = 13, |
| |
| SPINEL_PROP_BASE_EXT__BEGIN = 0x1000, |
| |
| /// GPIO Configuration |
| /** Format: `A(CCU)` |
| * Type: Read-Only (Optionally Read-write using `CMD_PROP_VALUE_INSERT`) |
| * |
| * An array of structures which contain the following fields: |
| * |
| * * `C`: GPIO Number |
| * * `C`: GPIO Configuration Flags |
| * * `U`: Human-readable GPIO name |
| * |
| * GPIOs which do not have a corresponding entry are not supported. |
| * |
| * The configuration parameter contains the configuration flags for the |
| * GPIO: |
| * |
| * 0 1 2 3 4 5 6 7 |
| * +---+---+---+---+---+---+---+---+ |
| * |DIR|PUP|PDN|TRIGGER| RESERVED | |
| * +---+---+---+---+---+---+---+---+ |
| * |O/D| |
| * +---+ |
| * |
| * * `DIR`: Pin direction. Clear (0) for input, set (1) for output. |
| * * `PUP`: Pull-up enabled flag. |
| * * `PDN`/`O/D`: Flag meaning depends on pin direction: |
| * * Input: Pull-down enabled. |
| * * Output: Output is an open-drain. |
| * * `TRIGGER`: Enumeration describing how pin changes generate |
| * asynchronous notification commands (TBD) from the NCP to the host. |
| * * 0: Feature disabled for this pin |
| * * 1: Trigger on falling edge |
| * * 2: Trigger on rising edge |
| * * 3: Trigger on level change |
| * * `RESERVED`: Bits reserved for future use. Always cleared to zero |
| * and ignored when read. |
| * |
| * As an optional feature, the configuration of individual pins may be |
| * modified using the `CMD_PROP_VALUE_INSERT` command. Only the GPIO |
| * number and flags fields MUST be present, the GPIO name (if present) |
| * would be ignored. This command can only be used to modify the |
| * configuration of GPIOs which are already exposed---it cannot be used |
| * by the host to add additional GPIOs. |
| */ |
| SPINEL_PROP_GPIO_CONFIG = SPINEL_PROP_BASE_EXT__BEGIN + 0, |
| |
| /// GPIO State Bitmask |
| /** Format: `D` |
| * Type: Read-Write |
| * |
| * Contains a bit field identifying the state of the GPIOs. The length of |
| * the data associated with these properties depends on the number of |
| * GPIOs. If you have 10 GPIOs, you'd have two bytes. GPIOs are numbered |
| * from most significant bit to least significant bit, so 0x80 is GPIO 0, |
| * 0x40 is GPIO 1, etc. |
| * |
| * For GPIOs configured as inputs: |
| * |
| * * `CMD_PROP_VAUE_GET`: The value of the associated bit describes the |
| * logic level read from the pin. |
| * * `CMD_PROP_VALUE_SET`: The value of the associated bit is ignored |
| * for these pins. |
| * |
| * For GPIOs configured as outputs: |
| * |
| * * `CMD_PROP_VAUE_GET`: The value of the associated bit is |
| * implementation specific. |
| * * `CMD_PROP_VALUE_SET`: The value of the associated bit determines |
| * the new logic level of the output. If this pin is configured as an |
| * open-drain, setting the associated bit to 1 will cause the pin to |
| * enter a Hi-Z state. |
| * |
| * For GPIOs which are not specified in `PROP_GPIO_CONFIG`: |
| * |
| * * `CMD_PROP_VAUE_GET`: The value of the associated bit is |
| * implementation specific. |
| * * `CMD_PROP_VALUE_SET`: The value of the associated bit MUST be |
| * ignored by the NCP. |
| * |
| * When writing, unspecified bits are assumed to be zero. |
| */ |
| SPINEL_PROP_GPIO_STATE = SPINEL_PROP_BASE_EXT__BEGIN + 2, |
| |
| /// GPIO State Set-Only Bitmask |
| /** Format: `D` |
| * Type: Write-Only |
| * |
| * Allows for the state of various output GPIOs to be set without affecting |
| * other GPIO states. Contains a bit field identifying the output GPIOs that |
| * should have their state set to 1. |
| * |
| * When writing, unspecified bits are assumed to be zero. The value of |
| * any bits for GPIOs which are not specified in `PROP_GPIO_CONFIG` MUST |
| * be ignored. |
| */ |
| SPINEL_PROP_GPIO_STATE_SET = SPINEL_PROP_BASE_EXT__BEGIN + 3, |
| |
| /// GPIO State Clear-Only Bitmask |
| /** Format: `D` |
| * Type: Write-Only |
| * |
| * Allows for the state of various output GPIOs to be cleared without affecting |
| * other GPIO states. Contains a bit field identifying the output GPIOs that |
| * should have their state cleared to 0. |
| * |
| * When writing, unspecified bits are assumed to be zero. The value of |
| * any bits for GPIOs which are not specified in `PROP_GPIO_CONFIG` MUST |
| * be ignored. |
| */ |
| SPINEL_PROP_GPIO_STATE_CLEAR = SPINEL_PROP_BASE_EXT__BEGIN + 4, |
| |
| /// 32-bit random number from TRNG, ready-to-use. |
| SPINEL_PROP_TRNG_32 = SPINEL_PROP_BASE_EXT__BEGIN + 5, |
| |
| /// 16 random bytes from TRNG, ready-to-use. |
| SPINEL_PROP_TRNG_128 = SPINEL_PROP_BASE_EXT__BEGIN + 6, |
| |
| /// Raw samples from TRNG entropy source representing 32 bits of entropy. |
| SPINEL_PROP_TRNG_RAW_32 = SPINEL_PROP_BASE_EXT__BEGIN + 7, |
| |
| /// NCP Unsolicited update filter |
| /** Format: `A(I)` |
| * Type: Read-Write (optional Insert-Remove) |
| * Required capability: `CAP_UNSOL_UPDATE_FILTER` |
| * |
| * Contains a list of properties which are excluded from generating |
| * unsolicited value updates. This property is empty after reset. |
| * In other words, the host may opt-out of unsolicited property updates |
| * for a specific property by adding that property id to this list. |
| * Hosts SHOULD NOT add properties to this list which are not |
| * present in `PROP_UNSOL_UPDATE_LIST`. If such properties are added, |
| * the NCP ignores the unsupported properties. |
| * |
| */ |
| SPINEL_PROP_UNSOL_UPDATE_FILTER = SPINEL_PROP_BASE_EXT__BEGIN + 8, |
| |
| /// List of properties capable of generating unsolicited value update. |
| /** Format: `A(I)` |
| * Type: Read-Only |
| * Required capability: `CAP_UNSOL_UPDATE_FILTER` |
| * |
| * Contains a list of properties which are capable of generating |
| * unsolicited value updates. This list can be used when populating |
| * `PROP_UNSOL_UPDATE_FILTER` to disable all unsolicited property |
| * updates. |
| * |
| * This property is intended to effectively behave as a constant |
| * for a given NCP firmware. |
| */ |
| SPINEL_PROP_UNSOL_UPDATE_LIST = SPINEL_PROP_BASE_EXT__BEGIN + 9, |
| |
| SPINEL_PROP_BASE_EXT__END = 0x1100, |
| |
| SPINEL_PROP_PHY__BEGIN = 0x20, |
| SPINEL_PROP_PHY_ENABLED = SPINEL_PROP_PHY__BEGIN + 0, ///< [b] |
| SPINEL_PROP_PHY_CHAN = SPINEL_PROP_PHY__BEGIN + 1, ///< [C] |
| SPINEL_PROP_PHY_CHAN_SUPPORTED = SPINEL_PROP_PHY__BEGIN + 2, ///< [A(C)] |
| SPINEL_PROP_PHY_FREQ = SPINEL_PROP_PHY__BEGIN + 3, ///< kHz [L] |
| SPINEL_PROP_PHY_CCA_THRESHOLD = SPINEL_PROP_PHY__BEGIN + 4, ///< dBm [c] |
| SPINEL_PROP_PHY_TX_POWER = SPINEL_PROP_PHY__BEGIN + 5, ///< [c] |
| SPINEL_PROP_PHY_RSSI = SPINEL_PROP_PHY__BEGIN + 6, ///< dBm [c] |
| SPINEL_PROP_PHY_RX_SENSITIVITY = SPINEL_PROP_PHY__BEGIN + 7, ///< dBm [c] |
| SPINEL_PROP_PHY_PCAP_ENABLED = SPINEL_PROP_PHY__BEGIN + 8, ///< [b] |
| SPINEL_PROP_PHY_CHAN_PREFERRED = SPINEL_PROP_PHY__BEGIN + 9, ///< [A(C)] |
| SPINEL_PROP_PHY__END = 0x30, |
| |
| SPINEL_PROP_PHY_EXT__BEGIN = 0x1200, |
| |
| /// Signal Jamming Detection Enable |
| /** Format: `b` |
| * |
| * Indicates if jamming detection is enabled or disabled. Set to true |
| * to enable jamming detection. |
| */ |
| SPINEL_PROP_JAM_DETECT_ENABLE = SPINEL_PROP_PHY_EXT__BEGIN + 0, |
| |
| /// Signal Jamming Detected Indicator |
| /** Format: `b` (Read-Only) |
| * |
| * Set to true if radio jamming is detected. Set to false otherwise. |
| * |
| * When jamming detection is enabled, changes to the value of this |
| * property are emitted asynchronously via `CMD_PROP_VALUE_IS`. |
| */ |
| SPINEL_PROP_JAM_DETECTED = SPINEL_PROP_PHY_EXT__BEGIN + 1, |
| |
| /// Jamming detection RSSI threshold |
| /** Format: `c` |
| * Units: dBm |
| * |
| * This parameter describes the threshold RSSI level (measured in |
| * dBm) above which the jamming detection will consider the |
| * channel blocked. |
| */ |
| SPINEL_PROP_JAM_DETECT_RSSI_THRESHOLD = SPINEL_PROP_PHY_EXT__BEGIN + 2, |
| |
| /// Jamming detection window size |
| /** Format: `C` |
| * Units: Seconds (1-63) |
| * |
| * This parameter describes the window period for signal jamming |
| * detection. |
| */ |
| SPINEL_PROP_JAM_DETECT_WINDOW = SPINEL_PROP_PHY_EXT__BEGIN + 3, |
| |
| /// Jamming detection busy period |
| /** Format: `C` |
| * Units: Seconds (1-63) |
| * |
| * This parameter describes the number of aggregate seconds within |
| * the detection window where the RSSI must be above |
| * `PROP_JAM_DETECT_RSSI_THRESHOLD` to trigger detection. |
| * |
| * The behavior of the jamming detection feature when `PROP_JAM_DETECT_BUSY` |
| * is larger than `PROP_JAM_DETECT_WINDOW` is undefined. |
| */ |
| SPINEL_PROP_JAM_DETECT_BUSY = SPINEL_PROP_PHY_EXT__BEGIN + 4, |
| |
| /// Jamming detection history bitmap (for debugging) |
| /** Format: `X` (read-only) |
| * |
| * This value provides information about current state of jamming detection |
| * module for monitoring/debugging purpose. It returns a 64-bit value where |
| * each bit corresponds to one second interval starting with bit 0 for the |
| * most recent interval and bit 63 for the oldest intervals (63 sec earlier). |
| * The bit is set to 1 if the jamming detection module observed/detected |
| * high signal level during the corresponding one second interval. |
| * |
| */ |
| SPINEL_PROP_JAM_DETECT_HISTORY_BITMAP = SPINEL_PROP_PHY_EXT__BEGIN + 5, |
| |
| /// Channel monitoring sample interval |
| /** Format: `L` (read-only) |
| * Units: Milliseconds |
| * |
| * Required capability: SPINEL_CAP_CHANNEL_MONITOR |
| * |
| * If channel monitoring is enabled and active, every sample interval, a |
| * zero-duration Energy Scan is performed, collecting a single RSSI sample |
| * per channel. The RSSI samples are compared with a pre-specified RSSI |
| * threshold. |
| * |
| */ |
| SPINEL_PROP_CHANNEL_MONITOR_SAMPLE_INTERVAL = SPINEL_PROP_PHY_EXT__BEGIN + 6, |
| |
| /// Channel monitoring RSSI threshold |
| /** Format: `c` (read-only) |
| * Units: dBm |
| * |
| * Required capability: SPINEL_CAP_CHANNEL_MONITOR |
| * |
| * This value specifies the threshold used by channel monitoring module. |
| * Channel monitoring maintains the average rate of RSSI samples that |
| * are above the threshold within (approximately) a pre-specified number |
| * of samples (sample window). |
| * |
| */ |
| SPINEL_PROP_CHANNEL_MONITOR_RSSI_THRESHOLD = SPINEL_PROP_PHY_EXT__BEGIN + 7, |
| |
| /// Channel monitoring sample window |
| /** Format: `L` (read-only) |
| * Units: Number of samples |
| * |
| * Required capability: SPINEL_CAP_CHANNEL_MONITOR |
| * |
| * The averaging sample window length (in units of number of channel |
| * samples) used by channel monitoring module. Channel monitoring will |
| * sample all channels every sample interval. It maintains the average rate |
| * of RSSI samples that are above the RSSI threshold within (approximately) |
| * the sample window. |
| * |
| */ |
| SPINEL_PROP_CHANNEL_MONITOR_SAMPLE_WINDOW = SPINEL_PROP_PHY_EXT__BEGIN + 8, |
| |
| /// Channel monitoring sample count |
| /** Format: `L` (read-only) |
| * Units: Number of samples |
| * |
| * Required capability: SPINEL_CAP_CHANNEL_MONITOR |
| * |
| * Total number of RSSI samples (per channel) taken by the channel |
| * monitoring module since its start (since Thread network interface |
| * was enabled). |
| * |
| */ |
| SPINEL_PROP_CHANNEL_MONITOR_SAMPLE_COUNT = SPINEL_PROP_PHY_EXT__BEGIN + 9, |
| |
| /// Channel monitoring channel occupancy |
| /** Format: `A(t(CU))` (read-only) |
| * |
| * Required capability: SPINEL_CAP_CHANNEL_MONITOR |
| * |
| * Data per item is: |
| * |
| * `C`: Channel |
| * `U`: Channel occupancy indicator |
| * |
| * The channel occupancy value represents the average rate/percentage of |
| * RSSI samples that were above RSSI threshold ("bad" RSSI samples) within |
| * (approximately) sample window latest RSSI samples. |
| * |
| * Max value of `0xffff` indicates all RSSI samples were above RSSI |
| * threshold (i.e. 100% of samples were "bad"). |
| * |
| */ |
| SPINEL_PROP_CHANNEL_MONITOR_CHANNEL_OCCUPANCY = SPINEL_PROP_PHY_EXT__BEGIN + 10, |
| |
| /// Radio caps |
| /** Format: `i` (read-only) |
| * |
| * Data per item is: |
| * |
| * `i`: Radio Capabilities. |
| * |
| */ |
| SPINEL_PROP_RADIO_CAPS = SPINEL_PROP_PHY_EXT__BEGIN + 11, |
| |
| /// All coex metrics related counters. |
| /** Format: t(LLLLLLLL)t(LLLLLLLLL)bL (Read-only) |
| * |
| * Required capability: SPINEL_CAP_RADIO_COEX |
| * |
| * The contents include two structures and two common variables, first structure corresponds to |
| * all transmit related coex counters, second structure provides the receive related counters. |
| * |
| * The transmit structure includes: |
| * 'L': NumTxRequest (The number of tx requests). |
| * 'L': NumTxGrantImmediate (The number of tx requests while grant was active). |
| * 'L': NumTxGrantWait (The number of tx requests while grant was inactive). |
| * 'L': NumTxGrantWaitActivated (The number of tx requests while grant was inactive that were |
| * ultimately granted). |
| * 'L': NumTxGrantWaitTimeout (The number of tx requests while grant was inactive that timed out). |
| * 'L': NumTxGrantDeactivatedDuringRequest (The number of tx requests that were in progress when grant was |
| * deactivated). |
| * 'L': NumTxDelayedGrant (The number of tx requests that were not granted within 50us). |
| * 'L': AvgTxRequestToGrantTime (The average time in usec from tx request to grant). |
| * |
| * The receive structure includes: |
| * 'L': NumRxRequest (The number of rx requests). |
| * 'L': NumRxGrantImmediate (The number of rx requests while grant was active). |
| * 'L': NumRxGrantWait (The number of rx requests while grant was inactive). |
| * 'L': NumRxGrantWaitActivated (The number of rx requests while grant was inactive that were |
| * ultimately granted). |
| * 'L': NumRxGrantWaitTimeout (The number of rx requests while grant was inactive that timed out). |
| * 'L': NumRxGrantDeactivatedDuringRequest (The number of rx requests that were in progress when grant was |
| * deactivated). |
| * 'L': NumRxDelayedGrant (The number of rx requests that were not granted within 50us). |
| * 'L': AvgRxRequestToGrantTime (The average time in usec from rx request to grant). |
| * 'L': NumRxGrantNone (The number of rx requests that completed without receiving grant). |
| * |
| * Two common variables: |
| * 'b': Stopped (Stats collection stopped due to saturation). |
| * 'L': NumGrantGlitch (The number of of grant glitches). |
| */ |
| SPINEL_PROP_RADIO_COEX_METRICS = SPINEL_PROP_PHY_EXT__BEGIN + 12, |
| |
| /// Radio Coex Enable |
| /** Format: `b` |
| * |
| * Required capability: SPINEL_CAP_RADIO_COEX |
| * |
| * Indicates if radio coex is enabled or disabled. Set to true to enable radio coex. |
| */ |
| SPINEL_PROP_RADIO_COEX_ENABLE = SPINEL_PROP_PHY_EXT__BEGIN + 13, |
| |
| SPINEL_PROP_PHY_EXT__END = 0x1300, |
| |
| SPINEL_PROP_MAC__BEGIN = 0x30, |
| |
| /// MAC Scan State |
| /** Format: `C` |
| * |
| * Possible values are from enumeration `spinel_scan_state_t`. |
| * |
| * SCAN_STATE_IDLE |
| * SCAN_STATE_BEACON |
| * SCAN_STATE_ENERGY |
| * SCAN_STATE_DISCOVER |
| * |
| * Set to `SCAN_STATE_BEACON` to start an active scan. |
| * Beacons will be emitted from `PROP_MAC_SCAN_BEACON`. |
| * |
| * Set to `SCAN_STATE_ENERGY` to start an energy scan. |
| * Channel energy result will be reported by emissions |
| * of `PROP_MAC_ENERGY_SCAN_RESULT` (per channel). |
| * |
| * Set to `SCAN_STATE_DISOVER` to start a Thread MLE discovery |
| * scan operation. Discovery scan result will be emitted from |
| * `PROP_MAC_SCAN_BEACON`. |
| * |
| * Value switches to `SCAN_STATE_IDLE` when scan is complete. |
| * |
| */ |
| SPINEL_PROP_MAC_SCAN_STATE = SPINEL_PROP_MAC__BEGIN + 0, |
| |
| /// MAC Scan Channel Mask |
| /** Format: `A(C)` |
| * |
| * List of channels to scan. |
| * |
| */ |
| SPINEL_PROP_MAC_SCAN_MASK = SPINEL_PROP_MAC__BEGIN + 1, |
| |
| /// MAC Scan Channel Period |
| /** Format: `S` |
| * Unit: milliseconds per channel |
| * |
| */ |
| SPINEL_PROP_MAC_SCAN_PERIOD = SPINEL_PROP_MAC__BEGIN + 2, |
| |
| /// MAC Scan Beacon |
| /** Format `Cct(ESSc)t(iCUdd)` - Asynchronous event only |
| * |
| * Scan beacons have two embedded structures which contain |
| * information about the MAC layer and the NET layer. Their |
| * format depends on the MAC and NET layer currently in use. |
| * The format below is for an 802.15.4 MAC with Thread: |
| * |
| * `C`: Channel |
| * `c`: RSSI of the beacon |
| * `t`: MAC layer properties (802.15.4 layer) |
| * `E`: Long address |
| * `S`: Short address |
| * `S`: PAN-ID |
| * `c`: LQI |
| * NET layer properties |
| * `i`: Protocol Number (SPINEL_PROTOCOL_TYPE_* values) |
| * `C`: Flags (SPINEL_BEACON_THREAD_FLAG_* values) |
| * `U`: Network Name |
| * `d`: XPANID |
| * `d`: Steering data |
| * |
| * Extra parameters may be added to each of the structures |
| * in the future, so care should be taken to read the length |
| * that prepends each structure. |
| * |
| */ |
| SPINEL_PROP_MAC_SCAN_BEACON = SPINEL_PROP_MAC__BEGIN + 3, |
| |
| /// MAC Long Address |
| /** Format: `E` |
| * |
| * The 802.15.4 long address of this node. |
| * |
| */ |
| SPINEL_PROP_MAC_15_4_LADDR = SPINEL_PROP_MAC__BEGIN + 4, |
| |
| /// MAC Short Address |
| /** Format: `S` |
| * |
| * The 802.15.4 short address of this node. |
| * |
| */ |
| SPINEL_PROP_MAC_15_4_SADDR = SPINEL_PROP_MAC__BEGIN + 5, |
| |
| /// MAC PAN ID |
| /** Format: `S` |
| * |
| * The 802.15.4 PANID this node is associated with. |
| * |
| */ |
| SPINEL_PROP_MAC_15_4_PANID = SPINEL_PROP_MAC__BEGIN + 6, |
| |
| /// MAC Stream Raw Enabled |
| /** Format: `b` |
| * |
| * Set to true to enable raw MAC frames to be emitted from |
| * `PROP_STREAM_RAW`. |
| * |
| */ |
| SPINEL_PROP_MAC_RAW_STREAM_ENABLED = SPINEL_PROP_MAC__BEGIN + 7, |
| |
| /// MAC Promiscuous Mode |
| /** Format: `C` |
| * |
| * Possible values are from enumeration |
| * `SPINEL_MAC_PROMISCUOUS_MODE_*`: |
| * |
| * `SPINEL_MAC_PROMISCUOUS_MODE_OFF` |
| * Normal MAC filtering is in place. |
| * |
| * `SPINEL_MAC_PROMISCUOUS_MODE_NETWORK` |
| * All MAC packets matching network are passed up |
| * the stack. |
| * |
| * `SPINEL_MAC_PROMISCUOUS_MODE_FULL` |
| * All decoded MAC packets are passed up the stack. |
| * |
| */ |
| SPINEL_PROP_MAC_PROMISCUOUS_MODE = SPINEL_PROP_MAC__BEGIN + 8, |
| |
| /// MAC Energy Scan Result |
| /** Format: `Cc` - Asynchronous event only |
| * |
| * This property is emitted during energy scan operation |
| * per scanned channel with following format: |
| * |
| * `C`: Channel |
| * `c`: RSSI (in dBm) |
| * |
| */ |
| SPINEL_PROP_MAC_ENERGY_SCAN_RESULT = SPINEL_PROP_MAC__BEGIN + 9, |
| |
| /// MAC Data Poll Period |
| /** Format: `L` |
| * Unit: millisecond |
| * The (user-specified) data poll (802.15.4 MAC Data Request) period |
| * in milliseconds. Value zero means there is no user-specified |
| * poll period, and the network stack determines the maximum period |
| * based on the MLE Child Timeout. |
| * |
| * If the value is non-zero, it specifies the maximum period between |
| * data poll transmissions. Note that the network stack may send data |
| * request transmissions more frequently when expecting a control-message |
| * (e.g., when waiting for an MLE Child ID Response). |
| * |
| */ |
| SPINEL_PROP_MAC_DATA_POLL_PERIOD = SPINEL_PROP_MAC__BEGIN + 10, |
| |
| SPINEL_PROP_MAC__END = 0x40, |
| |
| SPINEL_PROP_MAC_EXT__BEGIN = 0x1300, |
| |
| /// MAC Whitelist |
| /** Format: `A(t(Ec))` |
| * Required capability: `CAP_MAC_WHITELIST` |
| * |
| * Structure Parameters: |
| * |
| * `E`: EUI64 address of node |
| * `c`: Optional RSSI-override value. The value 127 indicates |
| * that the RSSI-override feature is not enabled for this |
| * address. If this value is omitted when setting or |
| * inserting, it is assumed to be 127. This parameter is |
| * ignored when removing. |
| */ |
| SPINEL_PROP_MAC_WHITELIST = SPINEL_PROP_MAC_EXT__BEGIN + 0, |
| |
| /// MAC Whitelist Enabled Flag |
| /** Format: `b` |
| * Required capability: `CAP_MAC_WHITELIST` |
| * |
| */ |
| SPINEL_PROP_MAC_WHITELIST_ENABLED = SPINEL_PROP_MAC_EXT__BEGIN + 1, |
| |
| /// MAC Extended Address |
| /** Format: `E` |
| * |
| * Specified by Thread. Randomly-chosen, but non-volatile EUI-64. |
| */ |
| SPINEL_PROP_MAC_EXTENDED_ADDR = SPINEL_PROP_MAC_EXT__BEGIN + 2, |
| |
| /// MAC Source Match Enabled Flag |
| /** Format: `b` |
| * Required Capability: SPINEL_CAP_MAC_RAW or SPINEL_CAP_CONFIG_RADIO |
| * |
| * Set to true to enable radio source matching or false to disable it. |
| * The source match functionality is used by radios when generating |
| * ACKs. The short and extended address lists are used for setting |
| * the Frame Pending bit in the ACKs. |
| * |
| */ |
| SPINEL_PROP_MAC_SRC_MATCH_ENABLED = SPINEL_PROP_MAC_EXT__BEGIN + 3, |
| |
| /// MAC Source Match Short Address List |
| /** Format: `A(S)` |
| * Required Capability: SPINEL_CAP_MAC_RAW or SPINEL_CAP_CONFIG_RADIO |
| * |
| */ |
| SPINEL_PROP_MAC_SRC_MATCH_SHORT_ADDRESSES = SPINEL_PROP_MAC_EXT__BEGIN + 4, |
| |
| /// MAC Source Match Extended Address List |
| /** Format: `A(E)` |
| * Required Capability: SPINEL_CAP_MAC_RAW or SPINEL_CAP_CONFIG_RADIO |
| * |
| */ |
| SPINEL_PROP_MAC_SRC_MATCH_EXTENDED_ADDRESSES = SPINEL_PROP_MAC_EXT__BEGIN + 5, |
| |
| /// MAC Blacklist |
| /** Format: `A(t(E))` |
| * Required capability: `CAP_MAC_WHITELIST` |
| * |
| * Structure Parameters: |
| * |
| * `E`: EUI64 address of node |
| * |
| */ |
| SPINEL_PROP_MAC_BLACKLIST = SPINEL_PROP_MAC_EXT__BEGIN + 6, |
| |
| /// MAC Blacklist Enabled Flag |
| /** Format: `b` |
| * Required capability: `CAP_MAC_WHITELIST` |
| */ |
| SPINEL_PROP_MAC_BLACKLIST_ENABLED = SPINEL_PROP_MAC_EXT__BEGIN + 7, |
| |
| /// MAC Received Signal Strength Filter |
| /** Format: `A(t(Ec))` |
| * Required capability: `CAP_MAC_WHITELIST` |
| * |
| * Structure Parameters: |
| * |
| * * `E`: Optional EUI64 address of node. Set default RSS if not included. |
| * * `c`: Fixed RSS. 127 means not set. |
| */ |
| SPINEL_PROP_MAC_FIXED_RSS = SPINEL_PROP_MAC_EXT__BEGIN + 8, |
| |
| /// The CCA failure rate |
| /** Format: `S` |
| * |
| * This property provides the current CCA (Clear Channel Assessment) failure rate. |
| * |
| * Maximum value `0xffff` corresponding to 100% failure rate. |
| * |
| */ |
| SPINEL_PROP_MAC_CCA_FAILURE_RATE = SPINEL_PROP_MAC_EXT__BEGIN + 9, |
| |
| /// MAC Max direct retry number |
| /** Format: `C` |
| * |
| * The maximum (user-specified) number of direct frame transmission retries. |
| * |
| */ |
| SPINEL_PROP_MAC_MAX_RETRY_NUMBER_DIRECT = SPINEL_PROP_MAC_EXT__BEGIN + 10, |
| |
| /// MAC Max indirect retry number |
| /** Format: `C` |
| * Required capability: `SPINEL_CAP_CONFIG_FTD` |
| * |
| * The maximum (user-specified) number of indirect frame transmission retries. |
| * |
| */ |
| SPINEL_PROP_MAC_MAX_RETRY_NUMBER_INDIRECT = SPINEL_PROP_MAC_EXT__BEGIN + 11, |
| |
| SPINEL_PROP_MAC_EXT__END = 0x1400, |
| |
| SPINEL_PROP_NET__BEGIN = 0x40, |
| |
| /// Network Is Saved (Is Commissioned) |
| /** Format: `b` - Read only |
| * |
| * Returns true if there is a network state stored/saved. |
| * |
| */ |
| SPINEL_PROP_NET_SAVED = SPINEL_PROP_NET__BEGIN + 0, |
| |
| /// Network Interface Status |
| /** Format `b` - Read-write |
| * |
| * Network interface up/down status. Write true to bring |
| * interface up and false to bring interface down. |
| * |
| */ |
| SPINEL_PROP_NET_IF_UP = SPINEL_PROP_NET__BEGIN + 1, |
| |
| /// Thread Stack Operational Status |
| /** Format `b` - Read-write |
| * |
| * Thread stack operational status. Write true to start |
| * Thread stack and false to stop it. |
| * |
| */ |
| SPINEL_PROP_NET_STACK_UP = SPINEL_PROP_NET__BEGIN + 2, |
| |
| /// Thread Device Role |
| /** Format `C` - Read-write |
| * |
| * Possible values are from enumeration `spinel_net_role_t` |
| * |
| * SPINEL_NET_ROLE_DETACHED = 0, |
| * SPINEL_NET_ROLE_CHILD = 1, |
| * SPINEL_NET_ROLE_ROUTER = 2, |
| * SPINEL_NET_ROLE_LEADER = 3, |
| * |
| */ |
| SPINEL_PROP_NET_ROLE = SPINEL_PROP_NET__BEGIN + 3, |
| |
| /// Thread Network Name |
| /** Format `U` - Read-write |
| * |
| */ |
| SPINEL_PROP_NET_NETWORK_NAME = SPINEL_PROP_NET__BEGIN + 4, |
| |
| /// Thread Network Extended PAN ID |
| /** Format `D` - Read-write |
| * |
| */ |
| SPINEL_PROP_NET_XPANID = SPINEL_PROP_NET__BEGIN + 5, |
| |
| /// Thread Network Master Key |
| /** Format `D` - Read-write |
| * |
| */ |
| SPINEL_PROP_NET_MASTER_KEY = SPINEL_PROP_NET__BEGIN + 6, |
| |
| /// Thread Network Key Sequence Counter |
| /** Format `L` - Read-write |
| * |
| */ |
| SPINEL_PROP_NET_KEY_SEQUENCE_COUNTER = SPINEL_PROP_NET__BEGIN + 7, |
| |
| /// Thread Network Partition Id |
| /** Format `L` - Read-write |
| * |
| * The partition ID of the partition that this node is a |
| * member of. |
| * |
| */ |
| SPINEL_PROP_NET_PARTITION_ID = SPINEL_PROP_NET__BEGIN + 8, |
| |
| /// Require Join Existing |
| /** Format: `b` |
| * Default Value: `false` |
| * |
| * This flag is typically used for nodes that are associating with an |
| * existing network for the first time. If this is set to `true` before |
| * `PROP_NET_STACK_UP` is set to `true`, the |
| * creation of a new partition at association is prevented. If the node |
| * cannot associate with an existing partition, `PROP_LAST_STATUS` will |
| * emit a status that indicates why the association failed and |
| * `PROP_NET_STACK_UP` will automatically revert to `false`. |
| * |
| * Once associated with an existing partition, this flag automatically |
| * reverts to `false`. |
| * |
| * The behavior of this property being set to `true` when |
| * `PROP_NET_STACK_UP` is already set to `true` is undefined. |
| * |
| */ |
| SPINEL_PROP_NET_REQUIRE_JOIN_EXISTING = SPINEL_PROP_NET__BEGIN + 9, |
| |
| /// Thread Network Key Switch Guard Time |
| /** Format `L` - Read-write |
| * |
| */ |
| SPINEL_PROP_NET_KEY_SWITCH_GUARDTIME = SPINEL_PROP_NET__BEGIN + 10, |
| |
| /// Thread Network PSKc |
| /** Format `D` - Read-write |
| * |
| */ |
| SPINEL_PROP_NET_PSKC = SPINEL_PROP_NET__BEGIN + 11, |
| |
| SPINEL_PROP_NET__END = 0x50, |
| |
| SPINEL_PROP_NET_EXT__BEGIN = 0x1400, |
| SPINEL_PROP_NET_EXT__END = 0x1500, |
| |
| SPINEL_PROP_THREAD__BEGIN = 0x50, |
| |
| /// Thread Leader IPv6 Address |
| /** Format `6` - Read only |
| * |
| */ |
| SPINEL_PROP_THREAD_LEADER_ADDR = SPINEL_PROP_THREAD__BEGIN + 0, |
| |
| /// Thread Parent Info |
| /** Format: `ESLccCC` - Read only |
| * |
| * `E`: Extended address |
| * `S`: RLOC16 |
| * `L`: Age (seconds since last heard from) |
| * `c`: Average RSS (in dBm) |
| * `c`: Last RSSI (in dBm) |
| * `C`: Link Quality In |
| * `C`: Link Quality Out |
| * |
| */ |
| SPINEL_PROP_THREAD_PARENT = SPINEL_PROP_THREAD__BEGIN + 1, |
| |
| /// Thread Child Table |
| /** Format: [A(t(ESLLCCcCc)] - Read only |
| * |
| * Data per item is: |
| * |
| * `E`: Extended address |
| * `S`: RLOC16 |
| * `L`: Timeout (in seconds) |
| * `L`: Age (in seconds) |
| * `L`: Network Data version |
| * `C`: Link Quality In |
| * `c`: Average RSS (in dBm) |
| * `C`: Mode (bit-flags) |
| * `c`: Last RSSI (in dBm) |
| * |
| */ |
| SPINEL_PROP_THREAD_CHILD_TABLE = SPINEL_PROP_THREAD__BEGIN + 2, |
| |
| /// Thread Leader Router Id |
| /** Format `C` - Read only |
| * |
| * The router-id of the current leader. |
| * |
| */ |
| SPINEL_PROP_THREAD_LEADER_RID = SPINEL_PROP_THREAD__BEGIN + 3, |
| |
| /// Thread Leader Weight |
| /** Format `C` - Read only |
| * |
| * The leader weight of the current leader. |
| * |
| */ |
| SPINEL_PROP_THREAD_LEADER_WEIGHT = SPINEL_PROP_THREAD__BEGIN + 4, |
| |
| /// Thread Local Leader Weight |
| /** Format `C` - Read only |
| * |
| * The leader weight of this node. |
| * |
| */ |
| SPINEL_PROP_THREAD_LOCAL_LEADER_WEIGHT = SPINEL_PROP_THREAD__BEGIN + 5, |
| |
| /// Thread Local Network Data |
| /** Format `D` - Read only |
| * |
| */ |
| SPINEL_PROP_THREAD_NETWORK_DATA = SPINEL_PROP_THREAD__BEGIN + 6, |
| |
| /// Thread Local Network Data Version |
| /** Format `C` - Read only |
| * |
| */ |
| SPINEL_PROP_THREAD_NETWORK_DATA_VERSION = SPINEL_PROP_THREAD__BEGIN + 7, |
| |
| /// Thread Local Stable Network Data |
| /** Format `D` - Read only |
| * |
| */ |
| SPINEL_PROP_THREAD_STABLE_NETWORK_DATA = SPINEL_PROP_THREAD__BEGIN + 8, |
| |
| /// Thread Local Stable Network Data Version |
| /** Format `C` - Read only |
| * |
| */ |
| SPINEL_PROP_THREAD_STABLE_NETWORK_DATA_VERSION = SPINEL_PROP_THREAD__BEGIN + 9, |
| |
| /// On-Mesh Prefixes |
| /** Format: `A(t(6CbCbS))` |
| * |
| * Data per item is: |
| * |
| * `6`: IPv6 Prefix |
| * `C`: Prefix length in bits |
| * `b`: Stable flag |
| * `C`: TLV flags |
| * `b`: "Is defined locally" flag. Set if this network was locally |
| * defined. Assumed to be true for set, insert and replace. Clear if |
| * the on mesh network was defined by another node. |
| * `S`: The RLOC16 of the device that registered this on-mesh prefix entry. |
| * This value is not used and ignored when adding an on-mesh prefix. |
| * |
| */ |
| SPINEL_PROP_THREAD_ON_MESH_NETS = SPINEL_PROP_THREAD__BEGIN + 10, |
| |
| /// Off-mesh routes |
| /** Format: [A(t(6CbCbb))] |
| * |
| * Data per item is: |
| * |
| * `6`: Route Prefix |
| * `C`: Prefix length in bits |
| * `b`: Stable flag |
| * `C`: Route preference flags |
| * `b`: "Is defined locally" flag. Set if this route info was locally |
| * defined as part of local network data. Assumed to be true for set, |
| * insert and replace. Clear if the route is part of partition's network |
| * data. |
| * `b`: "Next hop is this device" flag. Set if the next hop for the |
| * route is this device itself (i.e., route was added by this device) |
| * This value is ignored when adding an external route. For any added |
| * route the next hop is this device. |
| * `S`: The RLOC16 of the device that registered this route entry. |
| * This value is not used and ignored when adding a route. |
| * |
| */ |
| SPINEL_PROP_THREAD_OFF_MESH_ROUTES = SPINEL_PROP_THREAD__BEGIN + 11, |
| |
| /// Thread Assisting Ports |
| /** Format `A(S)` |
| * |
| * Array of port numbers. |
| */ |
| SPINEL_PROP_THREAD_ASSISTING_PORTS = SPINEL_PROP_THREAD__BEGIN + 12, |
| |
| /// Thread Allow Local Network Data Change |
| /** Format `b` - Read-write |
| * |
| * Set to true before changing local net data. Set to false when finished. |
| * This allows changes to be aggregated into a single event. |
| * |
| */ |
| SPINEL_PROP_THREAD_ALLOW_LOCAL_NET_DATA_CHANGE = SPINEL_PROP_THREAD__BEGIN + 13, |
| |
| /// Thread Mode |
| /** Format: `C` |
| * |
| * This property contains the value of the mode |
| * TLV for this node. The meaning of the bits in this |
| * bit-field are defined by section 4.5.2 of the Thread |
| * specification. |
| * |
| * The values `SPINEL_THREAD_MODE_*` defines the bit-fields |
| * |
| */ |
| SPINEL_PROP_THREAD_MODE = SPINEL_PROP_THREAD__BEGIN + 14, |
| |
| SPINEL_PROP_THREAD__END = 0x60, |
| |
| SPINEL_PROP_THREAD_EXT__BEGIN = 0x1500, |
| |
| /// Thread Child Timeout |
| /** Format: `L` |
| * Unit: Seconds |
| * |
| * Used when operating in the Child role. |
| */ |
| SPINEL_PROP_THREAD_CHILD_TIMEOUT = SPINEL_PROP_THREAD_EXT__BEGIN + 0, |
| |
| /// Thread RLOC16 |
| /** Format: `S` |
| * |
| */ |
| SPINEL_PROP_THREAD_RLOC16 = SPINEL_PROP_THREAD_EXT__BEGIN + 1, |
| |
| /// Thread Router Upgrade Threshold |
| /** Format: `C` |
| * |
| */ |
| SPINEL_PROP_THREAD_ROUTER_UPGRADE_THRESHOLD = SPINEL_PROP_THREAD_EXT__BEGIN + 2, |
| |
| /// Thread Context Reuse Delay |
| /** Format: `L` |
| * |
| */ |
| SPINEL_PROP_THREAD_CONTEXT_REUSE_DELAY = SPINEL_PROP_THREAD_EXT__BEGIN + 3, |
| |
| /// Thread Network ID Timeout |
| /** Format: `C` |
| * |
| */ |
| SPINEL_PROP_THREAD_NETWORK_ID_TIMEOUT = SPINEL_PROP_THREAD_EXT__BEGIN + 4, |
| |
| /// List of active thread router ids |
| /** Format: `A(C)` |
| * |
| * Note that some implementations may not support CMD_GET_VALUE |
| * router ids, but may support CMD_REMOVE_VALUE when the node is |
| * a leader. |
| * |
| */ |
| SPINEL_PROP_THREAD_ACTIVE_ROUTER_IDS = SPINEL_PROP_THREAD_EXT__BEGIN + 5, |
| |
| /// Forward IPv6 packets that use RLOC16 addresses to HOST. |
| /** Format: `b` |
| * |
| * Allow host to directly observe all IPv6 packets received by the NCP, |
| * including ones sent to the RLOC16 address. |
| * |
| * Default is false. |
| * |
| */ |
| SPINEL_PROP_THREAD_RLOC16_DEBUG_PASSTHRU = SPINEL_PROP_THREAD_EXT__BEGIN + 6, |
| |
| /// Router Role Enabled |
| /** Format `b` |
| * |
| * Allows host to indicate whether or not the router role is enabled. |
| * If current role is a router, setting this property to `false` starts |
| * a re-attach process as an end-device. |
| * |
| */ |
| SPINEL_PROP_THREAD_ROUTER_ROLE_ENABLED = SPINEL_PROP_THREAD_EXT__BEGIN + 7, |
| |
| /// Thread Router Downgrade Threshold |
| /** Format: `C` |
| * |
| */ |
| SPINEL_PROP_THREAD_ROUTER_DOWNGRADE_THRESHOLD = SPINEL_PROP_THREAD_EXT__BEGIN + 8, |
| |
| /// Thread Router Selection Jitter |
| /** Format: `C` |
| * |
| */ |
| SPINEL_PROP_THREAD_ROUTER_SELECTION_JITTER = SPINEL_PROP_THREAD_EXT__BEGIN + 9, |
| |
| /// Thread Preferred Router Id |
| /** Format: `C` - Write only |
| * |
| * Specifies the preferred Router Id. Upon becoming a router/leader the node |
| * attempts to use this Router Id. If the preferred Router Id is not set or |
| * if it can not be used, a randomly generated router id is picked. This |
| * property can be set only when the device role is either detached or |
| * disabled. |
| * |
| */ |
| SPINEL_PROP_THREAD_PREFERRED_ROUTER_ID = SPINEL_PROP_THREAD_EXT__BEGIN + 10, |
| |
| /// Thread Neighbor Table |
| /** Format: `A(t(ESLCcCbLLc))` - Read only |
| * |
| * Data per item is: |
| * |
| * `E`: Extended address |
| * `S`: RLOC16 |
| * `L`: Age (in seconds) |
| * `C`: Link Quality In |
| * `c`: Average RSS (in dBm) |
| * `C`: Mode (bit-flags) |
| * `b`: `true` if neighbor is a child, `false` otherwise. |
| * `L`: Link Frame Counter |
| * `L`: MLE Frame Counter |
| * `c`: The last RSSI (in dBm) |
| * |
| */ |
| SPINEL_PROP_THREAD_NEIGHBOR_TABLE = SPINEL_PROP_THREAD_EXT__BEGIN + 11, |
| |
| /// Thread Max Child Count |
| /** Format: `C` |
| * |
| * Specifies the maximum number of children currently allowed. |
| * This parameter can only be set when Thread protocol operation |
| * has been stopped. |
| * |
| */ |
| SPINEL_PROP_THREAD_CHILD_COUNT_MAX = SPINEL_PROP_THREAD_EXT__BEGIN + 12, |
| |
| /// Leader Network Data |
| /** Format: `D` - Read only |
| * |
| */ |
| SPINEL_PROP_THREAD_LEADER_NETWORK_DATA = SPINEL_PROP_THREAD_EXT__BEGIN + 13, |
| |
| /// Stable Leader Network Data |
| /** Format: `D` - Read only |
| * |
| */ |
| SPINEL_PROP_THREAD_STABLE_LEADER_NETWORK_DATA = SPINEL_PROP_THREAD_EXT__BEGIN + 14, |
| |
| /// Thread Joiner Data |
| /** Format `A(T(ULE))` |
| * PSKd, joiner timeout, eui64 (optional) |
| * |
| * This property is being deprecated by SPINEL_PROP_MESHCOP_COMMISSIONER_JOINERS. |
| * |
| */ |
| SPINEL_PROP_THREAD_JOINERS = SPINEL_PROP_THREAD_EXT__BEGIN + 15, |
| |
| /// Thread Commissioner Enable |
| /** Format `b` |
| * |
| * Default value is `false`. |
| * |
| * This property is being deprecated by SPINEL_PROP_MESHCOP_COMMISSIONER_STATE. |
| * |
| */ |
| SPINEL_PROP_THREAD_COMMISSIONER_ENABLED = SPINEL_PROP_THREAD_EXT__BEGIN + 16, |
| |
| /// Thread TMF proxy enable |
| /** Format `b` |
| * Required capability: `SPINEL_CAP_THREAD_TMF_PROXY` |
| * |
| * This property is deprecated. |
| * |
| */ |
| SPINEL_PROP_THREAD_TMF_PROXY_ENABLED = SPINEL_PROP_THREAD_EXT__BEGIN + 17, |
| |
| /// Thread TMF proxy stream |
| /** Format `dSS` |
| * Required capability: `SPINEL_CAP_THREAD_TMF_PROXY` |
| * |
| * This property is deprecated. Please see `SPINEL_PROP_THREAD_UDP_FORWARD_STREAM`. |
| * |
| */ |
| SPINEL_PROP_THREAD_TMF_PROXY_STREAM = SPINEL_PROP_THREAD_EXT__BEGIN + 18, |
| |
| /// Thread "joiner" flag used during discovery scan operation |
| /** Format `b` |
| * |
| * This property defines the Joiner Flag value in the Discovery Request TLV. |
| * |
| * Default value is `false`. |
| * |
| */ |
| SPINEL_PROP_THREAD_DISCOVERY_SCAN_JOINER_FLAG = SPINEL_PROP_THREAD_EXT__BEGIN + 19, |
| |
| /// Enable EUI64 filtering for discovery scan operation. |
| /** Format `b` |
| * |
| * Default value is `false` |
| * |
| */ |
| SPINEL_PROP_THREAD_DISCOVERY_SCAN_ENABLE_FILTERING = SPINEL_PROP_THREAD_EXT__BEGIN + 20, |
| |
| /// PANID used for Discovery scan operation (used for PANID filtering). |
| /** Format: `S` |
| * |
| * Default value is 0xffff (Broadcast PAN) to disable PANID filtering |
| * |
| */ |
| SPINEL_PROP_THREAD_DISCOVERY_SCAN_PANID = SPINEL_PROP_THREAD_EXT__BEGIN + 21, |
| |
| /// Thread (out of band) steering data for MLE Discovery Response. |
| /** Format `E` - Write only |
| * |
| * Required capability: SPINEL_CAP_OOB_STEERING_DATA. |
| * |
| * Writing to this property allows to set/update the MLE |
| * Discovery Response steering data out of band. |
| * |
| * - All zeros to clear the steering data (indicating that |
| * there is no steering data). |
| * - All 0xFFs to set steering data/bloom filter to |
| * accept/allow all. |
| * - A specific EUI64 which is then added to current steering |
| * data/bloom filter. |
| * |
| */ |
| SPINEL_PROP_THREAD_STEERING_DATA = SPINEL_PROP_THREAD_EXT__BEGIN + 22, |
| |
| /// Thread Router Table. |
| /** Format: `A(t(ESCCCCCCb)` - Read only |
| * |
| * Data per item is: |
| * |
| * `E`: IEEE 802.15.4 Extended Address |
| * `S`: RLOC16 |
| * `C`: Router ID |
| * `C`: Next hop to router |
| * `C`: Path cost to router |
| * `C`: Link Quality In |
| * `C`: Link Quality Out |
| * `C`: Age (seconds since last heard) |
| * `b`: Link established with Router ID or not. |
| * |
| */ |
| SPINEL_PROP_THREAD_ROUTER_TABLE = SPINEL_PROP_THREAD_EXT__BEGIN + 23, |
| |
| /// Thread Active Operational Dataset |
| /** Format: `A(t(iD))` - Read-Write |
| * |
| * This property provides access to current Thread Active Operational Dataset. A Thread device maintains the |
| * Operational Dataset that it has stored locally and the one currently in use by the partition to which it is |
| * attached. This property corresponds to the locally stored Dataset on the device. |
| * |
| * Operational Dataset consists of a set of supported properties (e.g., channel, master key, network name, PAN id, |
| * etc). Note that not all supported properties may be present (have a value) in a Dataset. |
| * |
| * The Dataset value is encoded as an array of structs containing pairs of property key (as `i`) followed by the |
| * property value (as `D`). The property value must follow the format associated with the corresponding property. |
| * |
| * On write, any unknown/unsupported property keys must be ignored. |
| * |
| * The following properties can be included in a Dataset list: |
| * |
| * SPINEL_PROP_DATASET_ACTIVE_TIMESTAMP |
| * SPINEL_PROP_PHY_CHAN |
| * SPINEL_PROP_PHY_CHAN_SUPPORTED (Channel Mask Page 0) |
| * SPINEL_PROP_NET_MASTER_KEY |
| * SPINEL_PROP_NET_NETWORK_NAME |
| * SPINEL_PROP_NET_XPANID |
| * SPINEL_PROP_MAC_15_4_PANID |
| * SPINEL_PROP_IPV6_ML_PREFIX |
| * SPINEL_PROP_NET_PSKC |
| * SPINEL_PROP_DATASET_SECURITY_POLICY |
| * |
| */ |
| SPINEL_PROP_THREAD_ACTIVE_DATASET = SPINEL_PROP_THREAD_EXT__BEGIN + 24, |
| |
| /// Thread Pending Operational Dataset |
| /** Format: `A(t(iD))` - Read-Write |
| * |
| * This property provide access to current locally stored Pending Operational Dataset. |
| * |
| * The formatting of this property follows the same rules as in SPINEL_PROP_THREAD_ACTIVE_DATASET. |
| * |
| * In addition supported properties in SPINEL_PROP_THREAD_ACTIVE_DATASET, the following properties can also |
| * be included in the Pending Dataset: |
| * |
| * SPINEL_PROP_DATASET_PENDING_TIMESTAMP |
| * SPINEL_PROP_DATASET_DELAY_TIMER |
| * |
| */ |
| SPINEL_PROP_THREAD_PENDING_DATASET = SPINEL_PROP_THREAD_EXT__BEGIN + 25, |
| |
| /// Send MGMT_SET Thread Active Operational Dataset |
| /** Format: `A(t(iD))` - Write only |
| * |
| * The formatting of this property follows the same rules as in SPINEL_PROP_THREAD_ACTIVE_DATASET. |
| * |
| * This is write-only property. When written, it triggers a MGMT_ACTIVE_SET meshcop command to be sent to leader |
| * with the given Dataset. The spinel frame response should be a `LAST_STATUS` with the status of the transmission |
| * of MGMT_ACTIVE_SET command. |
| * |
| * In addition to supported properties in SPINEL_PROP_THREAD_ACTIVE_DATASET, the following property can be |
| * included in the Dataset (to allow for custom raw TLVs): |
| * |
| * SPINEL_PROP_DATASET_RAW_TLVS |
| * |
| */ |
| SPINEL_PROP_THREAD_MGMT_SET_ACTIVE_DATASET = SPINEL_PROP_THREAD_EXT__BEGIN + 26, |
| |
| /// Send MGMT_SET Thread Pending Operational Dataset |
| /** Format: `A(t(iD))` - Write only |
| * |
| * This property is similar to SPINEL_PROP_THREAD_PENDING_DATASET and follows the same format and rules. |
| * |
| * In addition to supported properties in SPINEL_PROP_THREAD_PENDING_DATASET, the following property can be |
| * included the Dataset (to allow for custom raw TLVs to be provided). |
| * |
| * SPINEL_PROP_DATASET_RAW_TLVS |
| * |
| */ |
| SPINEL_PROP_THREAD_MGMT_SET_PENDING_DATASET = SPINEL_PROP_THREAD_EXT__BEGIN + 27, |
| |
| /// Operational Dataset Active Timestamp |
| /** Format: `X` - No direct read or write |
| * |
| * It can only be included in one of the Dataset related properties below: |
| * |
| * SPINEL_PROP_THREAD_ACTIVE_DATASET |
| * SPINEL_PROP_THREAD_PENDING_DATASET |
| * SPINEL_PROP_THREAD_MGMT_SET_ACTIVE_DATASET |
| * SPINEL_PROP_THREAD_MGMT_SET_PENDING_DATASET |
| * SPINEL_PROP_THREAD_MGMT_GET_ACTIVE_DATASET |
| * SPINEL_PROP_THREAD_MGMT_GET_PENDING_DATASET |
| * |
| */ |
| SPINEL_PROP_DATASET_ACTIVE_TIMESTAMP = SPINEL_PROP_THREAD_EXT__BEGIN + 28, |
| |
| /// Operational Dataset Pending Timestamp |
| /** Format: `X` - No direct read or write |
| * |
| * It can only be included in one of the Pending Dataset properties: |
| * |
| * SPINEL_PROP_THREAD_PENDING_DATASET |
| * SPINEL_PROP_THREAD_MGMT_SET_PENDING_DATASET |
| * SPINEL_PROP_THREAD_MGMT_GET_PENDING_DATASET |
| * |
| */ |
| SPINEL_PROP_DATASET_PENDING_TIMESTAMP = SPINEL_PROP_THREAD_EXT__BEGIN + 29, |
| |
| /// Operational Dataset Delay Timer |
| /** Format: `L` - No direct read or write |
| * |
| * Delay timer (in ms) specifies the time renaming until Thread devices overwrite the value in the Active |
| * Operational Dataset with the corresponding values in the Pending Operational Dataset. |
| * |
| * It can only be included in one of the Pending Dataset properties: |
| * |
| * SPINEL_PROP_THREAD_PENDING_DATASET |
| * SPINEL_PROP_THREAD_MGMT_SET_PENDING_DATASET |
| * SPINEL_PROP_THREAD_MGMT_GET_PENDING_DATASET |
| * |
| */ |
| SPINEL_PROP_DATASET_DELAY_TIMER = SPINEL_PROP_THREAD_EXT__BEGIN + 30, |
| |
| /// Operational Dataset Security Policy |
| /** Format: `SC` - No direct read or write |
| * |
| * It can only be included in one of the Dataset related properties below: |
| * |
| * SPINEL_PROP_THREAD_ACTIVE_DATASET |
| * SPINEL_PROP_THREAD_PENDING_DATASET |
| * SPINEL_PROP_THREAD_MGMT_SET_ACTIVE_DATASET |
| * SPINEL_PROP_THREAD_MGMT_SET_PENDING_DATASET |
| * SPINEL_PROP_THREAD_MGMT_GET_ACTIVE_DATASET |
| * SPINEL_PROP_THREAD_MGMT_GET_PENDING_DATASET |
| * |
| * Content is |
| * `S` : Key Rotation Time (in units of hour) |
| * `C` : Security Policy Flags (as specified in Thread 1.1 Section 8.10.1.15) |
| * |
| */ |
| SPINEL_PROP_DATASET_SECURITY_POLICY = SPINEL_PROP_THREAD_EXT__BEGIN + 31, |
| |
| /// Operational Dataset Additional Raw TLVs |
| /** Format: `D` - No direct read or write |
| * |
| * This property defines extra raw TLVs that can be added to an Operational DataSet. |
| * |
| * It can only be included in one of the following Dataset properties: |
| * |
| * SPINEL_PROP_THREAD_MGMT_SET_ACTIVE_DATASET |
| * SPINEL_PROP_THREAD_MGMT_SET_PENDING_DATASET |
| * SPINEL_PROP_THREAD_MGMT_GET_ACTIVE_DATASET |
| * SPINEL_PROP_THREAD_MGMT_GET_PENDING_DATASET |
| * |
| */ |
| SPINEL_PROP_DATASET_RAW_TLVS = SPINEL_PROP_THREAD_EXT__BEGIN + 32, |
| |
| /// Child table addresses |
| /** Format: `A(t(ESA(6)))` - Read only |
| * |
| * This property provides the list of all addresses associated with every child |
| * including any registered IPv6 addresses. |
| * |
| * Data per item is: |
| * |
| * `E`: Extended address of the child |
| * `S`: RLOC16 of the child |
| * `A(6)`: List of IPv6 addresses registered by the child (if any) |
| * |
| */ |
| SPINEL_PROP_THREAD_CHILD_TABLE_ADDRESSES = SPINEL_PROP_THREAD_EXT__BEGIN + 33, |
| |
| /// Neighbor Table Frame and Message Error Rates |
| /** Format: `A(t(ESSScc))` |
| * Required capability: `CAP_ERROR_RATE_TRACKING` |
| * |
| * This property provides link quality related info including |
| * frame and (IPv6) message error rates for all neighbors. |
| * |
| * With regards to message error rate, note that a larger (IPv6) |
| * message can be fragmented and sent as multiple MAC frames. The |
| * message transmission is considered a failure, if any of its |
| * fragments fail after all MAC retry attempts. |
| * |
| * Data per item is: |
| * |
| * `E`: Extended address of the neighbor |
| * `S`: RLOC16 of the neighbor |
| * `S`: Frame error rate (0 -> 0%, 0xffff -> 100%) |
| * `S`: Message error rate (0 -> 0%, 0xffff -> 100%) |
| * `c`: Average RSSI (in dBm) |
| * `c`: Last RSSI (in dBm) |
| * |
| */ |
| SPINEL_PROP_THREAD_NEIGHBOR_TABLE_ERROR_RATES = SPINEL_PROP_THREAD_EXT__BEGIN + 34, |
| |
| /// EID (Endpoint Identifier) IPv6 Address Cache Table |
| /** Format `A(t(6SCCt(bL6)t(bSS))) |
| * |
| * This property provides Thread EID address cache table. |
| * |
| * Data per item is: |
| * |
| * `6` : Target IPv6 address |
| * `S` : RLOC16 of target |
| * `C` : Age (order of use, 0 indicates most recently used entry) |
| * `C` : Entry state (values are defined by enumeration `SPINEL_ADDRESS_CACHE_ENTRY_STATE_*`). |
| * |
| * `t` : Info when state is `SPINEL_ADDRESS_CACHE_ENTRY_STATE_CACHED` |
| * `b` : Indicates whether last transaction time and ML-EID are valid. |
| * `L` : Last transaction time |
| * `6` : Mesh-local EID |
| * |
| * `t` : Info when state is other than `SPINEL_ADDRESS_CACHE_ENTRY_STATE_CACHED` |
| * `b` : Indicates whether the entry can be evicted. |
| * `S` : Timeout in seconds |
| * `S` : Retry delay (applicable if in query-retry state). |
| * |
| */ |
| SPINEL_PROP_THREAD_ADDRESS_CACHE_TABLE = SPINEL_PROP_THREAD_EXT__BEGIN + 35, |
| |
| /// Thread UDP forward stream |
| /** Format `dS6S` |
| * Required capability: `SPINEL_CAP_THREAD_UDP_FORWARD` |
| * |
| * This property helps exchange UDP packets with host. |
| * |
| * `d`: UDP payload |
| * `S`: Remote UDP port |
| * `6`: Remote IPv6 address |
| * `S`: Local UDP port |
| * |
| */ |
| SPINEL_PROP_THREAD_UDP_FORWARD_STREAM = SPINEL_PROP_THREAD_EXT__BEGIN + 36, |
| |
| /// Send MGMT_GET Thread Active Operational Dataset |
| /** Format: `A(t(iD))` - Write only |
| * |
| * The formatting of this property follows the same rules as in SPINEL_PROP_THREAD_MGMT_SET_ACTIVE_DATASET. This |
| * property further allows the sender to not include a value associated with properties in formating of `t(iD)`, |
| * i.e., it should accept either a `t(iD)` or a `t(i)` encoding (in both cases indicating that the associated |
| * Dataset property should be requested as part of MGMT_GET command). |
| * |
| * This is write-only property. When written, it triggers a MGMT_ACTIVE_GET meshcop command to be sent to leader |
| * requesting the Dataset related properties from the format. The spinel frame response should be a `LAST_STATUS` |
| * with the status of the transmission of MGMT_ACTIVE_GET command. |
| * |
| * In addition to supported properties in SPINEL_PROP_THREAD_MGMT_SET_ACTIVE_DATASET, the following property can be |
| * optionally included in the Dataset: |
| * |
| * SPINEL_PROP_DATASET_DEST_ADDRESS |
| * |
| */ |
| SPINEL_PROP_THREAD_MGMT_GET_ACTIVE_DATASET = SPINEL_PROP_THREAD_EXT__BEGIN + 37, |
| |
| /// Send MGMT_GET Thread Pending Operational Dataset |
| /** Format: `A(t(iD))` - Write only |
| * |
| * The formatting of this property follows the same rules as in SPINEL_PROP_THREAD_MGMT_GET_ACTIVE_DATASET. |
| * |
| * This is write-only property. When written, it triggers a MGMT_PENDING_GET meshcop command to be sent to leader |
| * with the given Dataset. The spinel frame response should be a `LAST_STATUS` with the status of the transmission |
| * of MGMT_PENDING_GET command. |
| * |
| */ |
| SPINEL_PROP_THREAD_MGMT_GET_PENDING_DATASET = SPINEL_PROP_THREAD_EXT__BEGIN + 38, |
| |
| /// Operational Dataset (MGMT_GET) Destination IPv6 Address |
| /** Format: `6` - No direct read or write |
| * |
| * This property specifies the IPv6 destination when sending MGMT_GET command for either Active or Pending Dataset |
| * if not provided, Leader ALOC address is used as default. |
| * |
| * It can only be included in one of the MGMT_GET Dataset properties: |
| * |
| * SPINEL_PROP_THREAD_MGMT_GET_ACTIVE_DATASET |
| * SPINEL_PROP_THREAD_MGMT_GET_PENDING_DATASET |
| * |
| */ |
| SPINEL_PROP_DATASET_DEST_ADDRESS = SPINEL_PROP_THREAD_EXT__BEGIN + 39, |
| |
| /// Thread New Operational Dataset |
| /** Format: `A(t(iD))` - Read only - FTD build only |
| * |
| * This property allows host to request NCP to create and return a new Operation Dataset to use when forming a new |
| * network. |
| * |
| * Operational Dataset consists of a set of supported properties (e.g., channel, master key, network name, PAN id, |
| * etc). Note that not all supported properties may be present (have a value) in a Dataset. |
| * |
| * The Dataset value is encoded as an array of structs containing pairs of property key (as `i`) followed by the |
| * property value (as `D`). The property value must follow the format associated with the corresponding property. |
| * |
| * The following properties can be included in a Dataset list: |
| * |
| * SPINEL_PROP_DATASET_ACTIVE_TIMESTAMP |
| * SPINEL_PROP_PHY_CHAN |
| * SPINEL_PROP_PHY_CHAN_SUPPORTED (Channel Mask Page 0) |
| * SPINEL_PROP_NET_MASTER_KEY |
| * SPINEL_PROP_NET_NETWORK_NAME |
| * SPINEL_PROP_NET_XPANID |
| * SPINEL_PROP_MAC_15_4_PANID |
| * SPINEL_PROP_IPV6_ML_PREFIX |
| * SPINEL_PROP_NET_PSKC |
| * SPINEL_PROP_DATASET_SECURITY_POLICY |
| * |
| */ |
| SPINEL_PROP_THREAD_NEW_DATASET = SPINEL_PROP_THREAD_EXT__BEGIN + 40, |
| |
| SPINEL_PROP_THREAD_EXT__END = 0x1600, |
| |
| SPINEL_PROP_IPV6__BEGIN = 0x60, |
| |
| /// Link-Local IPv6 Address |
| /** Format: `6` - Read only |
| * |
| */ |
| SPINEL_PROP_IPV6_LL_ADDR = SPINEL_PROP_IPV6__BEGIN + 0, ///< [6] |
| |
| /// Mesh Local IPv6 Address |
| /** Format: `6` - Read only |
| * |
| */ |
| SPINEL_PROP_IPV6_ML_ADDR = SPINEL_PROP_IPV6__BEGIN + 1, |
| |
| /// Mesh Local Prefix |
| /** Format: `6C` - Read-write |
| * |
| * Provides Mesh Local Prefix |
| * |
| * `6`: Mesh local prefix |
| * `C` : Prefix length (64 bit for Thread). |
| * |
| */ |
| SPINEL_PROP_IPV6_ML_PREFIX = SPINEL_PROP_IPV6__BEGIN + 2, |
| |
| /// IPv6 (Unicast) Address Table |
| /** Format: `A(t(6CLLC))` |
| * |
| * This property provides all unicast addresses. |
| * |
| * Array of structures containing: |
| * |
| * `6`: IPv6 Address |
| * `C`: Network Prefix Length (in bits) |
| * `L`: Valid Lifetime |
| * `L`: Preferred Lifetime |
| * |
| */ |
| SPINEL_PROP_IPV6_ADDRESS_TABLE = SPINEL_PROP_IPV6__BEGIN + 3, |
| |
| /// IPv6 Route Table - Deprecated |
| SPINEL_PROP_IPV6_ROUTE_TABLE = SPINEL_PROP_IPV6__BEGIN + 4, |
| |
| /// IPv6 ICMP Ping Offload |
| /** Format: `b` |
| * |
| * Allow the NCP to directly respond to ICMP ping requests. If this is |
| * turned on, ping request ICMP packets will not be passed to the host. |
| * |
| * Default value is `false`. |
| */ |
| SPINEL_PROP_IPV6_ICMP_PING_OFFLOAD = SPINEL_PROP_IPV6__BEGIN + 5, |
| |
| /// IPv6 Multicast Address Table |
| /** Format: `A(t(6))` |
| * |
| * This property provides all multicast addresses. |
| * |
| */ |
| SPINEL_PROP_IPV6_MULTICAST_ADDRESS_TABLE = SPINEL_PROP_IPV6__BEGIN + 6, |
| |
| /// IPv6 ICMP Ping Offload |
| /** Format: `C` |
| * |
| * Allow the NCP to directly respond to ICMP ping requests. If this is |
| * turned on, ping request ICMP packets will not be passed to the host. |
| * |
| * This property allows enabling responses sent to unicast only, multicast |
| * only, or both. The valid value are defined by enumeration |
| * `spinel_ipv6_icmp_ping_offload_mode_t`. |
| * |
| * SPINEL_IPV6_ICMP_PING_OFFLOAD_DISABLED = 0 |
| * SPINEL_IPV6_ICMP_PING_OFFLOAD_UNICAST_ONLY = 1 |
| * SPINEL_IPV6_ICMP_PING_OFFLOAD_MULTICAST_ONLY = 2 |
| * SPINEL_IPV6_ICMP_PING_OFFLOAD_ALL = 3 |
| * |
| * Default value is `NET_IPV6_ICMP_PING_OFFLOAD_DISABLED`. |
| * |
| */ |
| SPINEL_PROP_IPV6_ICMP_PING_OFFLOAD_MODE = SPINEL_PROP_IPV6__BEGIN + 7, ///< [b] |
| |
| SPINEL_PROP_IPV6__END = 0x70, |
| |
| SPINEL_PROP_IPV6_EXT__BEGIN = 0x1600, |
| SPINEL_PROP_IPV6_EXT__END = 0x1700, |
| |
| SPINEL_PROP_STREAM__BEGIN = 0x70, |
| |
| /// Debug Stream |
| /** Format: `U` (stream, read only) |
| * |
| * This property is a streaming property, meaning that you cannot explicitly |
| * fetch the value of this property. The stream provides human-readable debugging |
| * output which may be displayed in the host logs. |
| * |
| * The location of newline characters is not assumed by the host: it is |
| * the NCP's responsibility to insert newline characters where needed, |
| * just like with any other text stream. |
| * |
| * To receive the debugging stream, you wait for `CMD_PROP_VALUE_IS` |
| * commands for this property from the NCP. |
| * |
| */ |
| SPINEL_PROP_STREAM_DEBUG = SPINEL_PROP_STREAM__BEGIN + 0, |
| |
| /// Raw Stream |
| /** Format: `dD` (stream, read only) |
| * Required Capability: SPINEL_CAP_MAC_RAW or SPINEL_CAP_CONFIG_RADIO |
| * |
| * This stream provides the capability of sending and receiving raw 15.4 frames |
| * to and from the radio. The exact format of the frame metadata and data is |
| * dependent on the MAC and PHY being used. |
| * |
| * This property is a streaming property, meaning that you cannot explicitly |
| * fetch the value of this property. To receive traffic, you wait for |
| * `CMD_PROP_VALUE_IS` commands with this property id from the NCP. |
| * |
| * The general format of this property is: |
| * |
| * `d` : frame data |
| * `D` : frame meta data |
| * |
| * The frame meta data is optional. Frame metadata MAY be empty or partially |
| * specified. Partially specified metadata MUST be accepted. Default values |
| * are used for all unspecified fields. |
| * |
| * The frame metadata field consists of the following fields: |
| * |
| * `c` : Received Signal Strength (RSSI) in dBm - default is -128 |
| * `c` : Noise floor in dBm - default is -128 |
| * `S` : Flags (see below). |
| * `d` : PHY-specific data/struct |
| * `d` : Vendor-specific data/struct |
| * |
| * Flags fields are defined by the following enumeration bitfields: |
| * |
| * SPINEL_MD_FLAG_TX = 0x0001 : Packet was transmitted, not received. |
| * SPINEL_MD_FLAG_BAD_FCS = 0x0004 : Packet was received with bad FCS |
| * SPINEL_MD_FLAG_DUPE = 0x0008 : Packet seems to be a duplicate |
| * SPINEL_MD_FLAG_RESERVED = 0xFFF2 : Flags reserved for future use. |
| * |
| * The format of PHY-specific data for a Thread device contains the following |
| * optional fields: |
| |
| * `C` : 802.15.4 channel (Receive channel) |
| * `C` : IEEE 802.15.4 LQI |
| * `L` : The timestamp milliseconds |
| * `S` : The timestamp microseconds, offset to mMsec |
| * |
| * Frames written to this stream with `CMD_PROP_VALUE_SET` will be sent out |
| * over the radio. This allows the caller to use the radio directly. |
| * |
| * The frame meta data for the `CMD_PROP_VALUE_SET` contains the following |
| * optional fields. Default values are used for all unspecified fields. |
| * |
| * `C` : Channel (for frame tx) |
| * `C` : Maximum number of backoffs attempts before declaring CCA failure |
| * (use Thread stack default if not specified) |
| * `C` : Maximum number of retries allowed after a transmission failure |
| * (use Thread stack default if not specified) |
| * `b` : Set to true to enable CSMA-CA for this packet, false otherwise. |
| * (default true). |
| * `b` : Set to true to indicate it is a retransmission packet, false otherwise. |
| * (default false). |
| * `b` : Set to true to indicate that SubMac should skip AES processing, false otherwise. |
| * (default false). |
| * |
| */ |
| SPINEL_PROP_STREAM_RAW = SPINEL_PROP_STREAM__BEGIN + 1, |
| |
| /// (IPv6) Network Stream |
| /** Format: `dD` (stream, read only) |
| * |
| * This stream provides the capability of sending and receiving (IPv6) |
| * data packets to and from the currently attached network. The packets |
| * are sent or received securely (encryption and authentication). |
| * |
| * This property is a streaming property, meaning that you cannot explicitly |
| * fetch the value of this property. To receive traffic, you wait for |
| * `CMD_PROP_VALUE_IS` commands with this property id from the NCP. |
| * |
| * To send network packets, you call `CMD_PROP_VALUE_SET` on this property with |
| * the value of the packet. |
| * |
| * The general format of this property is: |
| * |
| * `d` : packet data |
| * `D` : packet meta data |
| * |
| * The packet metadata is optional. Packet meta data MAY be empty or partially |
| * specified. Partially specified metadata MUST be accepted. Default values |
| * are used for all unspecified fields. |
| * |
| * For OpenThread the meta data is currently empty. |
| * |
| */ |
| SPINEL_PROP_STREAM_NET = SPINEL_PROP_STREAM__BEGIN + 2, |
| |
| /// (IPv6) Network Stream Insecure |
| /** Format: `dD` (stream, read only) |
| * |
| * This stream provides the capability of sending and receiving unencrypted |
| * and unauthenticated data packets to and from nearby devices for the |
| * purposes of device commissioning. |
| * |
| * This property is a streaming property, meaning that you cannot explicitly |
| * fetch the value of this property. To receive traffic, you wait for |
| * `CMD_PROP_VALUE_IS` commands with this property id from the NCP. |
| * |
| * To send network packets, you call `CMD_PROP_VALUE_SET` on this property with |
| * the value of the packet. |
| * |
| * The general format of this property is: |
| * |
| * `d` : packet data |
| * `D` : packet meta data |
| * |
| * The packet metadata is optional. Packet meta data MAY be empty or partially |
| * specified. Partially specified metadata MUST be accepted. Default values |
| * are used for all unspecified fields. |
| * |
| * For OpenThread the meta data is currently empty. |
| * |
| */ |
| SPINEL_PROP_STREAM_NET_INSECURE = SPINEL_PROP_STREAM__BEGIN + 3, |
| |
| /// Log Stream |
| /** Format: `UD` (stream, read only) |
| * |
| * This property is a read-only streaming property which provides |
| * formatted log string from NCP. This property provides asynchronous |
| * `CMD_PROP_VALUE_IS` updates with a new log string and includes |
| * optional meta data. |
| * |
| * `U`: The log string |
| * `D`: Log metadata (optional). |
| * |
| * Any data after the log string is considered metadata and is OPTIONAL. |
| * Presence of `SPINEL_CAP_OPENTHREAD_LOG_METADATA` capability |
| * indicates that OpenThread log metadata format is used as defined |
| * below: |
| * |
| * `C`: Log level (as per definition in enumeration |
| * `SPINEL_NCP_LOG_LEVEL_<level>`) |
| * `i`: OpenThread Log region (as per definition in enumeration |
| * `SPINEL_NCP_LOG_REGION_<region>). |
| * `X`: Log timestamp = <timestamp_base> + <current_time_ms> |
| * |
| */ |
| SPINEL_PROP_STREAM_LOG = SPINEL_PROP_STREAM__BEGIN + 4, |
| |
| SPINEL_PROP_STREAM__END = 0x80, |
| |
| SPINEL_PROP_STREAM_EXT__BEGIN = 0x1700, |
| SPINEL_PROP_STREAM_EXT__END = 0x1800, |
| |
| SPINEL_PROP_MESHCOP__BEGIN = 0x80, |
| |
| // Thread Joiner State |
| /** Format `C` - Read Only |
| * |
| * Required capability: SPINEL_CAP_THREAD_JOINER |
| * |
| * The valid values are specified by `spinel_meshcop_joiner_state_t` (`SPINEL_MESHCOP_JOINER_STATE_<state>`) |
| * enumeration. |
| * |
| */ |
| SPINEL_PROP_MESHCOP_JOINER_STATE = SPINEL_PROP_MESHCOP__BEGIN + 0, ///<[C] |
| |
| /// Thread Joiner Commissioning command and the parameters |
| /** Format `b` or `bU(UUUUU)` (fields in parenthesis are optional) - Write Only |
| * |
| * This property starts or stops Joiner's commissioning process |
| * |
| * Required capability: SPINEL_CAP_THREAD_JOINER |
| * |
| * Writing to this property starts/stops the Joiner commissioning process. |
| * The immediate `VALUE_IS` response indicates success/failure of the starting/stopping |
| * the Joiner commissioning process. |
| * |
| * After a successful start operation, the join process outcome is reported through an |
| * asynchronous `VALUE_IS(LAST_STATUS)` update with one of the following error status values: |
| * |
| * - SPINEL_STATUS_JOIN_SUCCESS the join process succeeded. |
| * - SPINEL_STATUS_JOIN_SECURITY the join process failed due to security credentials. |
| * - SPINEL_STATUS_JOIN_NO_PEERS no joinable network was discovered. |
| * - SPINEL_STATUS_JOIN_RSP_TIMEOUT if a response timed out. |
| * - SPINEL_STATUS_JOIN_FAILURE join failure. |
| * |
| * Frame format: |
| * |
| * `b` : Start or stop commissioning process (true to start). |
| * |
| * Only if the start commissioning. |
| * |
| * `U` : Joiner's PSKd. |
| * |
| * The next fields are all optional. If not provided, OpenThread default values would be used. |
| * |
| * `U` : Provisioning URL (use empty string if not required). |
| * `U` : Vendor Name. If not specified or empty string, use OpenThread default (PACKAGE_NAME). |
| * `U` : Vendor Model. If not specified or empty string, use OpenThread default (OPENTHREAD_CONFIG_PLATFORM_INFO). |
| * `U` : Vendor Sw Version. If not specified or empty string, use OpenThread default (PACKAGE_VERSION). |
| * `U` : Vendor Data String. Will not be appended if not specified. |
| * |
| */ |
| SPINEL_PROP_MESHCOP_JOINER_COMMISSIONING = SPINEL_PROP_MESHCOP__BEGIN + 1, |
| |
| // Thread Commissioner State |
| /** Format `C` |
| * |
| * Required capability: SPINEL_CAP_THREAD_COMMISSIONER |
| * |
| * The valid values are specified by SPINEL_MESHCOP_COMMISSIONER_STATE_<state> enumeration. |
| * |
| */ |
| SPINEL_PROP_MESHCOP_COMMISSIONER_STATE = SPINEL_PROP_MESHCOP__BEGIN + 2, |
| |
| // Thread Commissioner Joiners |
| /** Format `A(t(t(E|CX)UL))` - get, insert or remove. |
| * |
| * Required capability: SPINEL_CAP_THREAD_COMMISSIONER |
| * |
| * Data per array entry is: |
| * |
| * `t()` | `t(E)` | `t(CX)` : Joiner info struct (formatting varies). |
| * |
| * - `t()` or empty struct indicates any joiner. |
| * - `t(E)` specifies the Joiner EUI-64. |
| * - `t(CX) specifies Joiner Discerner, `C` is Discerner length (in bits), and `X` is Discerner value. |
| * |
| * The struct is followed by: |
| * |
| * `L` : Timeout after which to remove Joiner (when written should be in seconds, when read is in milliseconds) |
| * `U` : PSKd |
| * |
| * For CMD_PROP_VALUE_REMOVE the timeout and PSKd are optional. |
| * |
| */ |
| SPINEL_PROP_MESHCOP_COMMISSIONER_JOINERS = SPINEL_PROP_MESHCOP__BEGIN + 3, |
| |
| // Thread Commissioner Provisioning URL |
| /** Format `U` |
| * |
| * Required capability: SPINEL_CAP_THREAD_COMMISSIONER |
| * |
| */ |
| SPINEL_PROP_MESHCOP_COMMISSIONER_PROVISIONING_URL = SPINEL_PROP_MESHCOP__BEGIN + 4, |
| |
| // Thread Commissioner Session ID |
| /** Format `S` - Read only |
| * |
| * Required capability: SPINEL_CAP_THREAD_COMMISSIONER |
| * |
| */ |
| SPINEL_PROP_MESHCOP_COMMISSIONER_SESSION_ID = SPINEL_PROP_MESHCOP__BEGIN + 5, |
| |
| /// Thread Joiner Discerner |
| /** Format `CX` - Read-write |
| * |
| * Required capability: SPINEL_CAP_THREAD_JOINER |
| * |
| * This property represents a Joiner Discerner. |
| * |
| * The Joiner Discerner is used to calculate the Joiner ID used during commissioning/joining process. |
| * |
| * By default (when a discerner is not provided or cleared), Joiner ID is derived as first 64 bits of the result |
| * of computing SHA-256 over factory-assigned IEEE EUI-64. Note that this is the main behavior expected by Thread |
| * specification. |
| * |
| * Format: |
| * |
| * 'C' : The Joiner Discerner bit length (number of bits). |
| * `X` : The Joiner Discerner value (64-bit unsigned) - Only present/applicable when length is non-zero. |
| * |
| * When writing to this property, the length can be set to zero to clear any previously set Joiner Discerner value. |
| * |
| * When reading this property if there is no currently set Joiner Discerner, zero is returned as the length (with |
| * no value field). |
| * |
| */ |
| SPINEL_PROP_MESHCOP_JOINER_DISCERNER = SPINEL_PROP_MESHCOP__BEGIN + 6, |
| |
| SPINEL_PROP_MESHCOP__END = 0x90, |
| |
| SPINEL_PROP_MESHCOP_EXT__BEGIN = 0x1800, |
| |
| // Thread Commissioner Announce Begin |
| /** Format `LCS6` - Write only |
| * |
| * Required capability: SPINEL_CAP_THREAD_COMMISSIONER |
| * |
| * Writing to this property sends an Announce Begin message with the specified parameters. Response is a |
| * `LAST_STATUS` update with status of operation. |
| * |
| * `L` : Channel mask |
| * `C` : Number of messages per channel |
| * `S` : The time between two successive MLE Announce transmissions (milliseconds) |
| * `6` : IPv6 destination |
| * |
| */ |
| SPINEL_PROP_MESHCOP_COMMISSIONER_ANNOUNCE_BEGIN = SPINEL_PROP_MESHCOP_EXT__BEGIN + 0, |
| |
| // Thread Commissioner Energy Scan Query |
| /** Format `LCSS6` - Write only |
| * |
| * Required capability: SPINEL_CAP_THREAD_COMMISSIONER |
| * |
| * Writing to this property sends an Energy Scan Query message with the specified parameters. Response is a |
| * `LAST_STATUS` with status of operation. The energy scan results are emitted asynchronously through |
| * `SPINEL_PROP_MESHCOP_COMMISSIONER_ENERGY_SCAN_RESULT` updates. |
| * |
| * Format is: |
| * |
| * `L` : Channel mask |
| * `C` : The number of energy measurements per channel |
| * `S` : The time between energy measurements (milliseconds) |
| * `S` : The scan duration for each energy measurement (milliseconds) |
| * `6` : IPv6 destination. |
| * |
| */ |
| SPINEL_PROP_MESHCOP_COMMISSIONER_ENERGY_SCAN = SPINEL_PROP_MESHCOP_EXT__BEGIN + 1, |
| |
| // Thread Commissioner Energy Scan Result |
| /** Format `Ld` - Asynchronous event only |
| * |
| * Required capability: SPINEL_CAP_THREAD_COMMISSIONER |
| * |
| * This property provides asynchronous `CMD_PROP_VALUE_INSERTED` updates to report energy scan results for a |
| * previously sent Energy Scan Query message (please see `SPINEL_PROP_MESHCOP_COMMISSIONER_ENERGY_SCAN`). |
| * |
| * Format is: |
| * |
| * `L` : Channel mask |
| * `d` : Energy measurement data (note that `d` encoding includes the length) |
| * |
| */ |
| SPINEL_PROP_MESHCOP_COMMISSIONER_ENERGY_SCAN_RESULT = SPINEL_PROP_MESHCOP_EXT__BEGIN + 2, |
| |
| // Thread Commissioner PAN ID Query |
| /** Format `SL6` - Write only |
| * |
| * Required capability: SPINEL_CAP_THREAD_COMMISSIONER |
| * |
| * Writing to this property sends a PAN ID Query message with the specified parameters. Response is a |
| * `LAST_STATUS` with status of operation. The PAN ID Conflict results are emitted asynchronously through |
| * `SPINEL_PROP_MESHCOP_COMMISSIONER_PAN_ID_CONFLICT_RESULT` updates. |
| * |
| * Format is: |
| * |
| * `S` : PAN ID to query |
| * `L` : Channel mask |
| * `6` : IPv6 destination |
| * |
| */ |
| SPINEL_PROP_MESHCOP_COMMISSIONER_PAN_ID_QUERY = SPINEL_PROP_MESHCOP_EXT__BEGIN + 3, |
| |
| // Thread Commissioner PAN ID Conflict Result |
| /** Format `SL` - Asynchronous event only |
| * |
| * Required capability: SPINEL_CAP_THREAD_COMMISSIONER |
| * |
| * This property provides asynchronous `CMD_PROP_VALUE_INSERTED` updates to report PAN ID conflict results for a |
| * previously sent PAN ID Query message (please see `SPINEL_PROP_MESHCOP_COMMISSIONER_PAN_ID_QUERY`). |
| * |
| * Format is: |
| * |
| * `S` : The PAN ID |
| * `L` : Channel mask |
| * |
| */ |
| SPINEL_PROP_MESHCOP_COMMISSIONER_PAN_ID_CONFLICT_RESULT = SPINEL_PROP_MESHCOP_EXT__BEGIN + 4, |
| |
| // Thread Commissioner Send MGMT_COMMISSIONER_GET |
| /** Format `d` - Write only |
| * |
| * Required capability: SPINEL_CAP_THREAD_COMMISSIONER |
| * |
| * Writing to this property sends a MGMT_COMMISSIONER_GET message with the specified parameters. Response is a |
| * `LAST_STATUS` with status of operation. |
| * |
| * Format is: |
| * |
| * `d` : List of TLV types to get |
| * |
| */ |
| SPINEL_PROP_MESHCOP_COMMISSIONER_MGMT_GET = SPINEL_PROP_MESHCOP_EXT__BEGIN + 5, |
| |
| // Thread Commissioner Send MGMT_COMMISSIONER_SET |
| /** Format `d` - Write only |
| * |
| * Required capability: SPINEL_CAP_THREAD_COMMISSIONER |
| * |
| * Writing to this property sends a MGMT_COMMISSIONER_SET message with the specified parameters. Response is a |
| * `LAST_STATUS` with status of operation. |
| * |
| * Format is: |
| * |
| * `d` : TLV encoded data |
| * |
| */ |
| SPINEL_PROP_MESHCOP_COMMISSIONER_MGMT_SET = SPINEL_PROP_MESHCOP_EXT__BEGIN + 6, |
| |
| // Thread Commissioner Generate PSKc |
| /** Format: `UUd` - Write only |
| * |
| * Required capability: SPINEL_CAP_THREAD_COMMISSIONER |
| * |
| * Writing to this property allows user to generate PSKc from a given commissioning pass-phrase, network name, |
| * extended PAN Id. |
| * |
| * Written value format is: |
| * |
| * `U` : The commissioning pass-phrase. |
| * `U` : Network Name. |
| * `d` : Extended PAN ID. |
| * |
| * The response on success would be a `VALUE_IS` command with the PSKc with format below: |
| * |
| * `D` : The PSKc |
| * |
| * On a failure a `LAST_STATUS` is emitted with the error status. |
| * |
| */ |
| SPINEL_PROP_MESHCOP_COMMISSIONER_GENERATE_PSKC = SPINEL_PROP_MESHCOP_EXT__BEGIN + 7, |
| |
| SPINEL_PROP_MESHCOP_EXT__END = 0x1900, |
| |
| SPINEL_PROP_OPENTHREAD__BEGIN = 0x1900, |
| |
| /// Channel Manager - Channel Change New Channel |
| /** Format: `C` (read-write) |
| * |
| * Required capability: SPINEL_CAP_CHANNEL_MANAGER |
| * |
| * Setting this property triggers the Channel Manager to start |
| * a channel change process. The network switches to the given |
| * channel after the specified delay (see `CHANNEL_MANAGER_DELAY`). |
| * |
| * A subsequent write to this property will cancel an ongoing |
| * (previously requested) channel change. |
| * |
| */ |
| SPINEL_PROP_CHANNEL_MANAGER_NEW_CHANNEL = SPINEL_PROP_OPENTHREAD__BEGIN + 0, |
| |
| /// Channel Manager - Channel Change Delay |
| /** Format 'S' |
| * Units: seconds |
| * |
| * Required capability: SPINEL_CAP_CHANNEL_MANAGER |
| * |
| * This property specifies the delay (in seconds) to be used for |
| * a channel change request. |
| * |
| * The delay should preferably be longer than maximum data poll |
| * interval used by all sleepy-end-devices within the Thread |
| * network. |
| * |
| */ |
| SPINEL_PROP_CHANNEL_MANAGER_DELAY = SPINEL_PROP_OPENTHREAD__BEGIN + 1, |
| |
| /// Channel Manager Supported Channels |
| /** Format 'A(C)' |
| * |
| * Required capability: SPINEL_CAP_CHANNEL_MANAGER |
| * |
| * This property specifies the list of supported channels. |
| * |
| */ |
| SPINEL_PROP_CHANNEL_MANAGER_SUPPORTED_CHANNELS = SPINEL_PROP_OPENTHREAD__BEGIN + 2, |
| |
| /// Channel Manager Favored Channels |
| /** Format 'A(C)' |
| * |
| * Required capability: SPINEL_CAP_CHANNEL_MANAGER |
| * |
| * This property specifies the list of favored channels (when `ChannelManager` is asked to select channel) |
| * |
| */ |
| SPINEL_PROP_CHANNEL_MANAGER_FAVORED_CHANNELS = SPINEL_PROP_OPENTHREAD__BEGIN + 3, |
| |
| /// Channel Manager Channel Select Trigger |
| /** Format 'b' |
| * |
| * Required capability: SPINEL_CAP_CHANNEL_MANAGER |
| * |
| * Writing to this property triggers a request on `ChannelManager` to select a new channel. |
| * |
| * Once a Channel Select is triggered, the Channel Manager will perform the following 3 steps: |
| * |
| * 1) `ChannelManager` decides if the channel change would be helpful. This check can be skipped if in the input |
| * boolean to this property is set to `true` (skipping the quality check). |
| * This step uses the collected link quality metrics on the device such as CCA failure rate, frame and message |
| * error rates per neighbor, etc. to determine if the current channel quality is at the level that justifies |
| * a channel change. |
| * |
| * 2) If first step passes, then `ChannelManager` selects a potentially better channel. It uses the collected |
| * channel quality data by `ChannelMonitor` module. The supported and favored channels are used at this step. |
| * |
| * 3) If the newly selected channel is different from the current channel, `ChannelManager` requests/starts the |
| * channel change process. |
| * |
| * Reading this property always yields `false`. |
| * |
| */ |
| SPINEL_PROP_CHANNEL_MANAGER_CHANNEL_SELECT = SPINEL_PROP_OPENTHREAD__BEGIN + 4, |
| |
| /// Channel Manager Auto Channel Selection Enabled |
| /** Format 'b' |
| * |
| * Required capability: SPINEL_CAP_CHANNEL_MANAGER |
| * |
| * This property indicates if auto-channel-selection functionality is enabled/disabled on `ChannelManager`. |
| * |
| * When enabled, `ChannelManager` will periodically checks and attempts to select a new channel. The period interval |
| * is specified by `SPINEL_PROP_CHANNEL_MANAGER_AUTO_SELECT_INTERVAL`. |
| * |
| */ |
| SPINEL_PROP_CHANNEL_MANAGER_AUTO_SELECT_ENABLED = SPINEL_PROP_OPENTHREAD__BEGIN + 5, |
| |
| /// Channel Manager Auto Channel Selection Interval |
| /** Format 'L' |
| * units: seconds |
| * |
| * Required capability: SPINEL_CAP_CHANNEL_MANAGER |
| * |
| * This property specifies the auto-channel-selection check interval (in seconds). |
| * |
| */ |
| SPINEL_PROP_CHANNEL_MANAGER_AUTO_SELECT_INTERVAL = SPINEL_PROP_OPENTHREAD__BEGIN + 6, |
| |
| /// Thread network time. |
| /** Format: `Xc` - Read only |
| * |
| * Data per item is: |
| * |
| * `X`: The Thread network time, in microseconds. |
| * `c`: Time synchronization status. |
| * |
| */ |
| SPINEL_PROP_THREAD_NETWORK_TIME = SPINEL_PROP_OPENTHREAD__BEGIN + 7, |
| |
| /// Thread time synchronization period |
| /** Format: `S` - Read-Write |
| * |
| * Data per item is: |
| * |
| * `S`: Time synchronization period, in seconds. |
| * |
| */ |
| SPINEL_PROP_TIME_SYNC_PERIOD = SPINEL_PROP_OPENTHREAD__BEGIN + 8, |
| |
| /// Thread Time synchronization XTAL accuracy threshold for Router |
| /** Format: `S` - Read-Write |
| * |
| * Data per item is: |
| * |
| * `S`: The XTAL accuracy threshold for Router, in PPM. |
| * |
| */ |
| SPINEL_PROP_TIME_SYNC_XTAL_THRESHOLD = SPINEL_PROP_OPENTHREAD__BEGIN + 9, |
| |
| /// Child Supervision Interval |
| /** Format: `S` - Read-Write |
| * Units: Seconds |
| * |
| * Required capability: `SPINEL_CAP_CHILD_SUPERVISION` |
| * |
| * The child supervision interval (in seconds). Zero indicates that child supervision is disabled. |
| * |
| * When enabled, Child supervision feature ensures that at least one message is sent to every sleepy child within |
| * the given supervision interval. If there is no other message, a supervision message (a data message with empty |
| * payload) is enqueued and sent to the child. |
| * |
| * This property is available for FTD build only. |
| * |
| */ |
| SPINEL_PROP_CHILD_SUPERVISION_INTERVAL = SPINEL_PROP_OPENTHREAD__BEGIN + 10, |
| |
| /// Child Supervision Check Timeout |
| /** Format: `S` - Read-Write |
| * Units: Seconds |
| * |
| * Required capability: `SPINEL_CAP_CHILD_SUPERVISION` |
| * |
| * The child supervision check timeout interval (in seconds). Zero indicates supervision check on the child is |
| * disabled. |
| * |
| * Supervision check is only applicable on a sleepy child. When enabled, if the child does not hear from its parent |
| * within the specified check timeout, it initiates a re-attach process by starting an MLE Child Update |
| * Request/Response exchange with the parent. |
| * |
| * This property is available for FTD and MTD builds. |
| * |
| */ |
| SPINEL_PROP_CHILD_SUPERVISION_CHECK_TIMEOUT = SPINEL_PROP_OPENTHREAD__BEGIN + 11, |
| |
| // RCP (NCP in radio only mode) version |
| /** Format `U` - Read only |
| * |
| * Required capability: SPINEL_CAP_POSIX |
| * |
| * This property gives the version string of RCP (NCP in radio mode) which is being controlled by a POSIX |
| * application. It is available only in "POSIX" platform (i.e., `OPENTHREAD_PLATFORM_POSIX` is enabled). |
| * |
| */ |
| SPINEL_PROP_RCP_VERSION = SPINEL_PROP_OPENTHREAD__BEGIN + 12, |
| |
| /// Thread Parent Response info |
| /** Format: `ESccCCCb` - Asynchronous event only |
| * |
| * `E`: Extended address |
| * `S`: RLOC16 |
| * `c`: Instant RSSI |
| * 'c': Parent Priority |
| * `C`: Link Quality3 |
| * `C`: Link Quality2 |
| * `C`: Link Quality1 |
| * 'b': Is the node receiving parent response frame attached |
| * |
| * This property sends Parent Response frame information to the Host. |
| * This property is available for FTD build only. |
| * |
| */ |
| SPINEL_PROP_PARENT_RESPONSE_INFO = SPINEL_PROP_OPENTHREAD__BEGIN + 13, |
| |
| /// SLAAC enabled |
| /** Format `b` - Read-Write |
| * Required capability: `SPINEL_CAP_SLAAC` |
| * |
| * This property allows the host to enable/disable SLAAC module on NCP at run-time. When SLAAC module is enabled, |
| * SLAAC addresses (based on on-mesh prefixes in Network Data) are added to the interface. When SLAAC module is |
| * disabled any previously added SLAAC address is removed. |
| * |
| */ |
| SPINEL_PROP_SLAAC_ENABLED = SPINEL_PROP_OPENTHREAD__BEGIN + 14, |
| |
| SPINEL_PROP_OPENTHREAD__END = 0x2000, |
| |
| SPINEL_PROP_SERVER__BEGIN = 0xA0, |
| |
| /// Server Allow Local Network Data Change |
| /** Format `b` - Read-write |
| * |
| * Required capability: SPINEL_CAP_THREAD_SERVICE |
| * |
| * Set to true before changing local server net data. Set to false when finished. |
| * This allows changes to be aggregated into a single event. |
| * |
| */ |
| SPINEL_PROP_SERVER_ALLOW_LOCAL_DATA_CHANGE = SPINEL_PROP_SERVER__BEGIN + 0, |
| |
| // Server Services |
| /** Format: `A(t(LdbdS))` |
| * |
| * This property provides all services registered on the device |
| * |
| * Required capability: SPINEL_CAP_THREAD_SERVICE |
| * |
| * Array of structures containing: |
| * |
| * `L`: Enterprise Number |
| * `d`: Service Data |
| * `b`: Stable |
| * `d`: Server Data |
| * `S`: RLOC |
| * |
| */ |
| SPINEL_PROP_SERVER_SERVICES = SPINEL_PROP_SERVER__BEGIN + 1, |
| |
| // Server Leader Services |
| /** Format: `A(t(CLdbdS))` |
| * |
| * This property provides all services registered on the leader |
| * |
| * Array of structures containing: |
| * |
| * `C`: Service ID |
| * `L`: Enterprise Number |
| * `d`: Service Data |
| * `b`: Stable |
| * `d`: Server Data |
| * `S`: RLOC |
| * |
| */ |
| SPINEL_PROP_SERVER_LEADER_SERVICES = SPINEL_PROP_SERVER__BEGIN + 2, |
| |
| SPINEL_PROP_SERVER__END = 0xB0, |
| |
| SPINEL_PROP_INTERFACE__BEGIN = 0x100, |
| |
| /// UART Bitrate |
| /** Format: `L` |
| * |
| * If the NCP is using a UART to communicate with the host, |
| * this property allows the host to change the bitrate |
| * of the serial connection. The value encoding is `L`, |
| * which is a little-endian 32-bit unsigned integer. |
| * The host should not assume that all possible numeric values |
| * are supported. |
| * |
| * If implemented by the NCP, this property should be persistent |
| * across software resets and forgotten upon hardware resets. |
| * |
| * This property is only implemented when a UART is being |
| * used for Spinel. This property is optional. |
| * |
| * When changing the bitrate, all frames will be received |
| * at the previous bitrate until the response frame to this command |
| * is received. Once a successful response frame is received by |
| * the host, all further frames will be transmitted at the new |
| * bitrate. |
| */ |
| SPINEL_PROP_UART_BITRATE = SPINEL_PROP_INTERFACE__BEGIN + 0, |
| |
| /// UART Software Flow Control |
| /** Format: `b` |
| * |
| * If the NCP is using a UART to communicate with the host, |
| * this property allows the host to determine if software flow |
| * control (XON/XOFF style) should be used and (optionally) to |
| * turn it on or off. |
| * |
| * This property is only implemented when a UART is being |
| * used for Spinel. This property is optional. |
| */ |
| SPINEL_PROP_UART_XON_XOFF = SPINEL_PROP_INTERFACE__BEGIN + 1, |
| |
| SPINEL_PROP_INTERFACE__END = 0x200, |
| |
| SPINEL_PROP_15_4_PIB__BEGIN = 0x400, |
| // For direct access to the 802.15.4 PID. |
| // Individual registers are fetched using |
| // `SPINEL_PROP_15_4_PIB__BEGIN+[PIB_IDENTIFIER]` |
| // Only supported if SPINEL_CAP_15_4_PIB is set. |
| // |
| // For brevity, the entire 802.15.4 PIB space is |
| // not defined here, but a few choice attributes |
| // are defined for illustration and convenience. |
| SPINEL_PROP_15_4_PIB_PHY_CHANNELS_SUPPORTED = SPINEL_PROP_15_4_PIB__BEGIN + 0x01, ///< [A(L)] |
| SPINEL_PROP_15_4_PIB_MAC_PROMISCUOUS_MODE = SPINEL_PROP_15_4_PIB__BEGIN + 0x51, ///< [b] |
| SPINEL_PROP_15_4_PIB_MAC_SECURITY_ENABLED = SPINEL_PROP_15_4_PIB__BEGIN + 0x5d, ///< [b] |
| SPINEL_PROP_15_4_PIB__END = 0x500, |
| |
| SPINEL_PROP_CNTR__BEGIN = 0x500, |
| |
| /// Counter reset |
| /** Format: Empty (Write only). |
| * |
| * Writing to this property (with any value) will reset all MAC, MLE, IP, and NCP counters to zero. |
| * |
| */ |
| SPINEL_PROP_CNTR_RESET = SPINEL_PROP_CNTR__BEGIN + 0, |
| |
| /// The total number of transmissions. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_TX_PKT_TOTAL = SPINEL_PROP_CNTR__BEGIN + 1, |
| |
| /// The number of transmissions with ack request. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_TX_PKT_ACK_REQ = SPINEL_PROP_CNTR__BEGIN + 2, |
| |
| /// The number of transmissions that were acked. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_TX_PKT_ACKED = SPINEL_PROP_CNTR__BEGIN + 3, |
| |
| /// The number of transmissions without ack request. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_TX_PKT_NO_ACK_REQ = SPINEL_PROP_CNTR__BEGIN + 4, |
| |
| /// The number of transmitted data. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_TX_PKT_DATA = SPINEL_PROP_CNTR__BEGIN + 5, |
| |
| /// The number of transmitted data poll. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_TX_PKT_DATA_POLL = SPINEL_PROP_CNTR__BEGIN + 6, |
| |
| /// The number of transmitted beacon. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_TX_PKT_BEACON = SPINEL_PROP_CNTR__BEGIN + 7, |
| |
| /// The number of transmitted beacon request. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_TX_PKT_BEACON_REQ = SPINEL_PROP_CNTR__BEGIN + 8, |
| |
| /// The number of transmitted other types of frames. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_TX_PKT_OTHER = SPINEL_PROP_CNTR__BEGIN + 9, |
| |
| /// The number of retransmission times. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_TX_PKT_RETRY = SPINEL_PROP_CNTR__BEGIN + 10, |
| |
| /// The number of CCA failure times. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_TX_ERR_CCA = SPINEL_PROP_CNTR__BEGIN + 11, |
| |
| /// The number of unicast packets transmitted. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_TX_PKT_UNICAST = SPINEL_PROP_CNTR__BEGIN + 12, |
| |
| /// The number of broadcast packets transmitted. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_TX_PKT_BROADCAST = SPINEL_PROP_CNTR__BEGIN + 13, |
| |
| /// The number of frame transmission failures due to abort error. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_TX_ERR_ABORT = SPINEL_PROP_CNTR__BEGIN + 14, |
| |
| /// The total number of received packets. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_PKT_TOTAL = SPINEL_PROP_CNTR__BEGIN + 100, |
| |
| /// The number of received data. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_PKT_DATA = SPINEL_PROP_CNTR__BEGIN + 101, |
| |
| /// The number of received data poll. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_PKT_DATA_POLL = SPINEL_PROP_CNTR__BEGIN + 102, |
| |
| /// The number of received beacon. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_PKT_BEACON = SPINEL_PROP_CNTR__BEGIN + 103, |
| |
| /// The number of received beacon request. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_PKT_BEACON_REQ = SPINEL_PROP_CNTR__BEGIN + 104, |
| |
| /// The number of received other types of frames. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_PKT_OTHER = SPINEL_PROP_CNTR__BEGIN + 105, |
| |
| /// The number of received packets filtered by whitelist. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_PKT_FILT_WL = SPINEL_PROP_CNTR__BEGIN + 106, |
| |
| /// The number of received packets filtered by destination check. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_PKT_FILT_DA = SPINEL_PROP_CNTR__BEGIN + 107, |
| |
| /// The number of received packets that are empty. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_ERR_EMPTY = SPINEL_PROP_CNTR__BEGIN + 108, |
| |
| /// The number of received packets from an unknown neighbor. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_ERR_UKWN_NBR = SPINEL_PROP_CNTR__BEGIN + 109, |
| |
| /// The number of received packets whose source address is invalid. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_ERR_NVLD_SADDR = SPINEL_PROP_CNTR__BEGIN + 110, |
| |
| /// The number of received packets with a security error. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_ERR_SECURITY = SPINEL_PROP_CNTR__BEGIN + 111, |
| |
| /// The number of received packets with a checksum error. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_ERR_BAD_FCS = SPINEL_PROP_CNTR__BEGIN + 112, |
| |
| /// The number of received packets with other errors. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_ERR_OTHER = SPINEL_PROP_CNTR__BEGIN + 113, |
| |
| /// The number of received duplicated. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_PKT_DUP = SPINEL_PROP_CNTR__BEGIN + 114, |
| |
| /// The number of unicast packets received. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_PKT_UNICAST = SPINEL_PROP_CNTR__BEGIN + 115, |
| |
| /// The number of broadcast packets received. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_PKT_BROADCAST = SPINEL_PROP_CNTR__BEGIN + 116, |
| |
| /// The total number of secure transmitted IP messages. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_TX_IP_SEC_TOTAL = SPINEL_PROP_CNTR__BEGIN + 200, |
| |
| /// The total number of insecure transmitted IP messages. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_TX_IP_INSEC_TOTAL = SPINEL_PROP_CNTR__BEGIN + 201, |
| |
| /// The number of dropped (not transmitted) IP messages. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_TX_IP_DROPPED = SPINEL_PROP_CNTR__BEGIN + 202, |
| |
| /// The total number of secure received IP message. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_IP_SEC_TOTAL = SPINEL_PROP_CNTR__BEGIN + 203, |
| |
| /// The total number of insecure received IP message. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_IP_INSEC_TOTAL = SPINEL_PROP_CNTR__BEGIN + 204, |
| |
| /// The number of dropped received IP messages. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_IP_DROPPED = SPINEL_PROP_CNTR__BEGIN + 205, |
| |
| /// The number of transmitted spinel frames. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_TX_SPINEL_TOTAL = SPINEL_PROP_CNTR__BEGIN + 300, |
| |
| /// The number of received spinel frames. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_SPINEL_TOTAL = SPINEL_PROP_CNTR__BEGIN + 301, |
| |
| /// The number of received spinel frames with error. |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_SPINEL_ERR = SPINEL_PROP_CNTR__BEGIN + 302, |
| |
| /// Number of out of order received spinel frames (tid increase by more than 1). |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_RX_SPINEL_OUT_OF_ORDER_TID = SPINEL_PROP_CNTR__BEGIN + 303, |
| |
| /// The number of successful Tx IP packets |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_IP_TX_SUCCESS = SPINEL_PROP_CNTR__BEGIN + 304, |
| |
| /// The number of successful Rx IP packets |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_IP_RX_SUCCESS = SPINEL_PROP_CNTR__BEGIN + 305, |
| |
| /// The number of failed Tx IP packets |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_IP_TX_FAILURE = SPINEL_PROP_CNTR__BEGIN + 306, |
| |
| /// The number of failed Rx IP packets |
| /** Format: `L` (Read-only) */ |
| SPINEL_PROP_CNTR_IP_RX_FAILURE = SPINEL_PROP_CNTR__BEGIN + 307, |
| |
| /// The message buffer counter info |
| /** Format: `SSSSSSSSSSSSSSSS` (Read-only) |
| * `S`, (TotalBuffers) The number of buffers in the pool. |
| * `S`, (FreeBuffers) The number of free message buffers. |
| * `S`, (6loSendMessages) The number of messages in the 6lo send queue. |
| * `S`, (6loSendBuffers) The number of buffers in the 6lo send queue. |
| * `S`, (6loReassemblyMessages) The number of messages in the 6LoWPAN reassembly queue. |
| * `S`, (6loReassemblyBuffers) The number of buffers in the 6LoWPAN reassembly queue. |
| * `S`, (Ip6Messages) The number of messages in the IPv6 send queue. |
| * `S`, (Ip6Buffers) The number of buffers in the IPv6 send queue. |
| * `S`, (MplMessages) The number of messages in the MPL send queue. |
| * `S`, (MplBuffers) The number of buffers in the MPL send queue. |
| * `S`, (MleMessages) The number of messages in the MLE send queue. |
| * `S`, (MleBuffers) The number of buffers in the MLE send queue. |
| * `S`, (ArpMessages) The number of messages in the ARP send queue. |
| * `S`, (ArpBuffers) The number of buffers in the ARP send queue. |
| * `S`, (CoapMessages) The number of messages in the CoAP send queue. |
| * `S`, (CoapBuffers) The number of buffers in the CoAP send queue. |
| */ |
| SPINEL_PROP_MSG_BUFFER_COUNTERS = SPINEL_PROP_CNTR__BEGIN + 400, |
| |
| /// All MAC related counters. |
| /** Format: t(A(L))t(A(L)) |
| * |
| * The contents include two structs, first one corresponds to |
| * all transmit related MAC counters, second one provides the |
| * receive related counters. |
| * |
| * The transmit structure includes: |
| * |
| * 'L': TxTotal (The total number of transmissions). |
| * 'L': TxUnicast (The total number of unicast transmissions). |
| * 'L': TxBroadcast (The total number of broadcast transmissions). |
| * 'L': TxAckRequested (The number of transmissions with ack request). |
| * 'L': TxAcked (The number of transmissions that were acked). |
| * 'L': TxNoAckRequested (The number of transmissions without ack request). |
| * 'L': TxData (The number of transmitted data). |
| * 'L': TxDataPoll (The number of transmitted data poll). |
| * 'L': TxBeacon (The number of transmitted beacon). |
| * 'L': TxBeaconRequest (The number of transmitted beacon request). |
| * 'L': TxOther (The number of transmitted other types of frames). |
| * 'L': TxRetry (The number of retransmission times). |
| * 'L': TxErrCca (The number of CCA failure times). |
| * 'L': TxErrAbort (The number of frame transmission failures due to abort error). |
| * 'L': TxErrBusyChannel (The number of frames that were dropped due to a busy channel). |
| * 'L': TxDirectMaxRetryExpiry (The number of expired retransmission retries for direct message). |
| * 'L': TxIndirectMaxRetryExpiry (The number of expired retransmission retries for indirect message). |
| * |
| * The receive structure includes: |
| * |
| * 'L': RxTotal (The total number of received packets). |
| * 'L': RxUnicast (The total number of unicast packets received). |
| * 'L': RxBroadcast (The total number of broadcast packets received). |
| * 'L': RxData (The number of received data). |
| * 'L': RxDataPoll (The number of received data poll). |
| * 'L': RxBeacon (The number of received beacon). |
| * 'L': RxBeaconRequest (The number of received beacon request). |
| * 'L': RxOther (The number of received other types of frames). |
| * 'L': RxAddressFiltered (The number of received packets filtered by address filter |
| * (whitelist or blacklist)). |
| * 'L': RxDestAddrFiltered (The number of received packets filtered by destination check). |
| * 'L': RxDuplicated (The number of received duplicated packets). |
| * 'L': RxErrNoFrame (The number of received packets with no or malformed content). |
| * 'L': RxErrUnknownNeighbor (The number of received packets from unknown neighbor). |
| * 'L': RxErrInvalidSrcAddr (The number of received packets whose source address is invalid). |
| * 'L': RxErrSec (The number of received packets with security error). |
| * 'L': RxErrFcs (The number of received packets with FCS error). |
| * 'L': RxErrOther (The number of received packets with other error). |
| * |
| * Writing to this property with any value would reset all MAC counters to zero. |
| * |
| */ |
| SPINEL_PROP_CNTR_ALL_MAC_COUNTERS = SPINEL_PROP_CNTR__BEGIN + 401, |
| |
| /// Thread MLE counters. |
| /** Format: `SSSSSSSSS` |
| * |
| * 'S': DisabledRole (The number of times device entered OT_DEVICE_ROLE_DISABLED role). |
| * 'S': DetachedRole (The number of times device entered OT_DEVICE_ROLE_DETACHED role). |
| * 'S': ChildRole (The number of times device entered OT_DEVICE_ROLE_CHILD role). |
| * 'S': RouterRole (The number of times device entered OT_DEVICE_ROLE_ROUTER role). |
| * 'S': LeaderRole (The number of times device entered OT_DEVICE_ROLE_LEADER role). |
| * 'S': AttachAttempts (The number of attach attempts while device was detached). |
| * 'S': PartitionIdChanges (The number of changes to partition ID). |
| * 'S': BetterPartitionAttachAttempts (The number of attempts to attach to a better partition). |
| * 'S': ParentChanges (The number of times device changed its parents). |
| * |
| * Writing to this property with any value would reset all MLE counters to zero. |
| * |
| */ |
| SPINEL_PROP_CNTR_MLE_COUNTERS = SPINEL_PROP_CNTR__BEGIN + 402, |
| |
| /// Thread IPv6 counters. |
| /** Format: `t(LL)t(LL)` |
| * |
| * The contents include two structs, first one corresponds to |
| * all transmit related MAC counters, second one provides the |
| * receive related counters. |
| * |
| * The transmit structure includes: |
| * 'L': TxSuccess (The number of IPv6 packets successfully transmitted). |
| * 'L': TxFailure (The number of IPv6 packets failed to transmit). |
| * |
| * The receive structure includes: |
| * 'L': RxSuccess (The number of IPv6 packets successfully received). |
| * 'L': RxFailure (The number of IPv6 packets failed to receive). |
| * |
| * Writing to this property with any value would reset all IPv6 counters to zero. |
| * |
| */ |
| SPINEL_PROP_CNTR_ALL_IP_COUNTERS = SPINEL_PROP_CNTR__BEGIN + 403, |
| |
| /// MAC retry histogram. |
| /** Format: t(A(L))t(A(L)) |
| * |
| * Required capability: SPINEL_CAP_MAC_RETRY_HISTOGRAM |
| * |
| * The contents include two structs, first one is histogram which corresponds to retransmissions number of direct |
| * messages, second one provides the histogram of retransmissions for indirect messages. |
| * |
| * The first structure includes: |
| * 'L': DirectRetry[0] (The number of packets after 0 retry). |
| * 'L': DirectRetry[1] (The number of packets after 1 retry). |
| * ... |
| * 'L': DirectRetry[n] (The number of packets after n retry). |
| * |
| * The size of the array is OPENTHREAD_CONFIG_MAC_RETRY_SUCCESS_HISTOGRAM_MAX_SIZE_COUNT_DIRECT. |
| * |
| * The second structure includes: |
| * 'L': IndirectRetry[0] (The number of packets after 0 retry). |
| * 'L': IndirectRetry[1] (The number of packets after 1 retry). |
| * ... |
| * 'L': IndirectRetry[m] (The number of packets after m retry). |
| * |
| * The size of the array is OPENTHREAD_CONFIG_MAC_RETRY_SUCCESS_HISTOGRAM_MAX_SIZE_COUNT_INDIRECT. |
| * |
| * Writing to this property with any value would reset MAC retry histogram. |
| * |
| */ |
| SPINEL_PROP_CNTR_MAC_RETRY_HISTOGRAM = SPINEL_PROP_CNTR__BEGIN + 404, |
| |
| SPINEL_PROP_CNTR__END = 0x800, |
| |
| SPINEL_PROP_RCP__BEGIN = 0x800, |
| |
| /// MAC Key |
| /** Format: `CCddd`. |
| * |
| * `C`: MAC key ID mode |
| * `C`: MAC key ID |
| * `d`: previous MAC key material data |
| * `d`: current MAC key material data |
| * `d`: next MAC key material data |
| * |
| * The Spinel property is used to set/get MAC key materials to and from RCP. |
| * |
| */ |
| SPINEL_PROP_RCP_MAC_KEY = SPINEL_PROP_RCP__BEGIN + 0, |
| |
| /// MAC Frame Counter |
| /** Format: `L`. |
| * |
| * `L`: MAC frame counter |
| * |
| * The Spinel property is used to set MAC frame counter to RCP. |
| * |
| */ |
| SPINEL_PROP_RCP_MAC_FRAME_COUNTER = SPINEL_PROP_RCP__BEGIN + 1, |
| |
| /// Timestamps when Spinel frame is received and transmitted |
| /** Format: `X`. |
| * |
| * `X`: Spinel frame transmit timestamp |
| * |
| * The Spinel property is used to get timestamp from RCP to calculate host and RCP timer difference. |
| * |
| */ |
| SPINEL_PROP_RCP_TIMESTAMP = SPINEL_PROP_RCP__BEGIN + 2, |
| |
| SPINEL_PROP_RCP__END = 0x900, |
| |
| SPINEL_PROP_NEST__BEGIN = 0x3BC0, |
| |
| SPINEL_PROP_NEST_STREAM_MFG = SPINEL_PROP_NEST__BEGIN + 0, |
| |
| /// The legacy network ULA prefix (8 bytes) |
| /** Format: 'D' */ |
| SPINEL_PROP_NEST_LEGACY_ULA_PREFIX = SPINEL_PROP_NEST__BEGIN + 1, |
| |
| /// The EUI64 of last node joined using legacy protocol (if none, all zero EUI64 is returned). |
| /** Format: 'E' */ |
| SPINEL_PROP_NEST_LEGACY_LAST_NODE_JOINED = SPINEL_PROP_NEST__BEGIN + 2, |
| |
| SPINEL_PROP_NEST__END = 0x3C00, |
| |
| SPINEL_PROP_VENDOR__BEGIN = 0x3C00, |
| SPINEL_PROP_VENDOR__END = 0x4000, |
| |
| SPINEL_PROP_DEBUG__BEGIN = 0x4000, |
| |
| /// Testing platform assert |
| /** Format: 'b' (read-only) |
| * |
| * Reading this property will cause an assert on the NCP. This is intended for testing the assert functionality of |
| * underlying platform/NCP. Assert should ideally cause the NCP to reset, but if this is not supported a `false` |
| * boolean is returned in response. |
| * |
| */ |
| SPINEL_PROP_DEBUG_TEST_ASSERT = SPINEL_PROP_DEBUG__BEGIN + 0, |
| |
| /// The NCP log level. |
| /** Format: `C` */ |
| SPINEL_PROP_DEBUG_NCP_LOG_LEVEL = SPINEL_PROP_DEBUG__BEGIN + 1, |
| |
| /// Testing platform watchdog |
| /** Format: Empty (read-only) |
| * |
| * Reading this property will causes NCP to start a `while(true) ;` loop and thus triggering a watchdog. |
| * |
| * This is intended for testing the watchdog functionality on the underlying platform/NCP. |
| * |
| */ |
| SPINEL_PROP_DEBUG_TEST_WATCHDOG = SPINEL_PROP_DEBUG__BEGIN + 2, |
| |
| /// The NCP timestamp base |
| /** Format: X (write-only) |
| * |
| * This property controls the time base value that is used for logs timestamp field calculation. |
| * |
| */ |
| SPINEL_PROP_DEBUG_LOG_TIMESTAMP_BASE = SPINEL_PROP_DEBUG__BEGIN + 3, |
| |
| SPINEL_PROP_DEBUG__END = 0x4400, |
| |
| SPINEL_PROP_EXPERIMENTAL__BEGIN = 2000000, |
| SPINEL_PROP_EXPERIMENTAL__END = 2097152, |
| }; |
| |
| typedef uint32_t spinel_prop_key_t; |
| |
| // ---------------------------------------------------------------------------- |
| |
| #define SPINEL_HEADER_FLAG 0x80 |
| |
| #define SPINEL_HEADER_TID_SHIFT 0 |
| #define SPINEL_HEADER_TID_MASK (15 << SPINEL_HEADER_TID_SHIFT) |
| |
| #define SPINEL_HEADER_IID_SHIFT 4 |
| #define SPINEL_HEADER_IID_MASK (3 << SPINEL_HEADER_IID_SHIFT) |
| |
| #define SPINEL_HEADER_IID_0 (0 << SPINEL_HEADER_IID_SHIFT) |
| #define SPINEL_HEADER_IID_1 (1 << SPINEL_HEADER_IID_SHIFT) |
| #define SPINEL_HEADER_IID_2 (2 << SPINEL_HEADER_IID_SHIFT) |
| #define SPINEL_HEADER_IID_3 (3 << SPINEL_HEADER_IID_SHIFT) |
| |
| #define SPINEL_HEADER_GET_IID(x) (((x)&SPINEL_HEADER_IID_MASK) >> SPINEL_HEADER_IID_SHIFT) |
| #define SPINEL_HEADER_GET_TID(x) (spinel_tid_t)(((x)&SPINEL_HEADER_TID_MASK) >> SPINEL_HEADER_TID_SHIFT) |
| |
| #define SPINEL_GET_NEXT_TID(x) (spinel_tid_t)((x) >= 0xF ? 1 : (x) + 1) |
| |
| #define SPINEL_BEACON_THREAD_FLAG_VERSION_SHIFT 4 |
| |
| #define SPINEL_BEACON_THREAD_FLAG_VERSION_MASK (0xf << SPINEL_BEACON_THREAD_FLAG_VERSION_SHIFT) |
| |
| #define SPINEL_BEACON_THREAD_FLAG_JOINABLE (1 << 0) |
| |
| #define SPINEL_BEACON_THREAD_FLAG_NATIVE (1 << 3) |
| |
| // ---------------------------------------------------------------------------- |
| |
| enum |
| { |
| SPINEL_DATATYPE_NULL_C = 0, |
| SPINEL_DATATYPE_VOID_C = '.', |
| SPINEL_DATATYPE_BOOL_C = 'b', |
| SPINEL_DATATYPE_UINT8_C = 'C', |
| SPINEL_DATATYPE_INT8_C = 'c', |
| SPINEL_DATATYPE_UINT16_C = 'S', |
| SPINEL_DATATYPE_INT16_C = 's', |
| SPINEL_DATATYPE_UINT32_C = 'L', |
| SPINEL_DATATYPE_INT32_C = 'l', |
| SPINEL_DATATYPE_UINT64_C = 'X', |
| SPINEL_DATATYPE_INT64_C = 'x', |
| SPINEL_DATATYPE_UINT_PACKED_C = 'i', |
| SPINEL_DATATYPE_IPv6ADDR_C = '6', |
| SPINEL_DATATYPE_EUI64_C = 'E', |
| SPINEL_DATATYPE_EUI48_C = 'e', |
| SPINEL_DATATYPE_DATA_WLEN_C = 'd', |
| SPINEL_DATATYPE_DATA_C = 'D', |
| SPINEL_DATATYPE_UTF8_C = 'U', //!< Zero-Terminated UTF8-Encoded String |
| SPINEL_DATATYPE_STRUCT_C = 't', |
| SPINEL_DATATYPE_ARRAY_C = 'A', |
| }; |
| |
| typedef char spinel_datatype_t; |
| |
| #define SPINEL_DATATYPE_NULL_S "" |
| #define SPINEL_DATATYPE_VOID_S "." |
| #define SPINEL_DATATYPE_BOOL_S "b" |
| #define SPINEL_DATATYPE_UINT8_S "C" |
| #define SPINEL_DATATYPE_INT8_S "c" |
| #define SPINEL_DATATYPE_UINT16_S "S" |
| #define SPINEL_DATATYPE_INT16_S "s" |
| #define SPINEL_DATATYPE_UINT32_S "L" |
| #define SPINEL_DATATYPE_INT32_S "l" |
| #define SPINEL_DATATYPE_UINT64_S "X" |
| #define SPINEL_DATATYPE_INT64_S "x" |
| #define SPINEL_DATATYPE_UINT_PACKED_S "i" |
| #define SPINEL_DATATYPE_IPv6ADDR_S "6" |
| #define SPINEL_DATATYPE_EUI64_S "E" |
| #define SPINEL_DATATYPE_EUI48_S "e" |
| #define SPINEL_DATATYPE_DATA_WLEN_S "d" |
| #define SPINEL_DATATYPE_DATA_S "D" |
| #define SPINEL_DATATYPE_UTF8_S "U" //!< Zero-Terminated UTF8-Encoded String |
| |
| #define SPINEL_DATATYPE_ARRAY_S(x) "A(" x ")" |
| #define SPINEL_DATATYPE_STRUCT_S(x) "t(" x ")" |
| |
| #define SPINEL_DATATYPE_ARRAY_STRUCT_S(x) SPINEL_DATATYPE_ARRAY_S(SPINEL_DATATYPE_STRUCT_WLEN_S(x)) |
| |
| #define SPINEL_DATATYPE_COMMAND_S \ |
| SPINEL_DATATYPE_UINT8_S /* header */ \ |
| SPINEL_DATATYPE_UINT_PACKED_S /* command */ |
| |
| #define SPINEL_DATATYPE_COMMAND_PROP_S \ |
| SPINEL_DATATYPE_COMMAND_S /* prop command */ \ |
| SPINEL_DATATYPE_UINT_PACKED_S /* property id */ |
| |
| #define SPINEL_MAX_UINT_PACKED 2097151 |
| |
| SPINEL_API_EXTERN spinel_ssize_t spinel_datatype_pack(uint8_t * data_out, |
| spinel_size_t data_len_max, |
| const char * pack_format, |
| ...); |
| SPINEL_API_EXTERN spinel_ssize_t spinel_datatype_vpack(uint8_t * data_out, |
| spinel_size_t data_len_max, |
| const char * pack_format, |
| va_list args); |
| SPINEL_API_EXTERN spinel_ssize_t spinel_datatype_unpack(const uint8_t *data_in, |
| spinel_size_t data_len, |
| const char * pack_format, |
| ...); |
| /** |
| * This function parses spinel data similar to sscanf(). |
| * |
| * This function actually calls spinel_datatype_vunpack_in_place() to parse data. |
| * |
| * @param[in] data_in A pointer to the data to parse. |
| * @param[in] data_len The length of @p data_in in bytes. |
| * @param[in] pack_format C string that contains a format string follows the same specification of spinel. |
| * @param[in] ... Additional arguments depending on the format string @p pack_format. |
| * |
| * @returns The parsed length in bytes. |
| * |
| * @note This function behaves different from `spinel_datatype_unpack()`: |
| * - This function expects composite data arguments of pointer to data type, while `spinel_datatype_unpack()` |
| * expects them of pointer to data type pointer. For example, if `SPINEL_DATATYPE_EUI64_C` is present in |
| * @p pack_format, this function expects a `spinel_eui64_t *` is included in variable arguments, while |
| * `spinel_datatype_unpack()` expects a `spinel_eui64_t **` is included. |
| * - For `SPINEL_DATATYPE_UTF8_C`, this function expects two arguments, the first of type `char *` and the |
| * second is of type `size_t` to indicate length of the provided buffer in the first argument just like |
| * `strncpy()`, while `spinel_datatype_unpack()` only expects a `const char **`. |
| * |
| * @sa spinel_datatype_vunpack_in_place() |
| * |
| */ |
| SPINEL_API_EXTERN spinel_ssize_t spinel_datatype_unpack_in_place(const uint8_t *data_in, |
| spinel_size_t data_len, |
| const char * pack_format, |
| ...); |
| SPINEL_API_EXTERN spinel_ssize_t spinel_datatype_vunpack(const uint8_t *data_in, |
| spinel_size_t data_len, |
| const char * pack_format, |
| va_list args); |
| /** |
| * This function parses spinel data similar to vsscanf(). |
| * |
| * @param[in] data_in A pointer to the data to parse. |
| * @param[in] data_len The length of @p data_in in bytes. |
| * @param[in] pack_format C string that contains a format string follows the same specification of spinel. |
| * @param[in] args A value identifying a variable arguments list. |
| * |
| * @returns The parsed length in bytes. |
| * |
| * @note This function behaves different from `spinel_datatype_vunpack()`: |
| * - This function expects composite data arguments of pointer to data type, while `spinel_datatype_vunpack()` |
| * expects them of pointer to data type pointer. For example, if `SPINEL_DATATYPE_EUI64_C` is present in |
| * @p pack_format, this function expects a `spinel_eui64_t *` is included in variable arguments, while |
| * `spinel_datatype_vunpack()` expects a `spinel_eui64_t **` is included. |
| * - For `SPINEL_DATATYPE_UTF8_C`, this function expects two arguments, the first of type `char *` and the |
| * second is of type `size_t` to indicate length of the provided buffer in the first argument just like |
| * `strncpy()`, while `spinel_datatype_vunpack()` only expects a `const char **`. |
| * |
| * @sa spinel_datatype_unpack_in_place() |
| * |
| */ |
| SPINEL_API_EXTERN spinel_ssize_t spinel_datatype_vunpack_in_place(const uint8_t *data_in, |
| spinel_size_t data_len, |
| const char * pack_format, |
| va_list args); |
| |
| SPINEL_API_EXTERN spinel_ssize_t spinel_packed_uint_decode(const uint8_t *bytes, |
| spinel_size_t len, |
| unsigned int * value_ptr); |
| SPINEL_API_EXTERN spinel_ssize_t spinel_packed_uint_encode(uint8_t *bytes, spinel_size_t len, unsigned int value); |
| SPINEL_API_EXTERN spinel_ssize_t spinel_packed_uint_size(unsigned int value); |
| |
| SPINEL_API_EXTERN const char *spinel_next_packed_datatype(const char *pack_format); |
| |
| // ---------------------------------------------------------------------------- |
| |
| SPINEL_API_EXTERN const char *spinel_command_to_cstr(spinel_command_t command); |
| |
| SPINEL_API_EXTERN const char *spinel_prop_key_to_cstr(spinel_prop_key_t prop_key); |
| |
| SPINEL_API_EXTERN const char *spinel_net_role_to_cstr(uint8_t net_role); |
| |
| SPINEL_API_EXTERN const char *spinel_mcu_power_state_to_cstr(uint8_t mcu_power_state); |
| |
| SPINEL_API_EXTERN const char *spinel_status_to_cstr(spinel_status_t status); |
| |
| SPINEL_API_EXTERN const char *spinel_capability_to_cstr(spinel_capability_t capability); |
| |
| // ---------------------------------------------------------------------------- |
| |
| #if defined(__cplusplus) |
| } |
| #endif |
| |
| #endif /* defined(SPINEL_HEADER_INCLUDED) */ |