671 lines
19 KiB
C
671 lines
19 KiB
C
/**************************************************************************************************
|
|
Filename: ZGlobals.c
|
|
Revised: $Date: 2012-04-02 17:02:19 -0700 (Mon, 02 Apr 2012) $
|
|
Revision: $Revision: 29996 $
|
|
|
|
Description: User definable Z-Stack parameters.
|
|
|
|
|
|
Copyright 2007-2011 Texas Instruments Incorporated. All rights reserved.
|
|
|
|
IMPORTANT: Your use of this Software is limited to those specific rights
|
|
granted under the terms of a software license agreement between the user
|
|
who downloaded the software, his/her employer (which must be your employer)
|
|
and Texas Instruments Incorporated (the "License"). You may not use this
|
|
Software unless you agree to abide by the terms of the License. The License
|
|
limits your use, and you acknowledge, that the Software may not be modified,
|
|
copied or distributed unless embedded on a Texas Instruments microcontroller
|
|
or used solely and exclusively in conjunction with a Texas Instruments radio
|
|
frequency transceiver, which is integrated into your product. Other than for
|
|
the foregoing purpose, you may not use, reproduce, copy, prepare derivative
|
|
works of, modify, distribute, perform, display or sell this Software and/or
|
|
its documentation for any purpose.
|
|
|
|
YOU FURTHER ACKNOWLEDGE AND AGREE THAT THE SOFTWARE AND DOCUMENTATION ARE
|
|
PROVIDED “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED,
|
|
INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, TITLE,
|
|
NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL
|
|
TEXAS INSTRUMENTS OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER CONTRACT,
|
|
NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR OTHER
|
|
LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
|
|
INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE
|
|
OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT
|
|
OF SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
|
|
(INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
|
|
|
|
Should you have any questions regarding your right to use this Software,
|
|
contact Texas Instruments Incorporated at www.TI.com.
|
|
**************************************************************************************************/
|
|
|
|
/*********************************************************************
|
|
* INCLUDES
|
|
*/
|
|
|
|
#include "ZComDef.h"
|
|
#include "OSAL_Nv.h"
|
|
#include "ZDObject.h"
|
|
#include "ZGlobals.h"
|
|
#include "ZDNwkMgr.h"
|
|
#include "OnBoard.h"
|
|
#include "ZDSecMgr.h"
|
|
|
|
/*********************************************************************
|
|
* MACROS
|
|
*/
|
|
|
|
/*********************************************************************
|
|
* CONSTANTS
|
|
*/
|
|
|
|
/*********************************************************************
|
|
* TYPEDEFS
|
|
*/
|
|
|
|
typedef struct zgItem
|
|
{
|
|
uint16 id;
|
|
uint16 len;
|
|
void *buf;
|
|
} zgItem_t;
|
|
|
|
/*********************************************************************
|
|
* NWK GLOBAL VARIABLES
|
|
*/
|
|
|
|
// Polling values
|
|
uint16 zgPollRate = POLL_RATE;
|
|
uint16 zgQueuedPollRate = QUEUED_POLL_RATE;
|
|
uint16 zgResponsePollRate = RESPONSE_POLL_RATE;
|
|
uint16 zgRejoinPollRate = REJOIN_POLL_RATE;
|
|
|
|
// Transmission retries numbers
|
|
uint8 zgMaxDataRetries = NWK_MAX_DATA_RETRIES;
|
|
uint8 zgMaxPollFailureRetries = MAX_POLL_FAILURE_RETRIES;
|
|
|
|
// Default channel list
|
|
uint32 zgDefaultChannelList = DEFAULT_CHANLIST;
|
|
|
|
// Default starting scan duration
|
|
uint8 zgDefaultStartingScanDuration = STARTING_SCAN_DURATION;
|
|
|
|
// Stack profile Id
|
|
uint8 zgStackProfile = STACK_PROFILE_ID;
|
|
|
|
// Default indirect message holding timeout
|
|
uint8 zgIndirectMsgTimeout = NWK_INDIRECT_MSG_TIMEOUT;
|
|
|
|
// Security mode
|
|
uint8 zgSecurityMode = ZG_SECURITY_MODE;
|
|
|
|
// Secure permit join
|
|
uint8 zgSecurePermitJoin = true;
|
|
|
|
// Trust center address
|
|
uint16 zgTrustCenterAddr = ZG_TRUSTCENTER_ADDR;
|
|
|
|
// Route Discovery Time - amount of time that a route request lasts
|
|
uint8 zgRouteDiscoveryTime = ROUTE_DISCOVERY_TIME;
|
|
|
|
// Route expiry
|
|
uint8 zgRouteExpiryTime = ROUTE_EXPIRY_TIME;
|
|
|
|
// Extended PAN Id
|
|
uint8 zgExtendedPANID[Z_EXTADDR_LEN];
|
|
|
|
// Broadcast parameters
|
|
uint8 zgMaxBcastRetires = MAX_BCAST_RETRIES;
|
|
uint8 zgPassiveAckTimeout = PASSIVE_ACK_TIMEOUT;
|
|
uint8 zgBcastDeliveryTime = BCAST_DELIVERY_TIME;
|
|
|
|
// Network mode
|
|
uint8 zgNwkMode = NWK_MODE;
|
|
|
|
// Many-to-one values
|
|
uint8 zgConcentratorEnable = CONCENTRATOR_ENABLE;
|
|
uint8 zgConcentratorDiscoveryTime = CONCENTRATOR_DISCOVERY_TIME;
|
|
uint8 zgConcentratorRadius = CONCENTRATOR_RADIUS;
|
|
uint8 zgConcentratorRC = CONCENTRATOR_ROUTE_CACHE; // concentrator with route cache (no memory constraints)
|
|
uint8 zgNwkSrcRtgExpiryTime = SRC_RTG_EXPIRY_TIME;
|
|
|
|
// Cleanup Child Table according to routing traffic
|
|
uint8 zgRouterOffAssocCleanup = FALSE;
|
|
|
|
/*********************************************************************
|
|
* APS GLOBAL VARIABLES
|
|
*/
|
|
|
|
// The maximum number of retries allowed after a transmission failure
|
|
uint8 zgApscMaxFrameRetries = APSC_MAX_FRAME_RETRIES;
|
|
|
|
// The maximum number of seconds (milliseconds) to wait for an
|
|
// acknowledgement to a transmitted frame.
|
|
|
|
// This number is used by polled devices.
|
|
uint16 zgApscAckWaitDurationPolled = APSC_ACK_WAIT_DURATION_POLLED;
|
|
|
|
// This number is used by non-polled devices in the following formula:
|
|
// (100 mSec) * (_NIB.MaxDepth * zgApsAckWaitMultiplier)
|
|
uint8 zgApsAckWaitMultiplier = 2;
|
|
|
|
// The maximum number of milliseconds for the end device binding
|
|
uint16 zgApsDefaultMaxBindingTime = APS_DEFAULT_MAXBINDING_TIME;
|
|
|
|
// The 64-big identifier of the network to join or form.
|
|
// Default set to all zeros
|
|
uint8 zgApsUseExtendedPANID[Z_EXTADDR_LEN] = {00,00,00,00,00,00,00,00};
|
|
|
|
// A boolean flag that indicates whether it is OK to use insecure join
|
|
// on startup. Default set to true
|
|
uint8 zgApsUseInsecureJoin = TRUE;
|
|
|
|
// The radius of broadcast multicast transmissions
|
|
uint8 zgApsNonMemberRadius = APS_DEFAULT_NONMEMBER_RADIUS;
|
|
|
|
/*********************************************************************
|
|
* SECURITY GLOBAL VARIABLES
|
|
*/
|
|
|
|
// If true, preConfigKey should be configured on all devices on the network
|
|
// If false, it is configured only on the coordinator and sent to other
|
|
// devices upon joining.
|
|
uint8 zgPreConfigKeys = FALSE;// TRUE;
|
|
|
|
// If true, defaultTCLinkKey should be configured on all devices on the
|
|
// network. If false, individual trust center link key between each device and
|
|
// the trust center should be manually configured via MT_WRITE_NV
|
|
uint8 zgUseDefaultTCLK = TRUE; // FALSE
|
|
|
|
/*********************************************************************
|
|
* ZDO GLOBAL VARIABLES
|
|
*/
|
|
|
|
// Configured PAN ID
|
|
uint16 zgConfigPANID = ZDAPP_CONFIG_PAN_ID;
|
|
|
|
// Device Logical Type
|
|
uint8 zgDeviceLogicalType = DEVICE_LOGICAL_TYPE;
|
|
|
|
// Startup Delay
|
|
uint8 zgStartDelay = START_DELAY;
|
|
|
|
#if !defined MT_TASK
|
|
// Flag to use verbose (i.e. "cc2480-style") direct MT callbacks in ZDProfile.c, ZDP_IncomingData().
|
|
uint8 zgZdoDirectCB = FALSE;
|
|
#endif
|
|
|
|
// Min number of attempted transmissions for Channel Interference detection
|
|
uint8 zgNwkMgrMinTransmissions = ZDNWKMGR_MIN_TRANSMISSIONS;
|
|
|
|
/*********************************************************************
|
|
* APPLICATION GLOBAL VARIABLES
|
|
*/
|
|
|
|
// Network Manager Mode
|
|
uint8 zgNwkMgrMode = ZDNWKMGR_ENABLE;
|
|
|
|
/*********************************************************************
|
|
* NON-STANDARD GLOBAL VARIABLES
|
|
*/
|
|
|
|
// Simple API Endpoint
|
|
uint8 zgSapiEndpoint = SAPI_ENDPOINT;
|
|
|
|
/*********************************************************************
|
|
* LOCAL VARIABLES
|
|
*/
|
|
|
|
/*********************************************************************
|
|
* ZGlobal Item Table
|
|
*/
|
|
static CONST zgItem_t zgItemTable[] =
|
|
{
|
|
#if defined ( NV_INIT )
|
|
#if !defined MT_TASK
|
|
{
|
|
ZCD_NV_ZDO_DIRECT_CB, sizeof(zgZdoDirectCB), &zgZdoDirectCB
|
|
},
|
|
#endif
|
|
{
|
|
ZCD_NV_LOGICAL_TYPE, sizeof(zgDeviceLogicalType), &zgDeviceLogicalType
|
|
},
|
|
{
|
|
ZCD_NV_POLL_RATE, sizeof(zgPollRate), &zgPollRate
|
|
},
|
|
{
|
|
ZCD_NV_QUEUED_POLL_RATE, sizeof(zgQueuedPollRate), &zgQueuedPollRate
|
|
},
|
|
{
|
|
ZCD_NV_RESPONSE_POLL_RATE, sizeof(zgResponsePollRate), &zgResponsePollRate
|
|
},
|
|
{
|
|
ZCD_NV_REJOIN_POLL_RATE, sizeof(zgRejoinPollRate), &zgRejoinPollRate
|
|
},
|
|
{
|
|
ZCD_NV_DATA_RETRIES, sizeof(zgMaxDataRetries), &zgMaxDataRetries
|
|
},
|
|
{
|
|
ZCD_NV_POLL_FAILURE_RETRIES, sizeof(zgMaxPollFailureRetries), &zgMaxPollFailureRetries
|
|
},
|
|
{
|
|
ZCD_NV_CHANLIST, sizeof(zgDefaultChannelList), &zgDefaultChannelList
|
|
},
|
|
{
|
|
ZCD_NV_SCAN_DURATION, sizeof(zgDefaultStartingScanDuration), &zgDefaultStartingScanDuration
|
|
},
|
|
{
|
|
ZCD_NV_STACK_PROFILE, sizeof(zgStackProfile), &zgStackProfile
|
|
},
|
|
{
|
|
ZCD_NV_INDIRECT_MSG_TIMEOUT, sizeof(zgIndirectMsgTimeout), &zgIndirectMsgTimeout
|
|
},
|
|
{
|
|
ZCD_NV_ROUTE_EXPIRY_TIME, sizeof(zgRouteExpiryTime), &zgRouteExpiryTime
|
|
},
|
|
{
|
|
ZCD_NV_EXTENDED_PAN_ID, Z_EXTADDR_LEN, zgExtendedPANID
|
|
},
|
|
{
|
|
ZCD_NV_BCAST_RETRIES, sizeof(zgMaxBcastRetires), &zgMaxBcastRetires
|
|
},
|
|
{
|
|
ZCD_NV_PASSIVE_ACK_TIMEOUT, sizeof(zgPassiveAckTimeout), &zgPassiveAckTimeout
|
|
},
|
|
{
|
|
ZCD_NV_BCAST_DELIVERY_TIME, sizeof(zgBcastDeliveryTime), &zgBcastDeliveryTime
|
|
},
|
|
{
|
|
ZCD_NV_NWK_MODE, sizeof(zgNwkMode), &zgNwkMode
|
|
},
|
|
{
|
|
ZCD_NV_CONCENTRATOR_ENABLE, sizeof(zgConcentratorEnable), &zgConcentratorEnable
|
|
},
|
|
{
|
|
ZCD_NV_CONCENTRATOR_DISCOVERY, sizeof(zgConcentratorDiscoveryTime), &zgConcentratorDiscoveryTime
|
|
},
|
|
{
|
|
ZCD_NV_CONCENTRATOR_RADIUS, sizeof(zgConcentratorRadius), &zgConcentratorRadius
|
|
},
|
|
{
|
|
ZCD_NV_CONCENTRATOR_RC, sizeof(zgConcentratorRC), &zgConcentratorRC
|
|
},
|
|
{
|
|
ZCD_NV_SRC_RTG_EXPIRY_TIME, sizeof(zgNwkSrcRtgExpiryTime), &zgNwkSrcRtgExpiryTime
|
|
},
|
|
{
|
|
ZCD_NV_ROUTE_DISCOVERY_TIME, sizeof(zgRouteDiscoveryTime), &zgRouteDiscoveryTime
|
|
},
|
|
#ifndef NONWK
|
|
{
|
|
ZCD_NV_PANID, sizeof(zgConfigPANID), &zgConfigPANID
|
|
},
|
|
{
|
|
ZCD_NV_PRECFGKEYS_ENABLE, sizeof(zgPreConfigKeys), &zgPreConfigKeys
|
|
},
|
|
{
|
|
ZCD_NV_SECURITY_MODE, sizeof(zgSecurityMode), &zgSecurityMode
|
|
},
|
|
{
|
|
ZCD_NV_SECURE_PERMIT_JOIN, sizeof(zgSecurePermitJoin), &zgSecurePermitJoin
|
|
},
|
|
{
|
|
ZCD_NV_USE_DEFAULT_TCLK, sizeof(zgUseDefaultTCLK), &zgUseDefaultTCLK
|
|
},
|
|
{
|
|
ZCD_NV_TRUSTCENTER_ADDR, sizeof(zgTrustCenterAddr), &zgTrustCenterAddr
|
|
},
|
|
#endif // NONWK
|
|
{
|
|
ZCD_NV_APS_FRAME_RETRIES, sizeof(zgApscMaxFrameRetries), &zgApscMaxFrameRetries
|
|
},
|
|
{
|
|
ZCD_NV_APS_ACK_WAIT_DURATION, sizeof(zgApscAckWaitDurationPolled), &zgApscAckWaitDurationPolled
|
|
},
|
|
{
|
|
ZCD_NV_APS_ACK_WAIT_MULTIPLIER, sizeof(zgApsAckWaitMultiplier), &zgApsAckWaitMultiplier
|
|
},
|
|
{
|
|
ZCD_NV_BINDING_TIME, sizeof(zgApsDefaultMaxBindingTime), &zgApsDefaultMaxBindingTime
|
|
},
|
|
{
|
|
ZCD_NV_APS_USE_EXT_PANID, Z_EXTADDR_LEN, zgApsUseExtendedPANID
|
|
},
|
|
{
|
|
ZCD_NV_APS_USE_INSECURE_JOIN, sizeof(zgApsUseInsecureJoin), &zgApsUseInsecureJoin
|
|
},
|
|
{
|
|
ZCD_NV_APS_NONMEMBER_RADIUS, sizeof(zgApsNonMemberRadius), &zgApsNonMemberRadius
|
|
},
|
|
{
|
|
ZCD_NV_START_DELAY, sizeof(zgStartDelay), &zgStartDelay
|
|
},
|
|
{
|
|
ZCD_NV_SAPI_ENDPOINT, sizeof(zgSapiEndpoint), &zgSapiEndpoint
|
|
},
|
|
{
|
|
ZCD_NV_NWK_MGR_MODE, sizeof(zgNwkMgrMode), &zgNwkMgrMode
|
|
},
|
|
{
|
|
ZCD_NV_NWKMGR_MIN_TX, sizeof(zgNwkMgrMinTransmissions), &zgNwkMgrMinTransmissions
|
|
},
|
|
{
|
|
ZCD_NV_ROUTER_OFF_ASSOC_CLEANUP, sizeof(zgRouterOffAssocCleanup), &zgRouterOffAssocCleanup
|
|
},
|
|
#endif // NV_INIT
|
|
// Last item -- DO NOT MOVE IT!
|
|
{
|
|
0x00, 0, NULL
|
|
}
|
|
};
|
|
|
|
/*********************************************************************
|
|
* LOCAL FUNCTIONS
|
|
*/
|
|
|
|
static uint8 zgItemInit( uint16 id, uint16 len, void *buf, uint8 setDefault );
|
|
|
|
#ifndef NONWK
|
|
static uint8 zgPreconfigKeyInit( uint8 setDefault );
|
|
#endif
|
|
|
|
/*********************************************************************
|
|
* @fn zgItemInit()
|
|
*
|
|
* @brief
|
|
*
|
|
* Initialize a global item. If the item doesn't exist in NV memory,
|
|
* write the system default (value passed in) into NV memory. But if
|
|
* it exists, set the item to the value stored in NV memory.
|
|
*
|
|
* Also, if setDefault is TRUE and the item exists, we will write
|
|
* the default value to NV space.
|
|
*
|
|
* @param id - item id
|
|
* @param len - item len
|
|
* @param buf - pointer to the item
|
|
* @param setDefault - TRUE to set default, not read
|
|
*
|
|
* @return ZSUCCESS if successful, NV_ITEM_UNINIT if item did not
|
|
* exist in NV, NV_OPER_FAILED if failure.
|
|
*/
|
|
static uint8 zgItemInit( uint16 id, uint16 len, void *buf, uint8 setDefault )
|
|
{
|
|
uint8 status;
|
|
|
|
// If the item doesn't exist in NV memory, create and initialize
|
|
// it with the value passed in.
|
|
status = osal_nv_item_init( id, len, buf );
|
|
if ( status == ZSUCCESS )
|
|
{
|
|
if ( setDefault )
|
|
{
|
|
// Write the default value back to NV
|
|
status = osal_nv_write( id, 0, len, buf );
|
|
}
|
|
else
|
|
{
|
|
// The item exists in NV memory, read it from NV memory
|
|
status = osal_nv_read( id, 0, len, buf );
|
|
}
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* API FUNCTIONS
|
|
*/
|
|
|
|
/*********************************************************************
|
|
* @fn zgInit
|
|
*
|
|
* @brief
|
|
*
|
|
* Initialize the Z-Stack Globals. If an item doesn't exist in
|
|
* NV memory, write the system default into NV memory. But if
|
|
* it exists, set the item to the value stored in NV memory.
|
|
*
|
|
* NOTE: The Startup Options (ZCD_NV_STARTUP_OPTION) indicate
|
|
* that the Config state items (zgItemTable) need to be
|
|
* set to defaults (ZCD_STARTOPT_DEFAULT_CONFIG_STATE). The
|
|
*
|
|
* @param none
|
|
*
|
|
* @return ZSUCCESS if successful, NV_ITEM_UNINIT if item did not
|
|
* exist in NV, NV_OPER_FAILED if failure.
|
|
*/
|
|
uint8 zgInit( void )
|
|
{
|
|
uint8 setDefault = FALSE;
|
|
|
|
// Do we want to default the Config state values
|
|
if ( zgReadStartupOptions() & ZCD_STARTOPT_DEFAULT_CONFIG_STATE )
|
|
{
|
|
setDefault = TRUE;
|
|
}
|
|
|
|
#if 0
|
|
// Enable this section if you need to track the number of resets
|
|
// This section is normally disabled to minimize "wear" on NV memory
|
|
uint16 bootCnt = 0;
|
|
|
|
// Update the Boot Counter
|
|
if ( osal_nv_item_init( ZCD_NV_BOOTCOUNTER, sizeof(bootCnt), &bootCnt ) == ZSUCCESS )
|
|
{
|
|
// Get the old value from NV memory
|
|
osal_nv_read( ZCD_NV_BOOTCOUNTER, 0, sizeof(bootCnt), &bootCnt );
|
|
}
|
|
|
|
// Increment the Boot Counter and store it into NV memory
|
|
if ( setDefault )
|
|
bootCnt = 0;
|
|
else
|
|
bootCnt++;
|
|
osal_nv_write( ZCD_NV_BOOTCOUNTER, 0, sizeof(bootCnt), &bootCnt );
|
|
#endif
|
|
|
|
// Initialize the Extended PAN ID as my own extended address
|
|
ZMacGetReq( ZMacExtAddr, zgExtendedPANID );
|
|
|
|
// Initialize the items table
|
|
zgInitItems( setDefault );
|
|
|
|
#ifndef NONWK
|
|
if ( ZG_SECURE_ENABLED )
|
|
{
|
|
// Initialize the Pre-Configured Key to the default key
|
|
zgPreconfigKeyInit( setDefault );
|
|
|
|
// Initialize NV items for all Keys: NWK, APS, TCLK and Master
|
|
ZDSecMgrInitNVKeyTables( setDefault );
|
|
}
|
|
#endif // NONWK
|
|
|
|
// Clear the Config State default
|
|
if ( setDefault )
|
|
{
|
|
zgWriteStartupOptions( ZG_STARTUP_CLEAR, ZCD_STARTOPT_DEFAULT_CONFIG_STATE );
|
|
}
|
|
|
|
return ( ZSUCCESS );
|
|
}
|
|
|
|
/*********************************************************************
|
|
* @fn zgInitItems
|
|
*
|
|
* @brief Initializes RAM variables from NV. If NV items don't
|
|
* exist, then the NV is initialize with what is in RAM
|
|
* variables.
|
|
*
|
|
* @param none
|
|
*
|
|
* @return none
|
|
*/
|
|
void zgInitItems( uint8 setDefault )
|
|
{
|
|
uint8 i = 0;
|
|
|
|
while ( zgItemTable[i].id != 0x00 )
|
|
{
|
|
// Initialize the item
|
|
zgItemInit( zgItemTable[i].id, zgItemTable[i].len, zgItemTable[i].buf, setDefault );
|
|
|
|
// Move on to the next item
|
|
i++;
|
|
}
|
|
}
|
|
|
|
/*********************************************************************
|
|
* @fn zgReadStartupOptions
|
|
*
|
|
* @brief Reads the ZCD_NV_STARTUP_OPTION NV Item.
|
|
*
|
|
* @param none
|
|
*
|
|
* @return the ZCD_NV_STARTUP_OPTION NV item
|
|
*/
|
|
uint8 zgReadStartupOptions( void )
|
|
{
|
|
// Default to Use Config State and Use Network State
|
|
uint8 startupOption = 0;
|
|
|
|
// This should have been done in ZMain.c, but just in case.
|
|
if ( osal_nv_item_init( ZCD_NV_STARTUP_OPTION,
|
|
sizeof(startupOption),
|
|
&startupOption ) == ZSUCCESS )
|
|
{
|
|
// Read saved startup control
|
|
osal_nv_read( ZCD_NV_STARTUP_OPTION,
|
|
0,
|
|
sizeof( startupOption ),
|
|
&startupOption);
|
|
}
|
|
return ( startupOption );
|
|
}
|
|
|
|
/*********************************************************************
|
|
* @fn zgWriteStartupOptions
|
|
*
|
|
* @brief Writes bits into the ZCD_NV_STARTUP_OPTION NV Item.
|
|
*
|
|
* @param action - ZG_STARTUP_SET set bit, ZG_STARTUP_CLEAR to
|
|
* clear bit. The set bit is an OR operation, and the
|
|
* clear bit is an AND ~(bitOptions) operation.
|
|
*
|
|
* @param bitOptions - which bits to perform action on:
|
|
* ZCD_STARTOPT_DEFAULT_CONFIG_STATE
|
|
* ZCD_STARTOPT_DEFAULT_NETWORK_STATE
|
|
*
|
|
* @return ZSUCCESS if successful
|
|
*/
|
|
uint8 zgWriteStartupOptions( uint8 action, uint8 bitOptions )
|
|
{
|
|
uint8 status;
|
|
uint8 startupOptions = 0;
|
|
|
|
status = osal_nv_read( ZCD_NV_STARTUP_OPTION,
|
|
0,
|
|
sizeof( startupOptions ),
|
|
&startupOptions );
|
|
|
|
if ( status == ZSUCCESS )
|
|
{
|
|
if ( action == ZG_STARTUP_SET )
|
|
{
|
|
// Set bits
|
|
startupOptions |= bitOptions;
|
|
}
|
|
else
|
|
{
|
|
// Clear bits
|
|
startupOptions &= (bitOptions ^ 0xFF);
|
|
}
|
|
|
|
// Changed?
|
|
status = osal_nv_write( ZCD_NV_STARTUP_OPTION,
|
|
0,
|
|
sizeof( startupOptions ),
|
|
&startupOptions );
|
|
}
|
|
|
|
return ( status );
|
|
}
|
|
|
|
/*********************************************************************
|
|
* @fn zgSetItem
|
|
*
|
|
* @brief Set RAM variables from set-NV, if it exist in the zgItemTable
|
|
*
|
|
* @param id - NV ID
|
|
* len - NV item length
|
|
* buf - pointer to the input buffer
|
|
*
|
|
* @return none
|
|
*/
|
|
void zgSetItem( uint16 id, uint16 len, void *buf )
|
|
{
|
|
|
|
uint8 i = 0;
|
|
|
|
// Look up the NV item table
|
|
while ( zgItemTable[i].id != 0x00 )
|
|
{
|
|
if( zgItemTable[i].id == id )
|
|
{
|
|
if ( zgItemTable[i].len == len )
|
|
{
|
|
osal_memcpy( zgItemTable[i].buf, buf, len );
|
|
}
|
|
break;
|
|
}
|
|
// Move on to the next item
|
|
i++;
|
|
}
|
|
}
|
|
|
|
#ifndef NONWK
|
|
/*********************************************************************
|
|
* @fn zgPreconfigKeyInit()
|
|
*
|
|
* @brief
|
|
*
|
|
* Initialize ZCD_NV_PRECFGKEY NV item. If the item doesn't exist in NV memory,
|
|
* write the system default (value passed in) into NV memory. But if
|
|
* it exists do not overwrite it.
|
|
*
|
|
* Also, if setDefault is TRUE and the item exists, we will write
|
|
* the default value to NV space.
|
|
*
|
|
* @param setDefault - TRUE to set default
|
|
*
|
|
* @return ZSUCCESS if successful, NV_ITEM_UNINIT if item did not
|
|
* exist in NV, NV_OPER_FAILED if failure.
|
|
*/
|
|
static uint8 zgPreconfigKeyInit( uint8 setDefault )
|
|
{
|
|
uint8 zgPreConfigKey[SEC_KEY_LEN];
|
|
uint8 status;
|
|
|
|
// Initialize the Pre-Configured Key to the default key
|
|
osal_memcpy( zgPreConfigKey, defaultKey, SEC_KEY_LEN );
|
|
|
|
// If the item doesn't exist in NV memory, create and initialize it
|
|
status = osal_nv_item_init( ZCD_NV_PRECFGKEY, SEC_KEY_LEN, zgPreConfigKey );
|
|
if ( status == ZSUCCESS )
|
|
{
|
|
if ( setDefault )
|
|
{
|
|
// Write the default value back to NV
|
|
status = osal_nv_write( ZCD_NV_PRECFGKEY, 0, SEC_KEY_LEN, zgPreConfigKey );
|
|
}
|
|
}
|
|
|
|
// clear local copy of default key
|
|
osal_memset(zgPreConfigKey, 0x00, SEC_KEY_LEN);
|
|
|
|
return (status);
|
|
}
|
|
#endif
|
|
|
|
/*********************************************************************
|
|
*********************************************************************/
|