bool emberAfPreZDOMessageReceivedCallback(EmberNodeId sender,
EmberApsFrame* apsFrame,
uint8_t* message,
uint16_t length)
{
if (!enabled) {
return false;
}
if (apsFrame->clusterId == END_DEVICE_ANNOUNCE) {
EmberEUI64 tempEui64;
MEMMOVE(tempEui64, &(message[DEVICE_ANNOUNCE_EUI64_OFFSET]), EUI64_SIZE);
// If the device already exists, this call won't overwrite it and will
// leave its status alone. Maybe it rejoined and we already know about,
// in which case we won't bother re-interrogating it.
const EmberAfDeviceInfo* device = emberAfPluginDeviceDatabaseAdd(tempEui64, message[DEVICE_ANNOUNCE_CAPABILITIES_OFFSET]);
if (device == NULL) {
emberAfCorePrint("Error: %p failed to add device to database: ",
PLUGIN_NAME);
emberAfPrintLittleEndianEui64(tempEui64);
emberAfCorePrintln("");
} else {
if (device->status == EMBER_AF_DEVICE_DISCOVERY_STATUS_NEW) {
emberAfCorePrint("%p added device to database: ", PLUGIN_NAME);
emberAfPrintLittleEndianEui64(tempEui64);
emberAfCorePrintln(", capabilities: 0x%X", device->capabilities);
scheduleEvent(WITH_DELAY);
}
}
return true;
}
return false;
}
bool emberAfPluginDeviceDatabaseSetEndpoints(const EmberEUI64 eui64,
const uint8_t* endpointList,
uint8_t endpointCount)
{
EmberAfDeviceInfo* device = findDeviceByEui64(eui64);
if (device == NULL) {
emberAfCorePrint("Error: %p cannot add endpoints. No such device in database: ");
emberAfPrintLittleEndianEui64(eui64);
emberAfCorePrintln("");
return false;
}
// Clear all existing endpoints so there is no leftover clusters or endpoints.
MEMSET(device->endpoints,
0xFF,
sizeof(EmberAfEndpointInfoStruct) * EMBER_AF_MAX_ENDPOINTS_PER_DEVICE);
device->endpointCount = (endpointCount < EMBER_AF_MAX_ENDPOINTS_PER_DEVICE
? endpointCount
: EMBER_AF_MAX_ENDPOINTS_PER_DEVICE);
uint8_t i;
for (i = 0; i < device->endpointCount; i++) {
device->endpoints[i].endpoint = *endpointList;
device->endpoints[i].clusterCount = 0;
endpointList++;
}
return true;
}
/** @brief User Control Repeated
*
* This function is called by the RF4CE ZRC plugin when a User Control
* Repeated message is received by the device.
*
* @param commandCode The HDMI CEC operand [UI Command]. Ver.: always
* @param commandPayload The additional operands, if any, required by the HDMI
* CEC command. Ver.: always
* @param commandPayloadLength The length of the command payload in bytes.
* Ver.: always
*/
void emberAfPluginRf4ceZrc11UserControlRepeatedCallback(EmberAfRf4ceUserControlCode commandCode,
const int8u *commandPayload,
int8u commandPayloadLength)
{
emberAfCorePrint("Repeated 0x%x {", commandCode);
emberAfCorePrintBuffer(commandPayload, commandPayloadLength, FALSE);
emberAfCorePrintln("}");
}
void ALIAS(emberGetGlobalAddressReturn)(const EmberIpv6Address *address,
uint32_t preferredLifetime,
uint32_t validLifetime,
uint8_t addressFlags)
{
emberAfCorePrint("global address: ");
emberAfCoreDebugExec(emberAfPrintIpv6Address(address));
emberAfCorePrintln("");
}
void ALIAS(emberGetGlobalPrefixReturn)(uint8_t borderRouterFlags,
const uint8_t *prefix,
uint8_t domainId,
uint32_t preferredLifetime,
uint32_t validLifetime)
{
emberAfCorePrint("global prefix: ");
emberAfCoreDebugExec(emberAfPrintIpv6Prefix((const EmberIpv6Prefix *)prefix));
emberAfCorePrintln("");
}
void endpointPrint(void)
{
uint8_t i;
for (i = 0; i < emberAfEndpointCount(); i++) {
emberAfCorePrint("EP %d: %p ",
emAfEndpoints[i].endpoint,
(emberAfEndpointIndexIsEnabled(i)
? "Enabled"
: "Disabled"));
emAfPrintEzspEndpointFlags(emAfEndpoints[i].endpoint);
emberAfCorePrintln("");
}
}
void printEvents(void)
{
uint8_t i = 0;
uint32_t nowMS32 = halCommonGetInt32uMillisecondTick();
while (emAfEvents[i].control != NULL) {
emberAfCorePrint("%p : ", emAfEventStrings[i]);
if (emAfEvents[i].control->status == EMBER_EVENT_INACTIVE) {
emberAfCorePrintln("inactive");
} else {
emberAfCorePrintln("%l ms", emAfEvents[i].control->timeToExecute - nowMS32);
}
i++;
}
}
const EmberAfDeviceInfo* emberAfPluginDeviceDatabaseAddDeviceWithAllInfo(const EmberAfDeviceInfo* newDevice)
{
if (NULL != findDeviceByEui64(newDevice->eui64)) {
emberAfCorePrint("Error: %p cannot add device that already exists: ", PLUGIN_NAME);
emberAfPrintLittleEndianEui64(newDevice->eui64);
emberAfCorePrintln("");
return NULL;
}
EmberEUI64 nullEui64;
MEMSET(nullEui64, 0xFF, EUI64_SIZE);
EmberAfDeviceInfo* device = findDeviceByEui64(nullEui64);
if (device != NULL) {
MEMMOVE(device, newDevice, sizeof(EmberAfDeviceInfo));
emberAfPluginDeviceDatabaseDiscoveryCompleteCallback(device);
}
return device;
}
void emberAfPluginDeviceQueryServiceMyEventHandler(void)
{
emberEventControlSetInactive(emberAfPluginDeviceQueryServiceMyEventControl);
debugPrintln("%p event", PLUGIN_NAME);
const EmberAfDeviceInfo* device;
if (emberAfMemoryByteCompare(currentEui64, EUI64_SIZE, 0xFF)) {
debugPrintln("%p no current device being queried, looking in database for one.", PLUGIN_NAME);
device = emberAfPluginDeviceDatabaseFindDeviceByStatus(EMBER_AF_DEVICE_DISCOVERY_STATUS_NEW
| EMBER_AF_DEVICE_DISCOVERY_STATUS_FIND_ENDPOINTS
| EMBER_AF_DEVICE_DISCOVERY_STATUS_FIND_CLUSTERS);
if (device != NULL) {
debugPrintln("%p found device with status (0x%X): %p",
PLUGIN_NAME,
device->status,
emberAfPluginDeviceDatabaseGetStatusString(device->status));
if ((device->capabilities & RECEIVER_ON_WHEN_IDLE) == 0) {
emberAfPluginDeviceDatabaseSetStatus(device->eui64, EMBER_AF_DEVICE_DISCOVERY_STATUS_DONE);
debugPrintln("%p ignoring sleepy device.");
scheduleEvent(RIGHT_NOW);
return;
} else {
MEMMOVE(currentEui64, device->eui64, EUI64_SIZE);
}
}
} else {
device = emberAfPluginDeviceDatabaseFindDeviceByEui64(currentEui64);
if (device == NULL) {
emberAfCorePrint("Error: %p the current EUI64 does not correspond to any known device: ", PLUGIN_NAME);
emberAfPrintLittleEndianEui64(currentEui64);
emberAfCorePrintln("");
clearCurrentDevice();
scheduleEvent(WITH_DELAY);
return;
}
}
if (device == NULL) {
clearCurrentDevice();
if (emberAfPluginDeviceDatabaseClearAllFailedDiscoveryStatus(EMBER_AF_PLUGIN_DEVICE_QUERY_SERVICE_MAX_FAILURES)) {
emberAfCorePrintln("%p Retrying failed discoveries.", PLUGIN_NAME);
scheduleEvent(WITH_DELAY);
} else {
emberAfCorePrintln("%p All known devices discovered.", PLUGIN_NAME);
}
return;
}
// Although we could consult our local tables for addresses, we perform a broadcast
// lookup here to insure that we have a current source route back to the destination.
// The target of the discovery will unicast the result, along with a route record.
if (currentNodeId == EMBER_NULL_NODE_ID) {
debugPrint("%p initiating node ID discovery for: ", PLUGIN_NAME);
debugPrintEui64(currentEui64);
debugPrintln("");
EmberStatus status = emberAfFindNodeId(currentEui64, serviceDiscoveryCallback);
if (status != EMBER_SUCCESS) {
emberAfCorePrintln("%p failed to initiate node ID discovery.", PLUGIN_NAME);
noteFailedDiscovery(device);
scheduleEvent(WITH_DELAY);
}
// Else
// Don't schedule event, since service discovery callback returns the results.
return;
}
switch (device->status) {
case EMBER_AF_DEVICE_DISCOVERY_STATUS_NEW:
case EMBER_AF_DEVICE_DISCOVERY_STATUS_FIND_ENDPOINTS:
sendActiveEndpointRequest(device);
break;
case EMBER_AF_DEVICE_DISCOVERY_STATUS_FIND_CLUSTERS:
sendSimpleDescriptorRequest(device);
break;
default:
break;
}
}
static void serviceDiscoveryCallback(const EmberAfServiceDiscoveryResult* result)
{
debugPrintln("%p serviceDiscoveryCallback()", PLUGIN_NAME);
emberEventControlSetInactive(emberAfPluginDeviceQueryServiceMyEventControl);
if (!enabled) {
return;
}
const EmberAfDeviceInfo* device = emberAfPluginDeviceDatabaseFindDeviceByEui64(currentEui64);
if (device == NULL) {
emberAfCorePrint("Error: %p could not find device in database with EUI64: ", PLUGIN_NAME);
emberAfPrintLittleEndianEui64(currentEui64);
emberAfCorePrintln("");
clearCurrentDevice();
scheduleEvent(WITH_DELAY);
return;
}
if (!emberAfHaveDiscoveryResponseStatus(result->status)) {
emberAfCorePrintln("Error: %p service discovery returned no results.", PLUGIN_NAME);
noteFailedDiscovery(device);
scheduleEvent(WITH_DELAY);
return;
} else if (result->zdoRequestClusterId == NETWORK_ADDRESS_REQUEST) {
currentNodeId = result->matchAddress;
emberAfPluginDeviceDatabaseSetStatus(device->eui64, EMBER_AF_DEVICE_DISCOVERY_STATUS_FIND_ENDPOINTS);
scheduleEvent(RIGHT_NOW);
} else if (result->zdoRequestClusterId == ACTIVE_ENDPOINTS_REQUEST) {
const EmberAfEndpointList* listStruct = (const EmberAfEndpointList*)(result->responseData);
debugPrintln("%p found %d active endpoints.", PLUGIN_NAME, listStruct->count);
if (!emberAfPluginDeviceDatabaseSetEndpoints(device->eui64,
listStruct->list,
listStruct->count)) {
emberAfCorePrint("Error: %p failed to set endpoints in device database for:", PLUGIN_NAME);
emberAfPrintLittleEndianEui64(device->eui64);
emberAfCorePrintln("");
noteFailedDiscovery(device);
scheduleEvent(WITH_DELAY);
} else {
currentEndpointIndex = 0;
emberAfPluginDeviceDatabaseSetStatus(device->eui64, EMBER_AF_DEVICE_DISCOVERY_STATUS_FIND_CLUSTERS);
scheduleEvent(RIGHT_NOW);
}
} else if (result->zdoRequestClusterId == SIMPLE_DESCRIPTOR_REQUEST) {
const EmberAfClusterList* clusterInfo = (const EmberAfClusterList*)result->responseData;
debugPrintln("%p found %d server clusters and %d client clusters on EP %d",
PLUGIN_NAME,
clusterInfo->inClusterCount,
clusterInfo->outClusterCount,
clusterInfo->endpoint);
if (!emberAfPluginDeviceDatabaseSetClustersForEndpoint(device->eui64,
clusterInfo)) {
emberAfCorePrintln("Error: %p failed to set clusters for device.", PLUGIN_NAME);
noteFailedDiscovery(device);
scheduleEvent(WITH_DELAY);
} else {
currentEndpointIndex++;
scheduleEvent(RIGHT_NOW);
}
}
}