/** Attempts to start the ZNP.
@param the type of device we're starting, e.g. ROUTER
@post znpResult contains the ZNP library error code, if any.
@return ZNP_SUCCESS if successful, else an error code indicating where it failed.
@see Communications Examples for more information about each of these steps.
*/
signed int startZnp(unsigned char deviceType)
{
printf("ZNP Startup ");
znpInit();
if (znpResult != ZNP_SUCCESS)
return -1;
setStartupOptions(STARTOPT_CLEAR_CONFIG + STARTOPT_CLEAR_STATE);
if (znpResult != ZNP_SUCCESS)
return -2;
znpReset();
if (znpResult != ZNP_SUCCESS)
return -3;
setZigbeeDeviceType(deviceType);
if (znpResult != ZNP_SUCCESS)
return -4;
setChannel(DEFAULT_CHANNEL);
if (znpResult != ZNP_SUCCESS)
return -5;
setCallbacks(CALLBACKS_ENABLED);
if (znpResult != ZNP_SUCCESS)
return -6;
afRegisterGenericApplication();
if (znpResult != ZNP_SUCCESS)
return -8;
zdoStartApplication();
if (znpResult != ZNP_SUCCESS)
return -9;
/* Wait until this device has joined a network.
Device State will change to DEV_ROUTER or DEV_COORD to indicate that the device has correctly joined a network. */
unsigned char deviceState = 0;
switch (deviceType)
{
case ROUTER: deviceState = DEV_ROUTER; break;
case END_DEVICE: deviceState = DEV_END_DEVICE; break;
case COORDINATOR: deviceState = DEV_ZB_COORD; break;
default: printf("ERROR - UNKNOWN DEVICE TYPE\r\n"); return -10;
}
znpResult = waitForDeviceState(deviceState);
if (znpResult != ZNP_SUCCESS)
return -10;
return ZNP_SUCCESS;
}
int main( void )
{
halInit();
printf("\r\n****************************************************\r\n");
printf("Packet Error Rate Tester - COORDINATOR - using AFZDO\r\n");
buttonIsr = &handleButtonPress;
HAL_ENABLE_INTERRUPTS();
setLed(0);
/* Initialize the ZNP */
printf("Initializing the ZNP\r\n");
znpInit();
handleReturnValue();
/* Set Startup Options (will restore the ZNP to default values on reset) */
printf("Setting StartupOptions\r\n");
setStartupOptions(STARTOPT_CLEAR_CONFIG + STARTOPT_CLEAR_STATE);
handleReturnValue();
/* Reset the ZNP */
printf("Reset the ZNP\r\n");
znpReset();
handleReturnValue();
/* Set Zigbee Device Type to be COORDINATOR */
printf("Setting Zigbee Device Type\r\n");
setZigbeeDeviceType(COORDINATOR);
handleReturnValue();
/* Reset the ZNP */
printf("Reset the ZNP\r\n");
znpReset();
handleReturnValue();
/* Configure the ZNP for our application */
printf("Registering Application\r\n");
afRegisterGenericApplication();
handleReturnValue();
/* Now, start the application. We will receive a START_REQUEST_SRSP, and then if it is successful, a START_CONFIRM. */
printf("Starting the Application\r\n");
zdoStartApplication();
handleReturnValue();
/** Wait until we get on the network.
We will receive a ZDO_STATE_CHANGE_IND message whenever the state changes. */
waitForDeviceState(DEV_ZB_COORD);
printf("On Network!\r\n");
setLed(1);
/* On network, display info about this network */
#ifdef DISPLAY_NETWORK_INFORMATION
getNetworkConfigurationParameters();
getDeviceInformation();
#endif
printf("Silently listening for packets; press button to display count\r\n");
printf("Count = %u; Start router sending packets\r\n", packetCounter);
/* Now the network is running - continually poll for any received messages from the ZNP */
waitForPackets();
}
/**
Start the Module and join a network, using the AF/ZDO interface. Reads RF Operating Region (US/EU) from GPIO.
@param moduleConfiguration the settings to use to start the module
@param applicationConfiguration the settings to use to start the Zigbee Application
@see struct moduleConfiguration in module_utilities.h for information about each field of the moduleConfiguration
@see struct applicationConfiguration in application_configuration.h for information about each field of the applicationConfiguration
@see module.c for more information about each of these steps.
*/
moduleResult_t startModule(const struct moduleConfiguration* mc, const struct applicationConfiguration* ac)
{
printf("Module Startup\r\n");
/* Initialize the Module */
RETURN_RESULT_IF_FAIL(moduleReset(), METHOD_START_MODULE);
/* Clear out any old network or state information (if requested) */
RETURN_RESULT_IF_FAIL(setStartupOptions(mc->startupOptions), METHOD_START_MODULE);
/* This section is for reading Operating region from GPIO pins - omit if using different method */
/* First, configure GPIOs as inputs: */
RETURN_RESULT_IF_FAIL(sysGpio(GPIO_SET_DIRECTION , GPIO_DIRECTION_ALL_INPUTS), METHOD_START_MODULE);
RETURN_RESULT_IF_FAIL(sysGpio(GPIO_SET_INPUT_MODE , GPIO_INPUT_MODE_ALL_PULL_UPS), METHOD_START_MODULE);
/* Now, read GPIO inputs 0 & 1: */
RETURN_RESULT_IF_FAIL(sysGpio(GPIO_READ, (GPIO_0 | GPIO_1)), METHOD_START_MODULE);
/* The operating region (US vs. EU etc.) is based on DIP Switch settings, read from GPIO 0 & 1 */
uint16_t moduleRegion = zmBuf[SYS_GPIO_READ_RESULT_FIELD];
/*** Done reading GPIO inputs. If application needs them as outputs then configure accordingly ***/
/* Reset the Module to apply the changes we just set */
RETURN_RESULT_IF_FAIL(moduleReset(), METHOD_START_MODULE);
/* Read the productId - this indicates the model of module used. */
uint8_t productId = zmBuf[SYS_RESET_IND_PRODUCTID_FIELD];
/* If this is not valid (bad firmware) then stop */
RETURN_RESULT_IF_EXPRESSION_TRUE((productId < MINIMUM_BUILD_ID), METHOD_START_MODULE,
ZM_INVALID_MODULE_CONFIGURATION);
/* Configure the module's RF output */
setModuleRfPower(productId, moduleRegion);
/* Set any end device options */
if (mc->deviceType == END_DEVICE)
RETURN_RESULT_IF_FAIL(setPollRate(mc->endDevicePollRate), METHOD_START_MODULE);
/* Configure which RF Channels to use. If none set then this will default to 11. */
RETURN_RESULT_IF_FAIL(setZigbeeDeviceType(mc->deviceType), METHOD_START_MODULE); // Set Zigbee Device Type
RETURN_RESULT_IF_FAIL(setChannelMask(mc->channelMask), METHOD_START_MODULE);
RETURN_RESULT_IF_FAIL(setPanId(mc->panId), METHOD_START_MODULE);
RETURN_RESULT_IF_FAIL(setCallbacks(CALLBACKS_ENABLED), METHOD_START_MODULE);
// Note: ZCD_NV_SECURITY_MODE defaults to 01
if (mc->securityMode != SECURITY_MODE_OFF) // Note: If a coordinator has ZCD_NV_SECURITY_MODE = 00, router must have ZCD_NV_SECURITY_MODE = 01 or else they won't communicate
{
RETURN_RESULT_IF_FAIL(setSecurityMode(mc->securityMode), METHOD_START_MODULE);
RETURN_RESULT_IF_FAIL(setSecurityKey(mc->securityKey), METHOD_START_MODULE);
}
if (ac == GENERIC_APPLICATION_CONFIGURATION) //TODO: use custom applicationFramework if this isn't null:
{
RETURN_RESULT_IF_FAIL(afRegisterGenericApplication(), METHOD_START_MODULE); // Configure the Module for our application
} else {
printf("Custom Application Frameworks not supported\r\n");
return INVALID_PARAMETER;
}
RETURN_RESULT_IF_FAIL(zdoStartApplication(), METHOD_START_MODULE); // Start your engines
/* Wait until this device has joined a network. Device State will change to DEV_ROUTER,
DEV_END_DEVICE, or DEV_COORD to indicate that the device has correctly joined a network. */
#ifdef ZDO_STATE_CHANGE_IND_HANDLED_BY_APPLICATION //if you're handling this in your application instead...
return MODULE_SUCCESS;
#else
#define TEN_SECONDS 10000
#define FIFTEEN_SECONDS 15000
#define START_TIMEOUT FIFTEEN_SECONDS
RETURN_RESULT(waitForDeviceState(getDeviceStateForDeviceType(mc->deviceType), START_TIMEOUT), METHOD_START_MODULE);
#endif
}
/**
Starts module using an operating region as a parameter. This does NOT read the GPIO pin to set the region.
@param mc the module configuration - what RF channel, which PAN ID, etc. These options are used in
this expressStartModule function as arguments to the various functions.
@param ac the Zigbee application configuration - which endpoint to use and other global settings.
If not using GENERIC_APPLICATION_CONFIGURATION then you must #define the compilation option
SUPPORT_CUSTOM_APPLICATION_CONFIGURATION. Normally this option is NOT defined to reduce code size.
@param moduleRegion - which region of the world to use to ensure FCC/ETSI compliance.
*/
moduleResult_t expressStartModule(const struct moduleConfiguration* mc, const struct applicationConfiguration* ac, const uint8_t moduleRegion)
{
printf("Express Startup ");
/* Initialize the Module */
RETURN_RESULT_IF_FAIL(moduleReset(), METHOD_EXPRESS_START_MODULE);
/* Clear out any old network or state information (if requested) */
printf("Startup Options 0x%02X\r\n", mc->startupOptions);
RETURN_RESULT_IF_FAIL(setStartupOptions(mc->startupOptions), METHOD_EXPRESS_START_MODULE);
/* Reset the Module to apply the changes we just set */
RETURN_RESULT_IF_FAIL(moduleReset(), METHOD_EXPRESS_START_MODULE);
/* Read the productId - this indicates the model of module used. */
uint8_t productId = zmBuf[SYS_RESET_IND_PRODUCTID_FIELD];
/* If this is not valid (bad firmware) then stop */
RETURN_RESULT_IF_EXPRESSION_TRUE((productId < MINIMUM_BUILD_ID), METHOD_EXPRESS_START_MODULE, ZM_INVALID_MODULE_CONFIGURATION);
/* Configure the module's RF output */
setModuleRfPower(productId, moduleRegion);
/* Set any end device options */
if (mc->deviceType == END_DEVICE)
{
RETURN_RESULT_IF_FAIL(setPollRate(mc->endDevicePollRate), METHOD_EXPRESS_START_MODULE);
}
/* Override for testing low power operation - referenced in Basic Comms ED example*/
#ifdef DISABLE_END_DEVICE_POLLING
RETURN_RESULT_IF_FAIL(setPollRate(0), METHOD_EXPRESS_START_MODULE);
#endif
/* Configure the Zigbee Device Type (Coordinator, Router, End Device */
RETURN_RESULT_IF_FAIL(setZigbeeDeviceType(mc->deviceType), METHOD_EXPRESS_START_MODULE);
/* Configure which RF Channels to use. If none set then this will default to a default set. */
RETURN_RESULT_IF_FAIL(setChannelMask(mc->channelMask), METHOD_EXPRESS_START_MODULE);
/* Set the PAN ID, if you want to restrict the module to only a particular PAN ID. */
RETURN_RESULT_IF_FAIL(setPanId(mc->panId), METHOD_EXPRESS_START_MODULE);
RETURN_RESULT_IF_FAIL(setCallbacks(CALLBACKS_ENABLED), METHOD_EXPRESS_START_MODULE);
/* Set security mode and security key if required. Note: If a coordinator has
ZCD_NV_SECURITY_MODE = 00 then router must have ZCD_NV_SECURITY_MODE = 01 or else they won't communicate */
if (mc->securityMode != SECURITY_MODE_OFF)
{
RETURN_RESULT_IF_FAIL(setSecurityMode(mc->securityMode), METHOD_EXPRESS_START_MODULE);
RETURN_RESULT_IF_FAIL(setSecurityKey(mc->securityKey), METHOD_EXPRESS_START_MODULE);
}
#ifdef SUPPORT_CUSTOM_APPLICATION_CONFIGURATION
if (ac == GENERIC_APPLICATION_CONFIGURATION)
{
RETURN_RESULT_IF_FAIL(afRegisterGenericApplication(), METHOD_EXPRESS_START_MODULE); // Configure the Module for our application
} else {
RETURN_RESULT_IF_FAIL(afRegisterApplication(ac), METHOD_EXPRESS_START_MODULE);
}
#else
if (ac == GENERIC_APPLICATION_CONFIGURATION)
{
RETURN_RESULT_IF_FAIL(afRegisterGenericApplication(), METHOD_EXPRESS_START_MODULE); // Configure the Module for our application
} else {
/* Note: to use a custom application configuration, you must #define SUPPORT_CUSTOM_APPLICATION_CONFIGURATION. */
return INVALID_PARAMETER;
}
#endif
/* Note: you can register more than one Zigbee endpoint; just call afRegisterApplication() here
for the next endpoint */
/* Start the module with the registered application configuration */
RETURN_RESULT_IF_FAIL(zdoStartApplication(), METHOD_EXPRESS_START_MODULE);
/* Wait until this device has joined a network. Device State will change to DEV_ROUTER,
DEV_END_DEVICE, or DEV_COORD to indicate that the device has correctly joined a network. */
#ifdef ZDO_STATE_CHANGE_IND_HANDLED_BY_APPLICATION //if you're handling this in your application instead...
return MODULE_SUCCESS;
#else
#define TEN_SECONDS 10000
#define FIFTEEN_SECONDS 15000
RETURN_RESULT(waitForDeviceState(getDeviceStateForDeviceType(mc->deviceType), FIFTEEN_SECONDS), METHOD_EXPRESS_START_MODULE);
#endif
}
int main( void )
{
halInit();
printf("\r\n****************************************************\r\n");
printf("Basic Communications Example - COORDINATOR - using AFZDO\r\n");
HAL_ENABLE_INTERRUPTS();
setLed(0);
/* Initialize the ZNP */
printf("Initializing the ZNP ");
znpInit();
handleReturnValue();
/* Set Startup Options (will restore the ZNP to default values on reset) */
printf("Setting StartupOptions ");
setStartupOptions(STARTOPT_CLEAR_CONFIG + STARTOPT_CLEAR_STATE);
handleReturnValue();
/* Reset the ZNP */
printf("Reset the ZNP ");
znpReset();
handleReturnValue();
/* Set Zigbee Device Type to be COORDINATOR */
printf("Setting Zigbee Device Type ");
setZigbeeDeviceType(COORDINATOR);
handleReturnValue();
/* Enabling Callbacks (required to receive ZDO_IEEE_ADDR_RSP) */
//#ifdef FIND_MAC_ADDRESS_OF_SENDER //define this to print out sender's MAC address
printf("Enabling Callbacks ");
setCallbacks(CALLBACKS_ENABLED);
handleReturnValue();
//#endif
/* Configure the ZNP for our application */
printf("Registering Application ");
afRegisterGenericApplication();
handleReturnValue();
/* Now, start the application. We will receive a START_REQUEST_SRSP, and then if it is successful, a START_CONFIRM. */
printf("Starting the Application ");
zdoStartApplication();
handleReturnValue();
/** Wait until we get on the network.
We will receive a ZDO_STATE_CHANGE_IND message whenever the state changes. */
waitForDeviceState(DEV_ZB_COORD);
printf("On Network!\r\n");
setLed(1);
/* On network, display info about this network */
#ifdef DISPLAY_NETWORK_INFORMATION
getNetworkConfigurationParameters();
getDeviceInformation();
#endif
/* Now the network is running - continually poll for any received messages from the ZNP */
#ifdef FIND_MAC_ADDRESS_OF_SENDER //define this to print out sender's MAC address
displayReceivedMessagesAndFindDevice();
#else
displayReceivedMessages();
#endif
}
int main( void )
{
halInit();
printf("\r\n++++++++++++++++++++++++++++++++++++++++++++++++++++\r\n");
printf("\r\nBasic Communications Example - ROUTER - using Simple API\r\n");
HAL_ENABLE_INTERRUPTS();
//Simple check to ensure that both security options weren't #defined.
#if defined(USE_SECURITY_MODE_PRECONFIGURED_KEYS) && defined(USE_SECURITY_MODE_COORD_DIST_KEYS)
printf("ERROR - only select one security option!\r\n");
while (1);
#endif
/* Initialize the ZNP */
printf("Initializing the ZNP\r\n");
znpInit();
handleReturnValue();
/* Set Startup Options (will restore the ZNP to default values on reset) */
printf("Setting StartupOptions\r\n");
setStartupOptions(STARTOPT_CLEAR_CONFIG + STARTOPT_CLEAR_STATE);
handleReturnValue();
/* Reset the ZNP */
printf("Reset the ZNP\r\n");
znpReset();
handleReturnValue();
/* Set Zigbee Device Type to be ROUTER */
printf("Setting Zigbee Device Type\r\n");
setZigbeeDeviceType(ROUTER);
handleReturnValue();
/* Configure security mode, if it is being used */
#ifdef USE_SECURITY_MODE_PRECONFIGURED_KEYS
printf("SECURITY ON WITH PRECONFIGURED KEYS\r\n");
/* Turn security ON with pre-configured keys */
setSecurityMode(SECURITY_MODE_PRECONFIGURED_KEYS);
handleReturnValue();
/* All devices on the network must be loaded with the same key */
setSecurityKey(key);
handleReturnValue();
#endif
#ifdef USE_SECURITY_MODE_COORD_DIST_KEYS
printf("SECURITY ON WITH COORDINATOR DISTRIBUTING KEYS\r\n");
/* Turn security ON with the coordinator distributing keys. */
setSecurityMode(SECURITY_MODE_COORD_DIST_KEYS);
handleReturnValue();
/* This is the key that will be distributed to other devices when they attempt to join */
setSecurityKey(key);
handleReturnValue();
#endif
#if !defined(USE_SECURITY_MODE_PRECONFIGURED_KEYS) && !defined(USE_SECURITY_MODE_COORD_DIST_KEYS)
printf("SECURITY OFF\r\n");
#endif
/* Configure the ZNP for our application */
printf("Registering Application\r\n");
sapiRegisterGenericApplication();
handleReturnValue();
/* Now, start the application. We will receive a START_REQUEST_SRSP, and then if it is successful, a START_CONFIRM. */
printf("Starting the Application\r\n");
sapiStartApplication();
handleReturnValue();
printf("On Network!\r\n");
setLed(0);
/* On network, display info about this network */
#ifdef DISPLAY_NETWORK_INFORMATION
getNetworkConfigurationParameters();
getDeviceInformation();
#endif
/* Now the network is running - send a message to the coordinator every few seconds.*/
unsigned char counter = 0;
unsigned char testMessage[] = {0xF0,0xF1,0xF2,0xF3,0xF4};
#define TEST_CLUSTER 0x77
pollAndDisplay();
while (1)
{
printf("Sending Message %u\r\n", counter++);
sendData(0, TEST_CLUSTER, testMessage, 5);
handleReturnValue();
toggleLed(1);
delayMs(5000);
}
}
int main( void )
{
halInit(); //Sets up all hardware inc debug Tx/Rx (Used for WiFi <--> ZNP)
printf("\r\n++++++++++++++++++++++++++++++++++++++++++++++++++++\r\n");
printf("\r\nBasic Communications Example - COORDINATOR - using Simple API\r\n");
HAL_ENABLE_INTERRUPTS();
setLed(0);
//Simple check to ensure that both security options weren't #defined.
#if defined(USE_SECURITY_MODE_PRECONFIGURED_KEYS) && defined(USE_SECURITY_MODE_COORD_DIST_KEYS)
printf("ERROR\r\n");
while (1);
#endif
/* Initialize the ZNP */
printf("Initializing the ZNP\r\n");
znpInit();
handleReturnValue();
/* Set Startup Options (will restore the ZNP to default values on reset) */
printf("Setting StartupOptions\r\n");
setStartupOptions(STARTOPT_CLEAR_CONFIG + STARTOPT_CLEAR_STATE);
handleReturnValue();
/* Reset the ZNP */
printf("Reset the ZNP\r\n");
znpReset();
handleReturnValue();
/* Set Zigbee Device Type to be COORDINATOR */
printf("Setting Zigbee Device Type\r\n");
setZigbeeDeviceType(COORDINATOR);
handleReturnValue();
/* Enabling Callbacks (required to receive ZDO_IEEE_ADDR_RSP) */
printf("Enabling Callbacks\r\n");
setCallbacks(CALLBACKS_ENABLED);
handleReturnValue();
/* Configure security mode, if it is being used */
#ifdef USE_SECURITY_MODE_PRECONFIGURED_KEYS
printf("SECURITY ON WITH PRECONFIGURED KEYS\r\n");
/* Turn security ON with pre-configured keys */
setSecurityMode(SECURITY_MODE_PRECONFIGURED_KEYS);
handleReturnValue();
/* All devices on the network must be loaded with the same key */
setSecurityKey(key);
handleReturnValue();
#endif
#ifdef USE_SECURITY_MODE_COORD_DIST_KEYS
printf("SECURITY ON WITH COORDINATOR DISTRIBUTING KEYS\r\n");
/* Turn security ON with the coordinator distributing keys. */
setSecurityMode(SECURITY_MODE_COORD_DIST_KEYS);
handleReturnValue();
/* This is the key that will be distributed to other devices when they attempt to join */
setSecurityKey(key);
handleReturnValue();
#endif
#if !defined(USE_SECURITY_MODE_PRECONFIGURED_KEYS) && !defined(USE_SECURITY_MODE_COORD_DIST_KEYS)
printf("SECURITY OFF\r\n");
#endif
/* Configure the ZNP for our application: */
printf("Registering Application\r\n");
sapiRegisterGenericApplication();
handleReturnValue();
/* Now, start the application. We will receive a START_REQUEST_SRSP, and then if it is successful, a START_CONFIRM. */
printf("Starting the Application\r\n");
sapiStartApplication();
handleReturnValue();
printf("On Network!\r\n");
setLed(1);
/* On network, display info about this network */
#ifdef DISPLAY_NETWORK_INFORMATION
getNetworkConfigurationParameters();
getDeviceInformation();
#endif
/* Now the network is running - continually poll for any received messages from the ZNP */
//displayReceivedMessages();
while(1)
{
/*
int light = getLightSense();
if(light > 100)
{
sendData(0xC72, 0xF, 0x1, 1);
}
else
{
sendData(0xC72, 0xF, 0x2, 1);
}
*/
int cmd = readUART(); //Read UART
//Depending on command, send appropriate message to relevant end point
switch (cmd) {
case CLOSE1:
//sendData(dest, cluster, data, dataLength);
sendData(0xC72, 0xF, 0x1, 1);
break;
case OPEN1:
sendData(0xC72, 0xF, 0x2, 1);
break;
case FILM1:
sendData(0xC72, 0xF, 0x3, 1);
break;
case DAY1:
sendData(0xC72, 0xF, 0x4, 1);
break;
case NIGHT1:
sendData(0xC72, 0xF, 0x5, 1);
break;
case CLOSE2:
sendData(0xC72, 0xF, 0x6, 1);
break;
case OPEN2:
sendData(0xC72, 0xF, 0x7, 1);
break;
case FILM2:
sendData(0xC72, 0xF, 0x8, 1);
break;
case DAY2:
sendData(0xC72, 0xF, 0x9, 1);
break;
case NIGHT2:
sendData(0xC72, 0xF, 0xA, 1);
break;
default:
break;
}
}
}
int main( void )
{
halInit();
printf("\r\n****************************************************\r\n");
printf("Secure Communications Example - ROUTER - using AFZDO\r\n");
HAL_ENABLE_INTERRUPTS();
//Simple idiot check to ensure that we didn't accidentally define both security options.
#if defined(USE_SECURITY_MODE_PRECONFIGURED_KEYS) && defined(USE_SECURITY_MODE_COORD_DIST_KEYS)
printf("ERROR - only select one security option!\r\n");
while (1);
#endif
/* Initialize the ZNP */
printf("Initializing the ZNP\r\n");
znpInit();
handleReturnValue();
/* Set Startup Options (will restore the ZNP to default values on reset) */
printf("Setting StartupOptions\r\n");
setStartupOptions(STARTOPT_CLEAR_CONFIG + STARTOPT_CLEAR_STATE);
handleReturnValue();
/* Reset the ZNP */
printf("Reset the ZNP\r\n");
znpReset();
handleReturnValue();
/* Set Zigbee Device Type to be ROUTER */
printf("Setting Zigbee Device Type\r\n");
setZigbeeDeviceType(ROUTER);
handleReturnValue();
/* Configure security mode, if it is being used */
#ifdef USE_SECURITY_MODE_PRECONFIGURED_KEYS
printf("PRECONFIGURED KEYS\r\n");
/* Turn security ON with pre-configured keys */
setSecurityMode(SECURITY_MODE_PRECONFIGURED_KEYS);
handleReturnValue();
/* All devices on the network must be loaded with the same key */
setSecurityKey(key);
handleReturnValue();
#endif
#ifdef USE_SECURITY_MODE_COORD_DIST_KEYS
printf("COORDINATOR DISTRIBUTING KEYS\r\n");
/* Turn security ON with the coordinator distributing keys.
Since this is the router we don't need to load a key; it will be sent to us by the coordinator! */
setSecurityMode(SECURITY_MODE_COORD_DIST_KEYS);
handleReturnValue();
#endif
#if !defined(USE_SECURITY_MODE_PRECONFIGURED_KEYS) && !defined(USE_SECURITY_MODE_COORD_DIST_KEYS)
printf("WARNING - NO SECURITY OPTION SELECTED; SECURITY OFF\r\n");
#endif
/* Configure the ZNP for our application */
printf("Registering Application\r\n");
afRegisterGenericApplication();
handleReturnValue();
/* Now, start the application. We will receive a START_REQUEST_SRSP, and then if it is successful, a START_CONFIRM. */
printf("Starting the Application\r\n");
zdoStartApplication();
handleReturnValue();
/** Wait until we get on the network.
We will receive a ZDO_STATE_CHANGE_IND message whenever the state changes. */
waitForDeviceState(DEV_ROUTER);
printf("On Network!\r\n");
setLed(0);
/* On network, display info about this network */
#ifdef DISPLAY_NETWORK_INFORMATION
getNetworkConfigurationParameters();
getDeviceInformation();
#endif
/* Now the network is running - send a message to the coordinator every few seconds.*/
unsigned char counter = 0;
unsigned char testMessage[] = {0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9};
#define TEST_CLUSTER 0x77
while (1)
{
printf("Sending Message %u\r\n", counter++);
afSendData(DEFAULT_ENDPOINT,DEFAULT_ENDPOINT,0, TEST_CLUSTER, testMessage, 10);
handleReturnValue();
toggleLed(1);
delayMs(5000);
}
}
int main( void )
{
halInit();
printf("\r\n****************************************************\r\n");
printf("Secure Communications Example - COORDINATOR - using AFZDO\r\n");
HAL_ENABLE_INTERRUPTS();
setLed(0);
//Simple idiot check to ensure that we didn't accidentally define both security options.
#if defined(USE_SECURITY_MODE_PRECONFIGURED_KEYS) && defined(USE_SECURITY_MODE_COORD_DIST_KEYS)
printf("ERROR - only select one security option!\r\n");
while (1);
#endif
/* Initialize the ZNP */
printf("Initializing the ZNP\r\n");
znpInit();
handleReturnValue();
/* Set Startup Options (will restore the ZNP to default values on reset) */
printf("Setting StartupOptions\r\n");
setStartupOptions(STARTOPT_CLEAR_CONFIG + STARTOPT_CLEAR_STATE);
handleReturnValue();
/* Set Zigbee Device Type to be COORDINATOR */
printf("Setting Zigbee Device Type\r\n");
setZigbeeDeviceType(COORDINATOR);
handleReturnValue();
/* Enabling Callbacks (required to receive ZDO_IEEE_ADDR_RSP) */
printf("Enabling Callbacks\r\n");
setCallbacks(CALLBACKS_ENABLED);
handleReturnValue();
/* Reset the ZNP */
printf("Reset the ZNP\r\n");
znpReset();
handleReturnValue();
/* Configure security mode, if it is being used */
#ifdef USE_SECURITY_MODE_PRECONFIGURED_KEYS
printf("SECURITY ON WITH PRECONFIGURED KEYS\r\n");
/* Turn security ON with pre-configured keys */
setSecurityMode(SECURITY_MODE_PRECONFIGURED_KEYS);
handleReturnValue();
/* All devices on the network must be loaded with the same key */
setSecurityKey(key);
handleReturnValue();
#endif
#ifdef USE_SECURITY_MODE_COORD_DIST_KEYS
printf("SECURITY ON WITH COORDINATOR DISTRIBUTING KEYS\r\n");
/* Turn security ON with the coordinator distributing keys. */
setSecurityMode(SECURITY_MODE_COORD_DIST_KEYS);
handleReturnValue();
/* This is the key that will be distributed to other devices when they attempt to join */
setSecurityKey(key);
handleReturnValue();
#endif
/** Note: if no security option is selected then this will behave like a normal coordinator
and will accept join requests from any device. */
#if !defined(USE_SECURITY_MODE_PRECONFIGURED_KEYS) && !defined(USE_SECURITY_MODE_COORD_DIST_KEYS)
printf("WARNING - NO SECURITY OPTION SELECTED; SECURITY OFF\r\n");
#endif
/* Configure the ZNP for our application */
printf("Registering Application\r\n");
afRegisterGenericApplication();
handleReturnValue();
/* Now, start the application. We will receive a START_REQUEST_SRSP, and then if it is successful, a START_CONFIRM. */
printf("Starting the Application\r\n");
zdoStartApplication();
handleReturnValue();
/** Wait until we get on the network.
We will receive a ZDO_STATE_CHANGE_IND message whenever the state changes. */
waitForDeviceState(DEV_ZB_COORD);
printf("On Network!\r\n");
setLed(1);
/* On network, display info about this network */
#ifdef DISPLAY_NETWORK_INFORMATION
getNetworkConfigurationParameters();
getDeviceInformation();
#endif
/* Now the network is running - continually poll for any received messages from the ZNP */
if (SRDY_IS_HIGH())
pollAndDisplay();
displayReceivedMessages();
}
