From b24866225a6301d3a663f874725e83c012dc25d3 Mon Sep 17 00:00:00 2001 From: Florent Duchon Date: Wed, 26 Dec 2012 17:36:00 +0100 Subject: digital/beacon: add bitcloud stack into common directory digital/zigbit --- .../Components/ConfigServer/include/csDefaults.h | 1381 ++++++++++++++++++++ 1 file changed, 1381 insertions(+) create mode 100644 digital/zigbit/bitcloud/stack/Components/ConfigServer/include/csDefaults.h (limited to 'digital/zigbit/bitcloud/stack/Components/ConfigServer/include/csDefaults.h') diff --git a/digital/zigbit/bitcloud/stack/Components/ConfigServer/include/csDefaults.h b/digital/zigbit/bitcloud/stack/Components/ConfigServer/include/csDefaults.h new file mode 100644 index 00000000..4bda4a33 --- /dev/null +++ b/digital/zigbit/bitcloud/stack/Components/ConfigServer/include/csDefaults.h @@ -0,0 +1,1381 @@ +/**************************************************************************//** + \file csDefaults.h + + \brief + Configuration Server parameters default values. + The contents of this file must not be changed by a user. Any default value can be redefined + in the application \c configuration.h file. + + Most of the parameters descriptions include the following standard remarks: + + \li Value range notes describe possible values that can be taken by a parameter; + \li C-type stands for the type in code that can be used to hold a value of a parameter; + \li Can be set indicates when a parameter can be changed: at compile time only, at any time before network start, or at any time; + \li if a parameter is stored in EEPROM memory so that its value does not change after hardware reset, while + other parameters restore their default values, then it is marked as Persistent; note that only + run-time parameters can be persistent. + + \author + Atmel Corporation: http://www.atmel.com \n + Support email: avr@atmel.com + + Copyright (c) 2010 , Atmel Corporation. All rights reserved. + Licensed under Atmel's Limited License Agreement (BitCloudTM). + + \internal + History: + 19.10.10 A. Razinkov - Created. +******************************************************************************/ + +#ifndef _CSDEFAULTS_H +#define _CSDEFAULTS_H + +/****************************************************************************** + Includes section +******************************************************************************/ +#include +#include + +/* MISRA killing for IAR compiler */ +#ifdef __IAR_SYSTEMS_ICC__ + #ifndef _SYSTEM_BUILD + #pragma system_include + #endif +#endif + +/****************************************************************************** + Definitions section +******************************************************************************/ +#ifdef CS_APS_DATA_REQ_BUFFER_SIZE + #error CS_APS_DATA_REQ_BUFFER_SIZE definition is renamed to CS_APS_DATA_REQ_BUFFERS_AMOUNT - please, use the new name. +#endif +#ifdef CS_APS_ACK_FRAME_BUFFER_SIZE + #error CS_APS_ACK_FRAME_BUFFER_SIZE definition is renamed to CS_APS_ACK_FRAME_BUFFERS_AMOUNT - please, use the new name. +#endif + +//BOOST mode is enabled automatically only for 11, 10, 9, 8, 7, 6 dBm(s) all other power valuses do not use BOOST mode. +//! \brief RF transmission power +/*! +The parameter specifies the TX power of the transceiver device, is measured in dBm(s). +After the node has entered the network the value can only be changed via +the ZDO_SetTxPowerReq() function. + +Value range: depends on the hardware +C-type: int8_t \n +Can be set: at any time \n +Persistent: Yes +*/ +#ifndef CS_RF_TX_POWER +/* It was TX_PWR_3_0DBM. */ +#define CS_RF_TX_POWER 0 +#endif + +//! \brief Determines the device extended address +/*! 64-bit Unique Identifier (UID). If this value is 0 stack will try to read +hardware UID from external UID or EEPROM chip. at startup. Location of hardware +UID is platform dependend and it may not be available on all platforms. If the latter +case then UID value must be provided by user via this parameter. This parameter must +be unique for each device in a network. + +Value range: any 64-bit value except for broadcast extended addresses +(see apsCommon.h) \n +C-type: ExtAddr_t \n +Can be set: at any time before network start \n +Persistent: Yes +*/ +#ifndef CS_UID +#define CS_UID 0x0000000000000000LL +#endif + +//! \brief The maximum duration in ms of frame transmission +/*! +The parameter is used in some internal calculations as the maximum duration +of transmitting a frame to the air. The default value should not be changed by the user. + +C-type: uint8_t \n +Can be set: at any time before network start \n +Persistent: No +*/ +#ifndef CS_MAX_FRAME_TRANSMISSION_TIME +#define CS_MAX_FRAME_TRANSMISSION_TIME 5 +#endif + +//! \brief Size of MAC RX buffer to store data frames +/*! +The parameter specifies a size of the buffer used by the MAC component for +data frames. The default value must not be changed by the user. + +Value range: the value must be greater than 131 \n +C-type: uint16_t \n +Can be set: at compile time only \n +Persistent: No +*/ +#ifndef CS_MAC_FRAME_RX_BUFFER_SIZE +#define CS_MAC_FRAME_RX_BUFFER_SIZE 132 +#endif + +#if defined(AT86RF212) || defined(CUSTOMRF3) +#ifndef CS_LBT_MODE +#define CS_LBT_MODE false +#endif +#endif + +#ifdef _MAC2_ +//! \brief MAC transaction persistence time +/*! +The parameter determines how long a frame received by the parent of a sleeping +end device is stored. If the end device does not polls for data during this time, then +the frame is dropped. + +For more details see MAC PIB attributes, Table 86 in IEEE 802.15.4-2006. + +C-type: uint32_t \n +Can be set: at any time \n +Persistent: No +*/ +// (by default in MAC = 7680L) +#ifndef CS_MAC_TRANSACTION_TIME +#define CS_MAC_TRANSACTION_TIME 7680L +#endif + +#else //_MAC2_ + +//! \brief Specifies receiver state (enabled or disabled) during inactive period for an end device +/*! +The parameter is taken into account on end devices only. Other devices behave as +if the parameter equals \c true. + +If on an end device the parameter equals \c true, +then the end device can receive data at any time, radio is always on, and +its parent, which is informed about the parameter's value during association, +sends data to the child immediately upon receiving a frame for the child. + +Switching the parameter to \c false on an end devices turns on indirect delivery: +the end device's parent suspends data delivery to the child until it receives +a polling request from the child; on the end device radio is only on when data is +being sent. + +Value range: \c true or \c false \n +C-type: bool \n +Can be set: at any time before network start \n +Persistent: Yes +*/ +#ifndef CS_RX_ON_WHEN_IDLE +#define CS_RX_ON_WHEN_IDLE false +#endif + +// \cond internal +//! \brief Protocol version identifier. Could not be changed by user. +#ifndef CS_PROTOCOL_VERSION +#define CS_PROTOCOL_VERSION 0x02 +#endif +//! \brief Stack profile identifier (Zigbee PRO profile is equal to 2). Could not be changed by user. +#ifndef CS_STACK_PROFILE +#define CS_STACK_PROFILE 0x02 +#endif +// \endcond +//! \brief Default value for the type of a device +/*! +ZigBee device type determines network behavior of a given device and functions it +can perform. To give a brief overview, each networks contains exacty one coordinator and +an arbirtary number of routers and end devices; an end device does not have children, data + is passed through the parent, that is, a router or the coordinator. + +Value range: \n +::DEVICE_TYPE_COORDINATOR (0) - the coordinator\n +::DEVICE_TYPE_ROUTER (1) - a router\n +::DEVICE_TYPE_END_DEVICE (2) - an end device + +C-type: DeviceType_t \n +Can be set: at any time before network start \n +Persistent: Yes +*/ +#ifndef CS_DEVICE_TYPE +#define CS_DEVICE_TYPE DEVICE_TYPE_ROUTER +#endif + +//! \brief The size of the neighbor table +/*! +The parameter determines the size of the neighbor table which is used to store +beacon responses from nearby devices. The parameter puts an upper bound +over the amount of child devices possible for the node. + +Value range: at minimum 1, the maximum value is limited to the available memory \n +C-type: uint8_t \n +Can be set: at compile time only \n +Persistent: No +*/ +#ifndef CS_NEIB_TABLE_SIZE + #define CS_NEIB_TABLE_SIZE 7 +#elif CS_NEIB_TABLE_SIZE == 0 + #undef CS_NEIB_TABLE_SIZE + #define CS_NEIB_TABLE_SIZE 1 + #warning CS_NEIB_TABLE_SIZE was set to 1 +#endif + +//! \brief The maximum number of direct children that a given device (the coordinator or a router) can have +/*! +The parameter is only enabled for routers and the coordinator. An end device can not +have children. If an actual number of children reaches a parameter's value, the node +will have not been able to accept any more children joining the network. The parameter can be +set to 0 on a router thus preventing it from accepting any children and can be help form a +desired network topology. For example, if the parameter is set to 0 on all routers, then the +coordinator will be the only device that can have children and the network will have star topology. + +Value range: from 0 to ::CS_NEIB_TABLE_SIZE \n +C-type: uint8_t \n +Can be set: at compile time only \n +Persistent: No +*/ +#ifndef CS_MAX_CHILDREN_AMOUNT +#define CS_MAX_CHILDREN_AMOUNT 6 +#endif +//! \brief The maximum number of routers among the direct children of the device +/*! +The parameter determines how many routers the device can have as children. Note that the maximum number of +end devices is equal to ::CS_MAX_CHILDREN_AMOUNT - ::CS_MAX_CHILDREN_ROUTER_AMOUNT. + +Value range: from 0 to ::CS_MAX_CHILDREN_AMOUNT \n +C-type: uint8_t \n +Can be set: at compile time only \n +Persistent: No + */ +#ifndef CS_MAX_CHILDREN_ROUTER_AMOUNT +#define CS_MAX_CHILDREN_ROUTER_AMOUNT 2 +#endif +//! \brief The maximum depth of a network +/*! +The parameter determines the maximum depth of a network tree formed by +child-parent relationships between nodes. + +While joining the network the node receives beacon responses from potential +parents containing their actual network depth and declines those which show values not +less than the maximum network depth on the joining device. A potential parent will also reject a +beacon from the joining device and will not sent a response if the joining device shows the network +depth greater than it is allowed on the potential parent. This logic is enabled if the parameter value +is not greater than 15. If its value is greater than 15, then device does not perform any checkings of +the network depth, neither when joining a network nor when accepting other nodes as children. +This allows forming long chains of devices across considerable distances. + +The stack also uses the parameter to calculate several timeouts. Besides, the parameter determines the maximum radius +of a data packet, that is, the maximum number of hops that a packet may travel, which is calculated by +the following formula: + +maximum radius = 2 * MIN(2 * maxNetworkDepth, 255) \n + +These uses of the parameter do not change if its value is greater than 15. Therefore to enable +transmitting data over long chains of devices, the parameter should be set to a real desired network depth, +rather than to an accidental value over 15. + +The parameter should be the same on all devices in the network. + +Value range: from 0 to 255 \n +C-type: uint8_t \n +Can be set: at compile time only \n +Persistent: No +*/ +#ifndef CS_MAX_NETWORK_DEPTH +#define CS_MAX_NETWORK_DEPTH 5 +#endif + +//! \brief The method of automatic address assignment +/*! +If ::CS_NWK_UNIQUE_ADDR equals \c 0 this parameter is used to determine +the assignment method that is applied when a device enters the network to choose +a short address. Otherwise, the parameter is ignored. + +Value range: \n +NWK_ADDR_ALLOC_DISTRIBUTED (equals 0) - distributed address allocation; the stack +applies a special recurrent algorithm to form a kind of a search tree from the network to simplify routing \n +NWK_ADDR_ALLOC_STOCHASTIC (equals 2) - the address is set to a random value, different +from all other short addresses in the network \n +NWK_ADDR_ALLOC_FROM_UID (equals 3) - two lower bytes of the extended address are used +for the short address + +C-type: uint8_t \n +Can be set: at compile time only \n +Persistent: No +*/ +#ifndef CS_ADDRESS_ASSIGNMENT_METHOD +#define CS_ADDRESS_ASSIGNMENT_METHOD 2 +#endif + + +#if defined(AT86RF212) || defined(CUSTOMRF3) +/* Channel number range + Page 0 (BPSK modulation is used and supported IEEE 802.15.4 2003/2006 ) + channel 0: 868 MHz | 20 Kbit/sec + channels 1 - 10: 915 MHz | 40 Kbit/sec + Page 2 (O-QPSK modulation is used and supported IEEE 802.15.4 2006) + channel 0: 868 MHz | 100 Kbit/sec + channels 1 - 10: 915 MHz | 250 Kbit/sec + + BOOST mode is enabled automatically only for 11, 10, 9, 8, 7, 6 dBm. All other power values do not use BOOST mode. +*/ +//! \brief 32-bit mask of channels to be scanned before network is started +/*! +Channels that should be used are marked with logical 1 at corresponding bit +location. + +\note For 900 MHz band you also need to specify channel page + +Value range: 32-bit values: \n +Valid channel numbers for 2.4 GHz band are 0x0b - 0x1a \n +Valid channel numbers for 900 MHz band are 0x00 - 0x0a + +C-type: uint32_t \n +Can be set: at any time before network start \n +Persistent: Yes +*/ + #ifndef CS_CHANNEL_MASK + #define CS_CHANNEL_MASK 0x00000002L + #endif +//! \brief Number of a channel page to be used +/*! +Channel page number defines band and modulation scheme that will be +used for communication. + +Value range: + 0 - 915MHz (BPSK-40, channels 0x01 - 0x0a), 868MHz (BPSK-20, channel 0x00) \n + 2 - 915MHz (O-QPSK-250, channels 0x01 - 0x0a), 868Mhz (O-QPSK-100, channel 0x00) \n + 5 - 780MHz (O-QPSK-250, channels 0x00 - 0x03, Chinese band) + +C-type: uint8_t \n +Can be set: at any time before network start \n +Persistent: Yes +*/ + #ifndef CS_CHANNEL_PAGE + #define CS_CHANNEL_PAGE 0 + #endif + +#else // AT86RF230/230B/231 +//! \brief 32-bit mask of channels to be scanned before network is started +/*! +Channels that should be used are marked with logical 1 at corresponding bit +location. + +\note For 900 MHz band you also need to specify channel page + +Value range: 32-bit values: \n +Valid channel numbers for 2.4 GHz band are 0x0b - 0x1a \n +Valid channel numbers for 900 MHz band are 0x00 - 0x0a + +C-type: uint32_t \n +Can be set: at any time before network start \n +Persistent: Yes +*/ + #ifndef CS_CHANNEL_MASK + #define CS_CHANNEL_MASK 0x00010000L + #endif +//! \brief Number of a channel page to be used. Ignored in the case of AT86RF230/230B/231 RF chip. + #ifndef CS_CHANNEL_PAGE + #define CS_CHANNEL_PAGE 0 + #endif +#endif + +//! \brief Extended PAN ID of the network to which the device should join +/*! +The parameter specifies the predefined extended PANID of the network to be formed +(for the coordinator) or joined (for a router or an end device). For a router or an end device + the parameter can equal 0 allowing them to join the first suitable network that they discover. + +Value range: All 64-bit values except for 0xFFFFFFFFFFFFFFFFLL; +specify a value in the \c 0x123456789ABCDEFLL format. \n +C-type: ExtPanId_t (equal to uint64_t) \n +Can be set: at any time before network start \n +Persistent: Yes +*/ +#ifndef CS_EXT_PANID +#define CS_EXT_PANID CS_UID +#endif +//! \brief An actual value of the extended PANID after network has started +/*! +Is automatically written by the stack with an actual extended PANID of the network +to which the device joined. The parameter should not be changed while the device is +in the network. + +Value range: All 64-bit values, specify a value in the \c 0x123456789ABCDEFLL format. \n +C-type: ExtPanId_t (equal to uint64_t) \n +Can be set: at any time before network start \n +Persistent: Yes.*/ +#ifndef CS_NWK_EXT_PANID +#define CS_NWK_EXT_PANID 0LL +#endif +/*! \brief Determines whether the static or automatic addressing mode will be used for the short address + +If set to \c 1, the ::CS_NWK_ADDR will be used as the device's short address. +Otherwise, the short address is assigned automatically by the stack. An actual assignment +method is specified in ::CS_ADDRESS_ASSIGNMENT_METHOD. + +Value range: \c 1 or \c 0 \n +C-type: bool \n +Can be set: at any time before network start \n +Persistent: Yes +*/ +#ifndef CS_NWK_UNIQUE_ADDR +#define CS_NWK_UNIQUE_ADDR 0 +#endif +//! \brief Device's short address if ::CS_NWK_UNIQUE_ADDR equals 1 +/*! +If static addressing is applied the stack uses the value of the parameter as a short address. Otherwise, +the stack assigns the parameter to a randomly chosen value unique within the network. In both cases +after the network start the parameter holds actual short address of the device. While the device is in +the network its value must not be changed. + +Note that the coordinator short address always equals \c 0x0000. + +Value range: 0x0000 - 0xFFF8 \n +C-type: ShortAddr_t \n +Can be set: at any time before network start \n +Persistent: Yes +*/ +#ifndef CS_NWK_ADDR +#define CS_NWK_ADDR 0xFFFF +#endif +//! \brief End device sleep period given in milliseconds +/*! +On an end device this parameter determines the duration of a sleep period. Falling asleep is +performed with the ZDO_SleepReq() request. After sleeping period exceeds the node is awakened and +the application receives an indication via ZDO_WakeUpInd(). +If the parameter's value is 0, then after the node falls asleep it can only be awakened by a +hardware interrupt; a callback for a given IRQ is registered via HAL_RegisterIrq(). +On a router or the coordinator, the parameter is used in two ways: + +1) To remove information about lost child end devices. If a parent receives no data polls or data +frames from the child end device for +CS_NWK_END_DEVICE_MAX_FAILURES*(CS_END_DEVICE_SLEEP_PERIOD + CS_INDIRECT_POLL_RATE) ms, +then it assumes it to be lost and deletes all information about such child. + +2) To determine whether to store or drop a message addressed to a child end device. The parent +estimates the time when its child end device will wake up by adding this value to the moment when the last poll +request has been received. If the time till end device wake up is greater than CS_MAC_TRANSACTION_TIME +the frame is stored. Otherwise, the frame is dropped. + +Value range: any value valid for the C-type; add "L" after a value \n +C-type: uint32_t \n +Can be set: at any time \n +Persistent: No +*/ +#ifndef CS_END_DEVICE_SLEEP_PERIOD +#define CS_END_DEVICE_SLEEP_PERIOD 10000L +#endif + +//! \brief Full Function Device sleep period given in milliseconds +#ifndef CS_FFD_SLEEP_PERIOD +#define CS_FFD_SLEEP_PERIOD 10000L +#endif + +//! \brief Encryption time of maximum-size packet in ms. Decryption time is equal to encryption time. +#ifndef CS_ENCRYPTION_TIME +#if defined(_SECURITY_) + #ifdef _MAC_HW_AES_ + #define CS_ENCRYPTION_TIME 18 // HW encryption + #else + #define CS_ENCRYPTION_TIME 119 // SW encryption + #endif +#else + #define CS_ENCRYPTION_TIME 0ul +#endif +#endif + +//! \brief Duration of internal processing of the maximum-size packet (without encryption) +#define CS_PACKET_PROCESS_INSIDE 7 + +//! \brief A period in ms of polling a parent for data by an end device +/*! +On a sleeping end device the parameter determines a period with which poll requests +are sent to the parent while the end device is awaken. A parent of a sleeping end device +uses the parameter to calculate estimates of the time when the next poll request from a child +will be received. + +Value range: any value valid for the C-type \n +C-type: uint32_t \n +Can be set: at any time \n +Persistent: No +*/ +#ifndef CS_INDIRECT_POLL_RATE +#define CS_INDIRECT_POLL_RATE 1000 +#endif + +//! \brief A value used to calculate the length of time to spend scanning each channel +/*! +While scanning channels during network join the node keeps listening to each channel +specified by the ::CS_CHANNEL_MASK for a period of time calculated according to the +formula that for the 2.4GHz frequency band is: \n + +960 * 16 * (2 raised to a power n + 1) microseconds, + +providing n is a value of this parameter. Note that the formula for the Sub-GHz employs +another constant instead of 16. + +Value range: 0x00-0x0e \n +C-type: uint8_t \n +Can be set: at any time \n +Persistent: No +*/ +#ifndef CS_SCAN_DURATION +#define CS_SCAN_DURATION 0x05 +#endif +//! \brief Specifies whether the device accepts children joining via MAC association +/*! +If the parameter being switched between \c 0xff and \c 0x00, determines whether the device +accepts or not a child joining the network via MAC association, that is, if the joining device does not +possess the PANID value of the network and its PANID parameter is set to 0. + +The parameter can be set before the netwrok start only. Once the device entered the netwrok it can +only switch the parameter with the help of a permit duration ZDP request. + +Value range: 0xff means "always on", 0x00 means "always off" \n +C-type: uint8_t \n +Can be set: at any time before network start \n +Persistent: No + */ +#ifndef CS_PERMIT_DURATION +#define CS_PERMIT_DURATION 0xff +#endif +//! \brief Enables or disables the multicast transmission mode at the NWK layer +/*! +If the parameter is set to \true multicasting on the NWK level is used, otherwise, +multicasting on the APS level is applied. The parameter is recommended to be set to +\c true. For detail refer to ZigBee specification. + +Value range: \c true or \c false \n +C-type: bool \n +Can be set: at any time before network start \n +Persistent: No +*/ +#ifndef CS_NWK_USE_MULTICAST +#define CS_NWK_USE_MULTICAST true +#endif + +//! \brief Indicates whether a complex descriptor is available on this device +/*! +Value range: \c true or \c false \n +C-type: bool \n +Can be set: at any time before network start \n +Persistent: Yes +*/ +#ifndef CS_COMPLEX_DESCRIPTOR_AVAILABLE +#define CS_COMPLEX_DESCRIPTOR_AVAILABLE false +#endif + +//! \brief Specifies whether a user descriptor is available on this device +/*! +A user descriptor is simply a string that can be assigned to a device and requested +by other devices in the network to identify the device. A user descriptor can read +and set on a remote device as well as on the local device with the help of corresponding +ZDP requests. + +Value range: \c true or \c false \n +C-type: bool \n +Can be set: at any time before network start \n +Persistent: Yes +*/ +#ifndef CS_USER_DESCRIPTOR_AVAILABLE +#define CS_USER_DESCRIPTOR_AVAILABLE true +#endif + +//! \brief The stack version +/*! +This is a read-only parameter specifying the stack version +used by the device. + +C-type: uint32_t \n +Can be set: at compile time only \n +Persistent: No +*/ +#ifndef CS_STACK_VERSION +#define CS_STACK_VERSION CS_STACK_VERSION_VALUE +#endif + +#ifdef _COMMISSIONING_ +//! \brief Persistent memory storing interval (ms) +#ifndef CS_PDS_STORING_INTERVAL +#define CS_PDS_STORING_INTERVAL 300000UL /* 5 minutes */ +#endif + +//! \brief Enabales or disables the power failure feature. +#ifdef _POWER_FAILURE_ +#ifndef CS_POWER_FAILURE +#define CS_POWER_FAILURE false +#endif +#endif /* _POWER_FAILURE_ */ +#endif /* _COMMISSIONING_ */ + +// by default in MAC = 7680L +//! \brief MAC transaction persistence time measured in ms +/*! +The parameter determines the maximum interval (in ms) a frame addressed to a sleeping +end device can be stored on the parent node. If the end device does not poll for data +during this time, then the frame is dropped. + +Value range: all unsinged 32-bit integers\n +C-type: uint32_t \n +Can be set: at any time \n +Persistent: No +*/ +#ifndef CS_MAC_TRANSACTION_TIME +#define CS_MAC_TRANSACTION_TIME ((uint32_t)CS_END_DEVICE_SLEEP_PERIOD + ((uint32_t)CS_INDIRECT_POLL_RATE * 3ul)) +#endif + +//! \brief The size of the APS duplicate rejection table +/*! +The duplicate rejection table is used by APS to store information about incoming +unicast messages in order to reject messages that have been already received and processed. +Following ZigBee specification, the parameter should be not less than 1. + +Value range: greater than 1 \n +C-type: uint8_t \n +Can be set: at compile time only \n +Persistent: No +*/ +#ifndef CS_DUPLICATE_REJECTION_TABLE_SIZE +#define CS_DUPLICATE_REJECTION_TABLE_SIZE 10 +#endif + +//! \brief The maximum number of records in the NWK route table. +/*! +The parameter sets the maximum number of records that can be kept in the +NWK route table. The table is used by NWK to store information about established +routes. Each table entry specifies the next-hop short address for a route from the +current node to a given destination node. The table is being filled automatically +during route discovery. An entry is added when a route is discovered. + +Since the end device always sends a frame directly to its parent its route table size +should be set to 0. + +C-type: uint8_t \n +Can be set: at compile time only \n +Persistent: No +*/ +#if defined _ROUTER_ || defined _COORDINATOR_ + #if !defined CS_ROUTE_TABLE_SIZE + #define CS_ROUTE_TABLE_SIZE 4 + #endif + #if CS_ROUTE_TABLE_SIZE == 0 + #undef CS_ROUTE_TABLE_SIZE + #define CS_ROUTE_TABLE_SIZE 1 + #warning CS_ROUTE_TABLE_SIZE was set to 1 + #endif +#else // _ENDDEVICE_ + #undef CS_ROUTE_TABLE_SIZE + #define CS_ROUTE_TABLE_SIZE 0 +#endif // _ROUTER_ or _COORDINATOR_ + +//! \brief The maximum number of records in the NWK address map table +/*! +The parameter sets the maximum number of records in the address map table used by +NWK to store pairs of corresponding short and extended addresses. The stack appeals +to the table when a data frame is being sent to a specified extended address to extract +the corresponding short address. If it fails to find the short address, an error is reported. + +C-type: NwkSizeOfAddressMap_t (typedef for uint8_t) \n +Can be set: at compile time only \n +Persistent: No +*/ +#ifndef CS_ADDRESS_MAP_TABLE_SIZE +#define CS_ADDRESS_MAP_TABLE_SIZE 5 +#endif +#if CS_ADDRESS_MAP_TABLE_SIZE == 0 + #undef CS_ADDRESS_MAP_TABLE_SIZE + #define CS_ADDRESS_MAP_TABLE_SIZE 1 + #warning CS_ADDRESS_MAP_TABLE_SIZE was set to 1 +#endif + +//! \brief The maximum number of records in the NWK route discovery table +/*! +The parameter specifies the size of the route discovery table used by NWK to store +next-hop addresses of the nodes for routes that are not yet established. Upon exausting +the capacity of the table, the stack starts rewriting old entries. If the size of the route table +is big enough after all used routes are established the table may not be used. + +Since the end device always sends a frame directly to its parent its route discovery table size +should be set to 0. + +C-type: uint8_t \n +Can be set: at compile time only \n +Persistent: No +*/ +#if defined _ROUTER_ || defined _COORDINATOR_ + #if !defined CS_ROUTE_DISCOVERY_TABLE_SIZE + #define CS_ROUTE_DISCOVERY_TABLE_SIZE 3 + #endif + #if CS_ROUTE_DISCOVERY_TABLE_SIZE == 0 + #undef CS_ROUTE_DISCOVERY_TABLE_SIZE + #define CS_ROUTE_DISCOVERY_TABLE_SIZE 1 + #warning CS_ROUTE_DISCOVERY_TABLE_SIZE was set to 1 + #endif +#else // _ENDDEVICE_ + #undef CS_ROUTE_DISCOVERY_TABLE_SIZE + #define CS_ROUTE_DISCOVERY_TABLE_SIZE 0 +#endif // _ROUTER_ or _COORDINATOR_ + +#if !defined CS_NWK_BUFFERS_AMOUNT + #define CS_NWK_BUFFERS_AMOUNT 4 +#endif // CS_NWK_BUFFERS_AMOUNT + +//!\brief The size of the passive acknoledgement table +#if !defined CS_NWK_PASSIVE_ACK_AMOUNT + #define CS_NWK_PASSIVE_ACK_AMOUNT 8 +#endif // CS_NWK_PASSIVE_ACK_AMOUNT + +//!\brief The size of of the broadcast transmission table +/*! +The broadcast transmission table is used for tracking incoming broadcast messages +to mark messages that have already been processed by the node. This causes only one +copy for each broadcast message to be processed. An entry for a broadcast message is +stored for a certain period of time and then removed. + +C-type: uint8_t \n +Can be set: at compile time only \n +Persistent: No +*/ +#if !defined CS_NWK_BTT_SIZE + #define CS_NWK_BTT_SIZE 8 +#endif + +//!\brief The size of of the group table +/*! +The size cannot be 0. The group table stores pairs of a group address and an endpoint. Upon +receiving a frame addressed to members of a certain group which include the current node as well +the stack fires indications on all endpoints registered with the group address. + +C-type: uint8_t \n +Can be set: at compile time only \n +Persistent: No +*/ +#if defined CS_GROUP_TABLE_SIZE + #if CS_GROUP_TABLE_SIZE == 0 + #undef CS_GROUP_TABLE_SIZE + #define CS_GROUP_TABLE_SIZE 1 + #warning CS_GROUP_TABLE_SIZE was set to 1 + #endif +#else + #define CS_GROUP_TABLE_SIZE 1 +#endif + +//! \brief The number of buffers for data requests on the APS layer +/*! +The parameter specifies the number of buffers that are allocated by APS +to store data requests parameters. The parameter puts an upper bound to the number of +data requests that can be processed by APS simultaneously. If all buffers are in +use and a new data request appears, it is kept in a queue until a buffer is released. + +C-type: uint8_t \n +Can be set: at compile time only \n +Persistent: No +*/ +#ifndef CS_APS_DATA_REQ_BUFFERS_AMOUNT + #ifdef _SECURITY_ + #define CS_APS_DATA_REQ_BUFFERS_AMOUNT 3 + #else // !_SECURITY_ + #define CS_APS_DATA_REQ_BUFFERS_AMOUNT 2 + #endif // _SECURITY_ +#endif + +//! \brief The number of buffers for acknowledgement messages sent by APS +/*! +This parameter determines the amount of memory that needs to be allocted for a special type +of buffers used by APS to store payloads for acknowledgement frames. The need to use the buffers +occurs when the node receives a frame that has to be acknowledged. That is, the APS component on +the node has to send an acknowledgement frame. For frames initiated by the application, the memory for +a payload is to be allocated by the application on its own, while the payload memory for an acknowledgement +frame shall be reserved by APS. The request parameters are still stored in the data request buffers. + +Typically, a value of this parameter equals ::CS_APS_DATA_REQ_BUFFERS_AMOUNT - 1. + +C-type: uint8_t \n +Can be set: at compile time only \n +Persistent: No +*/ +// To send APS ACK both types of buffers are used (.._DATA_REQ_.. and .._ACK_FRAME_..) +#ifndef CS_APS_ACK_FRAME_BUFFERS_AMOUNT + #define CS_APS_ACK_FRAME_BUFFERS_AMOUNT 2 +#endif + +//! \brief The maximum number of transmissoin retries allowed at the APS layer +/*! +The parameter sets the number of attempts that will be made by APS layer to +transmit a data frame. If all these attempts fail due to underlying layers failures, +then APS response with an error status. + +C-type: uint8_t \n +Can be set: at any time before network start \n +Persistent: No +*/ +#ifndef CS_APS_MAX_FRAME_RETRIES + #define CS_APS_MAX_FRAME_RETRIES 3 +#elif CS_APS_MAX_FRAME_RETRIES > 5 + #undef CS_APS_MAX_FRAME_RETRIES + #define CS_APS_MAX_FRAME_RETRIES 5 + #warning CS_APS_MAX_FRAME_RETRIES was set to 5 +#endif + +#ifndef CS_DTR_WAKEUP +#define CS_DTR_WAKEUP false +#endif + +/*! \brief If the number of consecutives link status frames given by this parameter is missed +from a neighbor it is removed from the neigbor table + +For all neighbors except for end device children the stack tracks the time of receiving link statuses. +If link statuses are not received from a given neighbor for this parameter's value times of link status +period (typically 15 seconds), then the neighbor is deleted from the neighbor table. + +C-type: uint8_t \n +Can be set: at any time \n +Persistent: No +*/ +#ifndef CS_NWK_MAX_LINK_STATUS_FAILURES +#define CS_NWK_MAX_LINK_STATUS_FAILURES 3 +#endif + +/*! \brief Is used to calculate the length of time after which a not responding +end device child is considered lost + +A sleeping end device is considered lost and a corresponding notification is raised on the +parent, if the end device does not polls for data for the time span which duration is calculated by +the following formula: +\code +CS_NWK_END_DEVICE_MAX_FAILURES * (CS_END_DEVICE_SLEEP_PERIOD + CS_INDIRECT_POLL_RATE) +\endcode + +C-type: uint8_t \n +Can be set: at any time \n +Persistent: No + */ +#ifndef CS_NWK_END_DEVICE_MAX_FAILURES +#define CS_NWK_END_DEVICE_MAX_FAILURES 3 +#endif + +//! \brief The maximum number of records in the binding table +/*! +The parameter sets the size of the binding table used by APS to store binding +links, which are structures containing information about source and destination +extended addresses and endpoints for unicast bindings and just group addresses +as destinations for group bindings. If the binding is going to be applied to send +a data frame, then the corresponding entry shall be first inserted into the table via +the APS_BindingReq() function. + +C-type: uint8_t \n +Can be set: at compile time only \n +Persistent: No +*/ +#ifdef _BINDING_ +#ifndef CS_APS_BINDING_TABLE_SIZE + #define CS_APS_BINDING_TABLE_SIZE 1 +#endif +#endif //_BINDING_ + +#ifdef _APS_FRAGMENTATION_ +//! \brief The maximum number of blocks the asdu can be split into +/*! +This parameter limits the number of pieces to which the data sent with one APS request +can be split i f the fragmentation feature is applied. Thus it also limits the maximum amount +of data sent by the application with a single request:\n +maximum data length = ::CS_APS_MAX_BLOCKS_AMOUNT * ::CS_APS_BLOCK_SIZE if the latter +parameter is not 0, else \n +maximum data length = ::CS_APS_MAX_BLOCKS_AMOUNT * ::APS_MAX_ASDU_SIZE. + +C-type: uint8_t \n +Can be set: at compile time only \n +Persistent: No + */ +#ifndef CS_APS_MAX_BLOCKS_AMOUNT +#define CS_APS_MAX_BLOCKS_AMOUNT 0 +#endif + +//! \brief The block size that is used for fragments in fragmented transmission +/*! +If the value is 0, then the maximum possible size is used for the block size, that is, the value +of ::CS_APS_MAX_ASDU_SIZE. The parameter and ::CS_APS_MAX_BLOCKS_AMOUNT are + also used to determine an amount of memory allocated for a special buffer that keeps parts of +incoming fragmented message until all of them are received. + +C-type: uint16_t \n +Can be set: at compile time only \n +Persistent: No +*/ +#ifndef CS_APS_BLOCK_SIZE +#define CS_APS_BLOCK_SIZE 0 +#endif +#if ((CS_APS_BLOCK_SIZE > APS_MAX_ASDU_SIZE) || (CS_APS_BLOCK_SIZE == 0)) + #undef CS_APS_BLOCK_SIZE + #define CS_APS_BLOCK_SIZE APS_MAX_ASDU_SIZE +#endif + +//! \brief Maximum transmission window size (in blocks) +/*! +The parameter determines how many pieces of a fragmented message are sent before +waiting for an aknowledgement. After acknowledgement is received another +portion of frames are sent and so on. + +Value range: greater than 0 \n +C-type: uint8_t \n +Can be set: at any time before network start \n +Persistent: No +*/ +#ifndef CS_APS_MAX_TRANSMISSION_WINDOW_SIZE + #ifdef _ZHP_SECURITY_ + #define CS_APS_MAX_TRANSMISSION_WINDOW_SIZE 1 + #else + #define CS_APS_MAX_TRANSMISSION_WINDOW_SIZE 3 + #endif +#endif + +#endif /* _APS_FRAGMENTATION_ */ + + +/***************************************************************************** + Security related defines +*****************************************************************************/ + +#ifdef _SECURITY_ +/*! \brief Turns on/off security features + +The parameter shall be configured before the network start. If it is set +to \c false, authentication is not applied as well as encryption of data frames, +therefore the device will only be able to enter networks without security. + +Value range: \c true of \c false \n +C-type: bool \n +Can be set: at any time before network start \n +Persistent: No +*/ +#ifndef CS_SECURITY_ON +#define CS_SECURITY_ON true +#endif + +/*! \brief A timeout for authentication procedures + +A timeout is started when connection with a parent is established. If the +security related procedures that are performed after this will not be completed +before the timeout exceeds, the device will fail joining the network. A value is +measured in milliseconds. + +C-type: uint32_t \n +Can be set: at compile time only \n +Persistent: No +*/ +#ifndef CS_APS_SECURITY_TIMEOUT_PERIOD +#define CS_APS_SECURITY_TIMEOUT_PERIOD (2 * 1000 * 10) +#endif + +//! \brief Default address of the trust center +/*! +The parameter specifies the trust center extended address. The stack makes use of the +parameter to support various opertaions in networks with security enabled. For correct network operation +the parameter's value must coincide with the actual trust center address. + +In case the trust center extended address is unknown, for example, for testing purposes, the +parameter can be set to the universal trust center address which equals ::APS_SM_UNIVERSAL_TRUST_CENTER_EXT_ADDRESS. + +Value range: All 64-bit values except for 0xFFFFFFFFFFFFFFFFLL, +specify a value in the \c 0x123456789ABCDEFLL format. \n +C-type: ExtAddr_t \n +Can be set: at any time before network start \n +Persistent: Yes +*/ +#ifndef CS_APS_TRUST_CENTER_ADDRESS +#define CS_APS_TRUST_CENTER_ADDRESS 0xAAAAAAAAAAAAAAAALL +#endif +//! \brief ZDO security status. +/*! +The parameter is used to determine the security type. + +Value range: 0,3 - for standard security; 1 - for stdlink security; 1,2,3 - for high security. \n +0 - network key is preconfigured ; \n +1 - network join without master key, but with the trust center link key, which must be set via APS_SetLinkKey();\n +2 - network join employs the trust center master key, which must be set via APS_SetMasterKey(); \n +3 - for standard security:network key is not preconfigured, but rather received from the + trust center in an unencrypted frame; + for high security:the trust center master key is not preconfigured, but rather received + from the trust center during network join. + +C-type: uint8_t \n +Can be set: at any time before network start \n +Persistent: Yes + */ +#ifndef CS_ZDO_SECURITY_STATUS +#define CS_ZDO_SECURITY_STATUS 0 +#endif +/*! \brief The maximum number of network keys that can be stored on the device + +A device in a secured network can keep several network keys up to the value of this +parameter. Upon frame reception the device extracts key sequence number from the auxiliary +header of the frame and decrypts the message with the network key corresponding to this +sequence number. Besides, one key is considered active for each device; this is the key that +is used for encrypting outgoing frames. + +Network keys are distributed by the trust center with the help of the APS_TransportKeyReq() +command. A switch to a new active network key is also initiated by the trust center, which +should use the APS_SwitchKeyReq() function. + +C-type: NwkKeyAmount_t (typedef for uint8_t) \n +Can be set: at compile time only \n +Persistent: No +*/ +#ifndef CS_NWK_SECURITY_KEYS_AMOUNT +#define CS_NWK_SECURITY_KEYS_AMOUNT 1 +#endif +/*! \brief Default value of the network key + +This is a parameter to store a value of the network key which is used to encrypt a part of a +data frame occupied by the NWK payload. This type of encryption is applied in both the standard and +high security mode. The high security mode also enables encryption of the APS payload with a link +key, but if the \c txOptions.useNwkKey field in APS request parameters is set to 0, the +APS payload is ecrypted with the network key. + +The network key must be predefined if standard security is used with ::CS_ZDO_SECURITY_STATUS +set to 0. For all other values of ::CS_ZDO_SECURITY_STATUS the network key is received from the +trust center during device authentication. Note that in the standard security mode with +::CS_ZDO_SECURITY_STATUS equal to 3 the network key is trasferred to the joining device +in an unencrypted frame. + +Value range: all 128-bit values \n +C-type: uint8_t[16] or any compatible \n +Can be set: at any time before network start \n +Persistent: No +*/ +#ifndef CS_NETWORK_KEY +#define CS_NETWORK_KEY {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0} +#endif +// \cond internal +// Default security level.When calculating APS_MAX_ASDU_SIZE assumed that this parameter is 5. +#ifndef CS_SECURITY_LEVEL +#define CS_SECURITY_LEVEL 0x05U +#endif +#if CS_SECURITY_LEVEL != 0x05U +#error Parameter CS_SECURITY_LEVEL must be 5. +#endif + +// Default nwkSecureAllFrames attribute value in NIB. +#ifndef CS_SECURITY_ALL_FRAMES +#define CS_SECURITY_ALL_FRAMES true +#endif +// \endcond +/*! \brief The maximum number of authentication requests that the trust center can process simultaneously + +The parameter is used on the trust center to allocate memory for buffers used +during joining device authentication. A value of the parameter determines how many +authentication request the stack on the trust center can process at once. + +C-type: uint8_t \n +Can be set: at compile time only \n +Persistent: No +*/ +#ifndef CS_MAX_TC_AUTHENTIC_PROCESS_AMOUNT + #define CS_MAX_TC_AUTHENTIC_PROCESS_AMOUNT 1 +#endif + +#ifdef _TC_PERMISSION_TABLE_ +//! \brief For a trust center, the maximum amount of records in the permission table + #ifndef CS_MAX_TC_ALLOWED_DEVICES_AMOUNT + #define CS_MAX_TC_ALLOWED_DEVICES_AMOUNT 5 + #endif +#endif + +#ifdef _LINK_SECURITY_ +//! \brief The maximum number of entries in APS key-pair set +/*! +The parameter is used in stadard security with link keys and in high security +to specify the size of the APS key-pair set. The APS key-pair set stores pairs of corresponding +extended address and a link key or a mster key. +For each node with which the current node is going to communicate it must keep an entry with +the remote node extended address and a link key. If the link key is unknown, the node can request +the trust center for it via APS_RequestKeyReq(). The trust center must store a link key or a master +key depending on the CS_SECURITY_STATUS used for each node it is going to authenticate. +Entries can also be added manually by APS_SetLinkKey() and APS_SetMasterKey(). + +Value range: 1 - 255 \n +C-type: uint8_t \n +Can be set: at compile time only \n +Persistent: No +*/ +#ifndef CS_APS_KEY_PAIR_DESCRIPTORS_AMOUNT +#define CS_APS_KEY_PAIR_DESCRIPTORS_AMOUNT 3 +#endif + +//\cond internal +//Not used in the stack +#ifndef CS_MASTER_KEY +#define CS_MASTER_KEY {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0} +#endif + +#ifndef CS_MAX_TC_ESTABLISH_KEY_AMOUNT +#define CS_MAX_TC_ESTABLISH_KEY_AMOUNT 1 +#endif +//\endcond +#endif + + +#endif + +/*! \brief The number of network join attempts ZDO performs before it reports failure + +Determines the maximum number of attempts to enter a network performed by the stack +during network start. Upon each attempt ZDO sends a beacon request and collects +beacon responses from nearby devices all over again. A pause length between two attempts +is given by the ::CS_ZDO_JOIN_INTERVAL parameter. + +C-type: uint8_t \n +Can be set: at any time before network start \n +Persistent: No +*/ +#ifndef CS_ZDO_JOIN_ATTEMPTS +#define CS_ZDO_JOIN_ATTEMPTS 4 +#endif + +/*! \brief The interval between two network join attempts + +The parameter specifies the time span in milliseconds between two attempts +to join the network. See ::CS_ZDO_JOIN_ATTEMPTS description. + +C-type: uint32_t \n +Can be set: at any time before network start \n +Persistent: No +*/ +#ifndef CS_ZDO_JOIN_INTERVAL +#define CS_ZDO_JOIN_INTERVAL 1000 +#endif + +/*! \brief ZDP response waiting timeout in millisecods. To use automatically calculated value set to 0 + +The parameter determines the length of time for which the reply in response to a ZDP request +is waited. if the response is not received before the timeout exceeds the confirmation callback for +the ZDP request is called to report a failure status. + +C-type: uint16_t \n +Can be set: at any time before network start \n +Persistent: No +*/ +#ifndef CS_ZDP_RESPONSE_TIMEOUT +#define CS_ZDP_RESPONSE_TIMEOUT 0 +#endif + +//! \brief TC Keep-Alive polling interval, should be in the range 5-20 minutes. +#ifndef CS_ZDO_TC_KEEP_ALIVE_INTERVAL +#define CS_ZDO_TC_KEEP_ALIVE_INTERVAL 20 +#endif + + +//! \brief Indication to use a predefined network PANID value +/*! +If a predefined value is required to be used for the network PANID, the parameter +shall be set to \c true. Otherwise, it shall be set to \c false. + +Value range: \c true or \c false \n +C-type: bool \n +Can be set: at any time before network start \n +Persistent: Yes +*/ +#ifndef CS_NWK_PREDEFINED_PANID +#define CS_NWK_PREDEFINED_PANID false +#endif + +//! \brief A predefined short PANID value +/*! +The parameter holds the short PANID value generated randomly if ::CS_NWK_PREDEFINED_PANID +equals \c false. Otherwise, the predefined parameter's value is +used as the short PANID. + +Value range: 16-bit values from the range 0x0000 - 0xFFFE \n +C-type: PanId_t (typedef for uint16_t) \n +Can be set: at any time before network start \n +Persistent: Yes +*/ +#ifndef CS_NWK_PANID +#define CS_NWK_PANID 0x1234 +#endif +// \cond internal +/*! 16-bit manufacturer code allocated by the ZigBee Alliance. + * See ZigBee Manufacturer Code Database, 053874r16, Atmel code. */ +#ifndef CS_MANUFACTURER_CODE +#define CS_MANUFACTURER_CODE 0x1014 +#endif + +#if defined _ROUTER_ || defined _COORDINATOR_ + #if !defined CS_JOIN_IND_OBJ_AMOUNT + #define CS_JOIN_IND_OBJ_AMOUNT (CS_NWK_BUFFERS_AMOUNT >> 1) + #endif +#else // _ENDDEVICE_ + #undef CS_JOIN_IND_OBJ_AMOUNT + #define CS_JOIN_IND_OBJ_AMOUNT 0 +#endif // _ROUTER_ or _COORDINATOR_ + +/* Maximum number of records in the route cache */ +#if defined _NWK_ROUTE_CACHE_ && (defined _ROUTER_ || defined _COORDINATOR_) + #if !defined CS_ROUTE_CACHE_SIZE + #define CS_ROUTE_CACHE_SIZE 4 + #endif /* CS_ROUTE_CACHE_SIZE */ + #if CS_ROUTE_CACHE_SIZE == 0 + #undef CS_ROUTE_CACHE_SIZE + #define CS_ROUTE_CACHE_SIZE 1 + #warning CS_ROUTE_CACHE_SIZE was set to 1 + #endif +#else /* no route cache */ + #undef CS_ROUTE_CACHE_SIZE + #define CS_ROUTE_CACHE_SIZE 0 +#endif + +/** The time in milliseconds between concentrator route discoveries. + * ZigBee spec r18, Table 3.44, page 348. */ +#if !defined NWK_CONCENTRATOR_DISCOVERY_TIME + #define NWK_CONCENTRATOR_DISCOVERY_TIME 20000UL /* milliseconds */ +#endif + +// \endcond +#endif //_MAC2_ + +#ifdef _ZCL_ +#ifndef CS_ZCL_ATTRIBUTE_REPORT_TIMER_INTERVAL + #define CS_ZCL_ATTRIBUTE_REPORT_TIMER_INTERVAL 4000 +#endif + +#ifndef CS_ZCL_MEMORY_BUFFERS_AMOUNT + #define CS_ZCL_MEMORY_BUFFERS_AMOUNT 5 +#endif + +#ifdef _OTAU_ +/** \brief The default address of an upgrade server + +The parameter indicates how the OTAU client will search for OTAU servers in the network. +If one of broadcast addresses is specified, the client will attempt to find all devices supporting +the OTAU server cluster and will request new images from the first server that will respond. +Otherwise, the client will try to connect to a particular device with the specified extended +address. + +The parameter is valid for OTAU clients only. + +Value range: any 64-bit value: \n +\li \c 0x0000000000000000ull, \c 0xFFFFFFFFFFFFFFFFull - a server discovery request is broadcasted +\li otherwise, the client tries to connect to a particular node + +C-type: ExtAddr_t \n +Can be set: at any time before an OTAU start \n +Persistent: No +*/ +#ifndef CS_ZCL_OTAU_DEFAULT_UPGRADE_SERVER_IEEE_ADDRESS + #define CS_ZCL_OTAU_DEFAULT_UPGRADE_SERVER_IEEE_ADDRESS 0xFFFFFFFFFFFFFFFFull +#endif +/** \brief The interval in milliseconds between two attempts to find an upgrade server + +The parameter is valid for OTAU clients only. + +Value range: any 32-bit value \n +C-type: uint32_t \n +Can be set: at any time before an OTAU start \n +Persistent: No +*/ +#ifndef CS_ZCL_OTAU_SERVER_DISCOVERY_PERIOD + #define CS_ZCL_OTAU_SERVER_DISCOVERY_PERIOD 60000ul +#endif +/** Default values of OTAU session. */ +/** \brief The amount of servers the OTAU client can listen to during upgrade server discovery + +The OTAU client can store information about several discovered OTAU servers. However, the client +device tries to connect to discovered servers one by one until the first successful attempt and then +communicates and uploads the whole image from the fisrt suitable server. + +The parameter is valid for OTAU clients only. + +Value range: at least 1 \n +C-type: uint8_t \n +Can be set: at compile time only \n +Persistent: No +*/ +#ifndef CS_ZCL_OTAU_DISCOVERED_SERVER_AMOUNT + #define CS_ZCL_OTAU_DISCOVERED_SERVER_AMOUNT 1 +#endif +/** \brief The number of clients that the OTAU server can serve simultaneously + +If this parameter equals 1, the OTAU server will upgrade devices in the network +one by one. However, the server can process more than one client sessions at a time, +if this parameter is greater than 1. + +The parameter is valid for OTAU servers only. + +Value range: at least 1 \n +C-type: uint8_t \n +Can be set: at compile time only \n +Persistent: No +*/ +#ifndef CS_ZCL_OTAU_CLIENT_SESSION_AMOUNT + #define CS_ZCL_OTAU_CLIENT_SESSION_AMOUNT 1 +#endif +/** \brief Usage of page request for OTAU +*/ +#ifndef CS_ZCL_OTAU_IMAGE_PAGE_REQUEST_USAGE + #define CS_ZCL_OTAU_IMAGE_PAGE_REQUEST_USAGE 1 +#endif +/** \brief Timeout between Image Block Response packet sent form server to client + +The value indicates how fast the server shall send the data (via Image Block Response command) to the client. +The value is determined by the client. +The server shall wait at the minimum the (response) spacing value before sending more data to the client. +The value is in milliseconds. +*/ +#ifndef CS_ZCL_OTAU_IMAGE_PAGE_REQUEST_RESPONSE_SPACING + #define CS_ZCL_OTAU_IMAGE_PAGE_REQUEST_RESPONSE_SPACING 200 +#endif +/** \brief Page size + +The value indicates the number of bytes to be sent by the server before the client sends another Image Page Request command. +In general, page size value shall be larger than the maximum data size value. +*/ +#if CS_ZCL_OTAU_IMAGE_PAGE_REQUEST_USAGE == 1 + #ifndef CS_ZCL_OTAU_IMAGE_PAGE_REQUEST_PAGE_SIZE + #define CS_ZCL_OTAU_IMAGE_PAGE_REQUEST_PAGE_SIZE 256 + #endif +#else + #undef CS_ZCL_OTAU_IMAGE_PAGE_REQUEST_PAGE_SIZE + #define CS_ZCL_OTAU_IMAGE_PAGE_REQUEST_PAGE_SIZE 1 +#endif //CS_ZCL_OTAU_IMAGE_PAGE_REQUEST_USAGE == 1 +/** \brief OTAU buffer for missed block responses during page request +*/ +#if CS_ZCL_OTAU_IMAGE_PAGE_REQUEST_USAGE == 1 + #ifndef CS_ZCL_OTAU_MISSED_BLOCKS_BUFFER_SIZE + #define CS_ZCL_OTAU_MISSED_BLOCKS_BUFFER_SIZE 8 + #endif +#else + #undef CS_ZCL_OTAU_MISSED_BLOCKS_BUFFER_SIZE + #define CS_ZCL_OTAU_MISSED_BLOCKS_BUFFER_SIZE 1 +#endif //CS_ZCL_OTAU_IMAGE_PAGE_REQUEST_USAGE == 1 + +#endif //_OTAU_ +#endif //_ZCL_ + +#ifndef CS_BAN_TABLE_SIZE + #define CS_BAN_TABLE_SIZE 1 +#endif /* _MAC_BAN_NODE_ */ + +/** \brief The maximum route cost between two nodes for direct delivery + +A data frame is routed directly to the neighbor only if the route cost, read +from the neighbor table, is less than the value of the parameter. If the route +cost is greater than the value of the parameter, route discovery will be +initiated to find an indirect route to the neighbor. + +Value range: 0 - 8 \n +0 - ignore information in the neighbor table (always start route discovery) \n +8 - always send data directly to a neighbor + +C-type: NwkLinkCost_t (typedef for uint8_t) \n +Can be set: at any time before network start \n +Persistent: No + */ +#ifndef CS_MAX_NEIGHBOR_ROUTE_COST + #define CS_MAX_NEIGHBOR_ROUTE_COST 8U +#endif + +/****************************************************************************** + Functions prototypes section +******************************************************************************/ + +/**************************************************************************//** +\brief Set Configuration Server memory to its default state +******************************************************************************/ +void csSetToDefault(void); + +#endif // _CSDEFAULTS_H +/* eof cdDefaults.h*/ -- cgit v1.2.3