static CommissioningState_t CheckNetwork(void) {
emberAfDebugPrintln("DEBUG: Check Network state");
EmberNetworkStatus nw_status = emberNetworkState();
emberAfDebugPrintln("DEBUG: network state 0x%X", nw_status);
if (nw_status == EMBER_JOINING_NETWORK ||
nw_status == EMBER_LEAVING_NETWORK) {
// Try to check again after 5 seconds
emberEventControlSetDelayQS(StateMachineEvent,
SIMPLE_COMMISSIONING_NETWORK_RETRY_DELAY);
return SC_EZ_START;
}
if (nw_status == EMBER_JOINED_NETWORK) {
SetNextEvent(SC_EZEV_BCAST_IDENT_QUERY);
// Send Permit Join broadcast to the current network
// in case of ZED nothing will happen
// TODO: Make this hadrcoded value as plugin's option
emberAfPermitJoin(SIMPLE_COMMISSIONING_PERMIT_JOIN_TIME, TRUE);
} else if (nw_status == EMBER_NO_NETWORK &&
GetNetworkTries() < NETWORK_ACCESS_CONS_TRIES) {
// Form or join available network
SetNextEvent(SC_EZEV_FORM_JOIN_NETWORK);
} else {
SetNextEvent(SC_EZEV_NETWORK_FAILED);
}
// if the device is in the network continue commissioning
// by sending Identify Query
emberEventControlSetActive(StateMachineEvent);
return SC_EZ_START;
}
/** @brief Stack Status
*
* This function is called by the application framework from the stack status
* handler. This callbacks provides applications an opportunity to be
* notified of changes to the stack status and take appropriate action. The
* return code from this callback is ignored by the framework. The framework
* will always process the stack status after the callback returns.
*
* @param status Ver.: always
*/
boolean emberAfStackStatusCallback(EmberStatus status)
{
if (status == EMBER_NETWORK_UP) {
emberEventControlSetInactive(networkEventControl);
halPlayTune_P(happyTune, TRUE);
} else if (status == EMBER_NETWORK_DOWN
&& emberNetworkState() == EMBER_NO_NETWORK) {
emberEventControlSetActive(networkEventControl);
}
return FALSE;
}
void buttonEventHandler(void)
{
emberEventControlSetInactive(buttonEventControl);
if (halButtonState(BUTTON0) == BUTTON_PRESSED) {
EmberNetworkStatus state = emberNetworkState();
if (state == EMBER_JOINED_NETWORK) {
emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND
| ZCL_FRAME_CONTROL_CLIENT_TO_SERVER),
ZCL_ON_OFF_CLUSTER_ID,
(on ? ZCL_OFF_COMMAND_ID : ZCL_ON_COMMAND_ID),
"");
emberAfGetCommandApsFrame()->profileId = emberAfPrimaryProfileId();
emberAfGetCommandApsFrame()->sourceEndpoint = emberAfPrimaryEndpoint();
emberAfGetCommandApsFrame()->destinationEndpoint = EMBER_BROADCAST_ENDPOINT;
if (emberAfSendCommandUnicastToBindings() == EMBER_SUCCESS) {
on = !on;
} else {
halPlayTune_P(sadTune, TRUE);
}
} else if (state == EMBER_NO_NETWORK) {
halPlayTune_P((emberAfStartSearchForJoinableNetwork() == EMBER_SUCCESS
? waitTune
: sadTune),
TRUE);
} else {
if (REPAIR_LIMIT_MS
< elapsedTimeInt16u(buttonPressTime,
halCommonGetInt16uMillisecondTick())) {
halPlayTune_P(sadTune, TRUE);
} else {
if (state == EMBER_JOINED_NETWORK_NO_PARENT
&& !emberStackIsPerformingRejoin()) {
halPlayTune_P((emberFindAndRejoinNetwork(TRUE, 0) == EMBER_SUCCESS
? waitTune
: sadTune),
TRUE);
}
emberEventControlSetDelayMS(buttonEventControl, REPAIR_DELAY_MS);
}
}
} else if (halButtonState(BUTTON1) == BUTTON_PRESSED) {
emberAfEzmodeClientCommission(emberAfPrimaryEndpoint(),
EMBER_AF_EZMODE_COMMISSIONING_CLIENT_TO_SERVER,
clusterIds,
COUNTOF(clusterIds));
}
}
void buttonEventHandler(void)
{
emberEventControlSetInactive(buttonEventControl);
EmberNetworkStatus state = emberNetworkState();
if (state == EMBER_JOINED_NETWORK) {
emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND
| ZCL_FRAME_CONTROL_CLIENT_TO_SERVER),
ZCL_ON_OFF_CLUSTER_ID,
(on ? ZCL_OFF_COMMAND_ID : ZCL_ON_COMMAND_ID),
"");
emberAfGetCommandApsFrame()->profileId = emberAfProfileIdFromIndex(0);
emberAfGetCommandApsFrame()->sourceEndpoint = emberAfEndpointFromIndex(0);
emberAfGetCommandApsFrame()->destinationEndpoint = EMBER_BROADCAST_ENDPOINT;
if (emberAfSendCommandBroadcast(EMBER_SLEEPY_BROADCAST_ADDRESS)
== EMBER_SUCCESS) {
on = !on;
} else {
halPlayTune_P(sadTune, TRUE);
}
} else if (state == EMBER_NO_NETWORK) {
halPlayTune_P((emberAfZllInitiateTouchLink() == EMBER_SUCCESS
? waitTune
: sadTune),
TRUE);
} else {
int16u elapsed = elapsedTimeInt16u(buttonPressTime,
halCommonGetInt16uMillisecondTick());
if (REPAIR_LIMIT_MS
< elapsedTimeInt16u(buttonPressTime,
halCommonGetInt16uMillisecondTick())) {
halPlayTune_P(sadTune, TRUE);
} else {
if (state == EMBER_JOINED_NETWORK_NO_PARENT
&& !emberStackIsPerformingRejoin()) {
halPlayTune_P((emberFindAndRejoinNetwork(TRUE, 0) == EMBER_SUCCESS
? waitTune
: sadTune),
TRUE);
}
emberEventControlSetDelayMS(buttonEventControl, REPAIR_DELAY_MS);
}
}
}
void buttonEventHandler(void)
{
// On a press-and-hold button event, form a network if we don't have one or
// permit joining if we do. If we form, we'll automatically permit joining
// when we come up.
emberEventControlSetInactive(buttonEventControl);
if (halButtonState(BUTTON0) == BUTTON_PRESSED) {
if (emberNetworkState() == EMBER_NO_NETWORK) {
halPlayTune_P(((emberFormAndJoinIsScanning()
|| emberAfFindUnusedPanIdAndForm() == EMBER_SUCCESS)
? waitTune
: sadTune),
TRUE);
} else {
pjoin();
}
} else if (halButtonState(BUTTON1) == BUTTON_PRESSED) {
emberAfEzmodeServerCommission(emberAfPrimaryEndpoint());
}
}
void buttonEventHandler(void)
{
emberEventControlSetInactive(buttonEventControl);
if (halButtonState(BUTTON0) == BUTTON_PRESSED) {
EmberNetworkStatus state = emberNetworkState();
if (state == EMBER_JOINED_NETWORK) {
emberAfEzmodeClientCommission(emberAfPrimaryEndpoint(),
EMBER_AF_EZMODE_COMMISSIONING_SERVER_TO_CLIENT,
clusterIds,
COUNTOF(clusterIds));
} else if (state == EMBER_NO_NETWORK) {
halPlayTune_P(((emberFormAndJoinIsScanning()
|| (emberAfStartSearchForJoinableNetwork()
== EMBER_SUCCESS))
? waitTune
: sadTune),
TRUE);
}
} else if (halButtonState(BUTTON1) == BUTTON_PRESSED) {
emberAfEzmodeServerCommission(emberAfPrimaryEndpoint());
}
}
void initAndRunMainLoop(void)
{
EmberEventControl dataReportControl;
EmberStatus status;
int counter_reset = 0;
emberTaskEnableIdling(true);
emAppTask = emberTaskInit(emAppEvents);
// Initialize the radio and the stack. If this fails, we have to assert
// because something is wrong.
status = emberInit();
emberSerialPrintfLine(COM_USART2, "Inititialization: 0x%x", status); //ember success;0x00 so emberinit worked
assert(status == EMBER_SUCCESS);
emberAfInit();
emberAfMainInitCallback(); //emberNetworkInit() called here
emberResetNetworkState(); /////////////////leave network to join coordinator
EmberNetworkStatus net_status;
EmberNetworkParameters parameters;
emberSetSecurityKey(&securityKey);
MEMSET(¶meters, 0, sizeof(EmberNetworkParameters));
parameters.radioTxPower = 0;
parameters.radioChannel = 1;
parameters.panId = 0x01FF;
halStackSeedRandom(halCommonGetInt32uMillisecondTick());
while (TRUE) {
// Let the stack or EZSP layer run periodic tasks.
emberTick();
// Let the application and plugins run periodic tasks.
emberAfMainTickCallback();
emberAfTick();
emberEventControlSetActive(dataReportControl);
net_status = emberNetworkState();
//emberResetNetworkState();
//emberJoinNetwork(EMBER_STAR_END_DEVICE, ¶meters);
/*
if(!emberStackIsUp()){
emberAfGuaranteedPrintln("stack wasn't up");
emberJoinNetwork(EMBER_STAR_END_DEVICE, ¶meters);
}
*/
//emberAfGuaranteedPrintln("net_status is: %d", net_status);
if(counter_reset == 10000){
emberResetNetworkState();
counter_reset = 0;
}
else{
counter_reset++;
}
if (net_status == EMBER_NO_NETWORK){
//emberPermitJoining(0xFF);
//emberResetNetworkState();
emberAfGuaranteedPrintln("Network has been reset");
emberJoinNetwork(EMBER_STAR_END_DEVICE, ¶meters);
}
emberRunTask(emAppTask);
}
}
void emAfCliInfoCommand(void)
{
EmberNodeType nodeTypeResult = 0xFF;
uint8_t commandLength;
EmberEUI64 myEui64;
EmberNetworkParameters networkParams;
emberStringCommandArgument(-1, &commandLength);
printMfgString();
emberAfAppPrintln("AppBuilder MFG Code: 0x%2X", EMBER_AF_MANUFACTURER_CODE);
emberAfGetEui64(myEui64);
emberAfGetNetworkParameters(&nodeTypeResult, &networkParams);
emberAfAppPrint("node [");
emberAfAppDebugExec(emberAfPrintBigEndianEui64(myEui64));
emberAfAppFlush();
emberAfAppPrintln("] chan [%d] pwr [%d]",
networkParams.radioChannel,
networkParams.radioTxPower);
emberAfAppPrint("panID [0x%2x] nodeID [0x%2x] ",
networkParams.panId,
emberAfGetNodeId());
emberAfAppFlush();
emberAfAppPrint("xpan [0x");
emberAfAppDebugExec(emberAfPrintBigEndianEui64(networkParams.extendedPanId));
emberAfAppPrintln("]");
emberAfAppFlush();
emAfCliVersionCommand();
emberAfAppFlush();
emberAfAppPrint("nodeType [");
if (nodeTypeResult != 0xFF) {
emberAfAppPrint("0x%x", nodeTypeResult);
} else {
emberAfAppPrint("unknown");
}
emberAfAppPrintln("]");
emberAfAppFlush();
emberAfAppPrintln("%p level [%x]", "Security", emberAfGetSecurityLevel());
printSmartEnergySecurityInfo();
printSmartEnergySecurityInfo283k1();
emberAfAppPrint("network state [%x] ", emberNetworkState());
printPacketBuffers();
emberAfAppFlush();
// print the endpoint information
{
uint8_t i, j;
emberAfAppPrintln("Ep cnt: %d", emberAfEndpointCount());
// loop for each endpoint
for (i = 0; i < emberAfEndpointCount(); i++) {
EmberAfEndpointType *et = emAfEndpoints[i].endpointType;
emberAfAppPrint("ep %d [endpoint %p, device %p] ",
emberAfEndpointFromIndex(i),
(emberAfEndpointIndexIsEnabled(i)
? "enabled"
: "disabled"),
emberAfIsDeviceEnabled(emberAfEndpointFromIndex(i))
? "enabled"
: "disabled");
emberAfAppPrintln("nwk [%d] profile [0x%2x] devId [0x%2x] ver [0x%x]",
emberAfNetworkIndexFromEndpointIndex(i),
emberAfProfileIdFromIndex(i),
emberAfDeviceIdFromIndex(i),
emberAfDeviceVersionFromIndex(i));
// loop for the clusters within the endpoint
for (j = 0; j < et->clusterCount; j++) {
EmberAfCluster *zc = &(et->cluster[j]);
emberAfAppPrint(" %p cluster: 0x%2x ",
(emberAfClusterIsClient(zc)
? "out(client)"
: "in (server)" ),
zc->clusterId);
emberAfAppDebugExec(emberAfDecodeAndPrintCluster(zc->clusterId));
emberAfAppPrintln("");
emberAfAppFlush();
}
emberAfAppFlush();
}
}
{
PGM_P names[] = {
EM_AF_GENERATED_NETWORK_STRINGS
};
uint8_t i;
emberAfAppPrintln("Nwk cnt: %d", EMBER_SUPPORTED_NETWORKS);
for (i = 0; i < EMBER_SUPPORTED_NETWORKS; i++) {
emberAfPushNetworkIndex(i);
emberAfAppPrintln("nwk %d [%p]", i, names[i]);
if (emAfProIsCurrentNetwork()) {
emberAfAppPrintln(" nodeType [0x%x]",
emAfCurrentZigbeeProNetwork->nodeType);
emberAfAppPrintln(" securityProfile [0x%x]",
emAfCurrentZigbeeProNetwork->securityProfile);
}
emberAfPopNetworkIndex();
}
}
}
