static void rescheduleUserControlEvent(void)
{
// Look at all the active records and figure out when to schedule the event.
// If any record should have been sent in the past, we immediately schedule
// the event to send it as soon as possible. Otherwise, we find the record
// that has to be repeated soonest and schedule based on that. If there are
// no active records, we are done and cancel the event.
uint16_t nowMs = halCommonGetInt16uMillisecondTick();
uint16_t delayMs = MAX_INT16U_VALUE;
uint8_t i;
for (i = 0; i < COUNTOF(records); i++) {
if (records[i].pairingIndex != 0xFF) {
if (timeGTorEqualInt16u(nowMs, records[i].timeMs)) {
delayMs = 0;
break;
} else {
uint16_t remainingMs = elapsedTimeInt16u(nowMs, records[i].timeMs);
if (remainingMs < delayMs) {
delayMs = remainingMs;
}
}
}
}
if (delayMs == MAX_INT16U_VALUE) {
emberEventControlSetInactive(emberAfPluginRf4ceZrc11OutgoingUserControlEventControl);
} else if (delayMs == 0) {
emberEventControlSetActive(emberAfPluginRf4ceZrc11OutgoingUserControlEventControl);
} else {
emberEventControlSetDelayMS(emberAfPluginRf4ceZrc11OutgoingUserControlEventControl,
delayMs);
}
}
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);
}
}
}
Ecode_t COM_ReadDataTimeout(COM_Port_t port,
uint8_t *data,
uint16_t length,
uint16_t *bytesRead,
uint16_t firstByteTimeout,
uint16_t subsequentByteTimeout)
{
if (checkValidPort(port)==false)
{
return EMBER_ERR_FATAL;
}
uint16_t bytesReadInternal = 0;
Ecode_t status;
uint16_t timeout = firstByteTimeout;
uint16_t startTime = halCommonGetInt16uMillisecondTick();
// loop until we read the max number of bytes or the timeout elapses
while (bytesReadInternal < length
&& elapsedTimeInt16u(startTime,halCommonGetInt16uMillisecondTick()) < timeout) {
status = COM_ReadByte(port, data);
switch (status) {
case EMBER_SUCCESS:
++data;
++bytesReadInternal;
// reset timer and timeout for next character
startTime = halCommonGetInt16uMillisecondTick();
timeout = subsequentByteTimeout;
break;
case EMBER_SERIAL_RX_EMPTY:
// empty queue is not an error for us, we just want to keep waiting
break;
default:
// only store number of bytes read if the caller provided a non-NULL pointer
if (bytesRead) {
*bytesRead = bytesReadInternal;
}
return status;
}
}
// only store number of bytes read if the caller provided a non-NULL pointer
if (bytesRead) {
*bytesRead = bytesReadInternal;
}
return bytesReadInternal == length ? EMBER_SUCCESS : EMBER_SERIAL_RX_EMPTY;
}
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));
}
}
/**
* @brief check if the device needs to go to deep sleep to save power
* @param active: Flag to indicate whether the node is active or not
* @param batteryOperated: Flag to activate power management
* @retval None
*/
void powerManagement(boolean active, boolean batteryOperated)
{
static uint32_t inactiveStartTime = 0;
if (!batteryOperated)
return;
if (inactiveStartTime == 0)
{
inactiveStartTime = halCommonGetInt16uQuarterSecondTick();
}
if (active)
{
/* Reset inactive start time */
inactiveStartTime = halCommonGetInt16uQuarterSecondTick();
}
else
{
if(elapsedTimeInt16u(inactiveStartTime, halCommonGetInt16uQuarterSecondTick()) > INACTIVE_TIMEOUT)
{
StStatus status;
ST_RadioSleep();
ATOMIC(
halPowerDown();
halSleepWithOptions(SLEEPMODE_NOTIMER,
BUTTON_S1_WAKE_SOURCE|
#ifdef USE_MB950
BUTTON_S2_WAKE_SOURCE|
BUTTON_S3_WAKE_SOURCE|
BUTTON_S4_WAKE_SOURCE|
BUTTON_S5_WAKE_SOURCE|
#endif /* USE_MB950 */
UART_RX_WAKE_SOURCE);
halPowerUp();
)
/* It is the application's responsibility to reinitialize the UART */
uartInit();
status = ST_RadioInit(ST_RADIO_POWER_MODE_RX_ON);
assert(status==ST_SUCCESS);
inactiveStartTime = halCommonGetInt16uQuarterSecondTick();
}
/**
* @brief Perform periodic maintenance tasks required by STM32W108
* @param None
* @retval None
*/
void periodicMaintenanceEvents(void)
{
static uint16_t lastPeriodicEventsQsTick = 0;
if (lastPeriodicEventsQsTick == 0)
{
lastPeriodicEventsQsTick = halCommonGetInt16uQuarterSecondTick();
}
/* Run periodic maintenance events */
if(elapsedTimeInt16u(lastPeriodicEventsQsTick, halCommonGetInt16uQuarterSecondTick()) > PERIODIC_MAINTENANCE_EVENTS_RATE)
{
if(ST_RadioCheckRadio())
{
ST_RadioCalibrateCurrentChannel();
}
halCommonCheckXtalBiasTrim();
halCommonCalibratePads();
lastPeriodicEventsQsTick = halCommonGetInt16uQuarterSecondTick();
}
}
EzspStatus serialResponseReceived(void)
{
EzspStatus status;
EzspBuffer *buffer;
EzspBuffer *dropBuffer = NULL;
if (!checkConnection()) {
ezspTraceEzspVerbose("serialResponseReceived(): EZSP_NOT_CONNECTED");
return EZSP_NOT_CONNECTED;
}
// ashSendExec();
// status = ashReceiveExec();
status = usbReceive();
if (status != EZSP_SUCCESS
&& status != EZSP_ASH_IN_PROGRESS
&& status != EZSP_NO_RX_DATA) {
ezspTraceEzspVerbose("serialResponseReceived(): 0x%x",
status);
return status;
}
if (waitingForResponse
&& elapsedTimeInt16u(waitStartTime, halCommonGetInt16uMillisecondTick())
> WAIT_FOR_RESPONSE_TIMEOUT) {
waitingForResponse = false;
ezspTraceEzspFrameId("no response", ezspFrameContents);
ezspTraceEzspVerbose("serialResponseReceived(): EZSP_ERROR_NO_RESPONSE");
return EZSP_ERROR_NO_RESPONSE;
}
status = EZSP_NO_RX_DATA;
buffer = ezspQueuePrecedingEntry(&rxQueue, NULL);
while (buffer != NULL) {
// While we are waiting for a response to a command, we use the asynch
// callback flag to ignore asynchronous callbacks. This allows our caller
// to assume that no callbacks will appear between sending a command and
// receiving its response.
if (waitingForResponse
&& (buffer->data[EZSP_FRAME_CONTROL_INDEX]
& EZSP_FRAME_CONTROL_ASYNCH_CB)
) {
if (ezspFreeListLength(&rxFree) == 0) {
dropBuffer = buffer;
}
buffer = ezspQueuePrecedingEntry(&rxQueue, buffer);
} else {
ezspTraceEzspVerbose("serialResponseReceived(): ID=0x%x Seq=0x%x Buffer=%u",
buffer->data[EZSP_FRAME_ID_INDEX],
buffer->data[EZSP_SEQUENCE_INDEX],
buffer);
ezspRemoveQueueEntry(&rxQueue, buffer);
memcpy(ezspFrameContents, buffer->data, buffer->len);
ezspTraceEzspFrameId("got response", buffer->data);
ezspFrameLength = buffer->len;
ezspFreeBuffer(&rxFree, buffer);
ezspTraceEzspVerbose("serialResponseReceived(): ezspFreeBuffer(): %u", buffer);
buffer = NULL;
status = EZSP_SUCCESS;
waitingForResponse = false;
}
}
if (dropBuffer != NULL) {
ezspRemoveQueueEntry(&rxQueue, dropBuffer);
ezspFreeBuffer(&rxFree, dropBuffer);
ezspTraceEzspFrameId("dropping", dropBuffer->data);
ezspTraceEzspVerbose("serialResponseReceived(): ezspFreeBuffer(): drop %u", dropBuffer);
ezspTraceEzspVerbose("serialResponseReceived(): ezspErrorHandler(): EZSP_ERROR_QUEUE_FULL");
ezspErrorHandler(EZSP_ERROR_QUEUE_FULL);
}
return status;
}
