static void TimerIntHandler(void)
{
// Clear interrupt flag
TimerIntClear( TIMER0_BASE, TIMER_TIMA_TIMEOUT );
if (LED_IS_ON())
LED_OFF();
else
LED_ON();
}
/**@brief Create representation of value based on content format.
*/
static void led_value_get(uint32_t led_mask, coap_content_type_t content_type, char ** str)
{
if (content_type == COAP_CT_APP_JSON)
{
static char response_str_led3_true[15] = {"{\"led3\": True}\0"};
static char response_str_led3_false[16] = {"{\"led3\": False}\0"};
static char response_str_led4_true[15] = {"{\"led4\": True}\0"};
static char response_str_led4_false[16] = {"{\"led4\": False}\0"};
if((bool)LED_IS_ON(led_mask) == true)
{
if (led_mask == LED_TWO)
{
*str = response_str_led3_true;
}
else
{
*str = response_str_led4_true;
}
}
else
{
if (led_mask == LED_TWO)
{
*str = response_str_led3_false;
}
else
{
*str = response_str_led4_false;
}
}
}
else // For all other use plain text
{
static char response_str[2];
memset(response_str, '\0', sizeof(response_str));
sprintf(response_str, "%d", (bool)LED_IS_ON(led_mask));
*str = response_str;
}
}
/**@brief Timer callback used for controlling board LEDs to represent application state.
*
* @param[in] p_context Pointer used for passing context. No context used in this application.
*/
static void blink_timeout_handler(void * p_context)
{
switch (m_display_state)
{
case LEDS_INACTIVE:
{
LEDS_OFF((LED_ONE | LED_TWO));
break;
}
case LEDS_BLE_ADVERTISING:
{
LEDS_INVERT(LED_ONE);
LEDS_OFF(LED_TWO);
break;
}
case LEDS_IPV6_IF_DOWN:
{
LEDS_ON(LED_ONE);
LEDS_INVERT(LED_TWO);
break;
}
case LEDS_TX_ECHO_RESPONSE:
{
LEDS_ON(LED_ONE);
LEDS_OFF(LED_TWO);
break;
}
case LEDS_TX_UDP_PACKET:
{
LEDS_ON(LED_TWO);
if (LED_IS_ON(LED_ONE) == 0)
{
if (m_udp_tx_occured)
{
// If UDP transmission stops, LED_ONE should stop blinking in off state.
LEDS_ON(LED_ONE);
m_udp_tx_occured = false;
}
}
else
{
LEDS_OFF(LED_ONE);
}
break;
}
default:
{
break;
}
}
}
static void led_value_get(coap_content_type_t content_type, char ** str)
{
if (content_type == COAP_CT_APP_JSON)
{
static char response_str_true[15] = {"{\"led3\": True}\0"};
static char response_str_false[16] = {"{\"led3\": False}\0"};
if((bool)LED_IS_ON(LED_THREE) == true)
{
*str = response_str_true;
}
else
{
*str = response_str_false;
}
}
// For all other use plain text
else
{
static char response_str[2];
memset(response_str, '\0', sizeof(response_str));
sprintf(response_str, "%d", (bool)LED_IS_ON(LED_THREE));
*str = response_str;
}
}
/**@brief Function for creating and sending main
* relay data page.
*
* @param[in] channel ANT channel on which to send this message.
*/
void ant_relay_main_message(uint8_t channel)
{
uint8_t status;
uint32_t err_code = sd_ant_channel_status_get(ANT_RELAY_SLAVE_CHANNEL, &status);
APP_ERROR_CHECK(err_code);
m_broadcast_data[0] = ANT_RELAY_MAIN_PAGE;
m_broadcast_data[1] = ( LED_IS_ON(BSP_LED_0_MASK) )? 1 : 0;
m_broadcast_data[2] = (uint8_t)(m_led_change_counter >> 0);
m_broadcast_data[3] = (uint8_t)(m_led_change_counter >> 8);
m_broadcast_data[4] = (uint8_t)(m_led_change_counter >> 16);
m_broadcast_data[5] = (uint8_t)(m_led_change_counter >> 24);
m_broadcast_data[6] = 0xFF;
m_broadcast_data[7] = status & STATUS_CHANNEL_STATE_MASK;
err_code = sd_ant_broadcast_message_tx(channel, ANT_STANDARD_DATA_PAYLOAD_SIZE, m_broadcast_data);
APP_ERROR_CHECK(err_code);
}
/**@brief Configure leds to indicate required state.
* @param[in] indicate State to be indicated.
*/
static uint32_t bsp_led_indication(bsp_indication_t indicate)
{
uint32_t err_code = NRF_SUCCESS;
uint32_t next_delay = 0;
switch (indicate)
{
case BSP_INDICATE_IDLE:
LEDS_OFF(LEDS_MASK & ~m_alert_mask);
m_stable_state = indicate;
break;
case BSP_INDICATE_SCANNING:
case BSP_INDICATE_ADVERTISING:
LEDS_OFF(LEDS_MASK & ~BSP_LED_0_MASK & ~m_alert_mask);
// in advertising blink LED_0
if (LED_IS_ON(BSP_LED_0_MASK))
{
LEDS_OFF(BSP_LED_0_MASK);
next_delay = indicate ==
BSP_INDICATE_ADVERTISING ? ADVERTISING_LED_OFF_INTERVAL :
ADVERTISING_SLOW_LED_OFF_INTERVAL;
}
else
{
LEDS_ON(BSP_LED_0_MASK);
next_delay = indicate ==
BSP_INDICATE_ADVERTISING ? ADVERTISING_LED_ON_INTERVAL :
ADVERTISING_SLOW_LED_ON_INTERVAL;
}
m_stable_state = indicate;
err_code = app_timer_start(m_leds_timer_id, BSP_MS_TO_TICK(next_delay), NULL);
break;
case BSP_INDICATE_ADVERTISING_WHITELIST:
LEDS_OFF(LEDS_MASK & ~BSP_LED_0_MASK & ~m_alert_mask);
// in advertising quickly blink LED_0
if (LED_IS_ON(BSP_LED_0_MASK))
{
LEDS_OFF(BSP_LED_0_MASK);
next_delay = indicate ==
BSP_INDICATE_ADVERTISING_WHITELIST ?
ADVERTISING_WHITELIST_LED_OFF_INTERVAL :
ADVERTISING_SLOW_LED_OFF_INTERVAL;
}
else
{
LEDS_ON(BSP_LED_0_MASK);
next_delay = indicate ==
BSP_INDICATE_ADVERTISING_WHITELIST ?
ADVERTISING_WHITELIST_LED_ON_INTERVAL :
ADVERTISING_SLOW_LED_ON_INTERVAL;
}
m_stable_state = indicate;
err_code = app_timer_start(m_leds_timer_id, BSP_MS_TO_TICK(next_delay), NULL);
break;
case BSP_INDICATE_ADVERTISING_SLOW:
LEDS_OFF(LEDS_MASK & ~BSP_LED_0_MASK & ~m_alert_mask);
// in advertising slowly blink LED_0
if (LED_IS_ON(BSP_LED_0_MASK))
{
LEDS_OFF(BSP_LED_0_MASK);
next_delay = indicate ==
BSP_INDICATE_ADVERTISING_SLOW ? ADVERTISING_SLOW_LED_OFF_INTERVAL :
ADVERTISING_SLOW_LED_OFF_INTERVAL;
}
else
{
LEDS_ON(BSP_LED_0_MASK);
next_delay = indicate ==
BSP_INDICATE_ADVERTISING_SLOW ? ADVERTISING_SLOW_LED_ON_INTERVAL :
ADVERTISING_SLOW_LED_ON_INTERVAL;
}
m_stable_state = indicate;
err_code = app_timer_start(m_leds_timer_id, BSP_MS_TO_TICK(next_delay), NULL);
break;
case BSP_INDICATE_ADVERTISING_DIRECTED:
LEDS_OFF(LEDS_MASK & ~BSP_LED_0_MASK & ~m_alert_mask);
// in advertising very quickly blink LED_0
if (LED_IS_ON(BSP_LED_0_MASK))
{
LEDS_OFF(BSP_LED_0_MASK);
next_delay = indicate ==
BSP_INDICATE_ADVERTISING_DIRECTED ?
ADVERTISING_DIRECTED_LED_OFF_INTERVAL :
ADVERTISING_SLOW_LED_OFF_INTERVAL;
}
else
{
LEDS_ON(BSP_LED_0_MASK);
next_delay = indicate ==
BSP_INDICATE_ADVERTISING_DIRECTED ?
ADVERTISING_DIRECTED_LED_ON_INTERVAL :
ADVERTISING_SLOW_LED_ON_INTERVAL;
}
m_stable_state = indicate;
err_code = app_timer_start(m_leds_timer_id, BSP_MS_TO_TICK(next_delay), NULL);
break;
case BSP_INDICATE_BONDING:
LEDS_OFF(LEDS_MASK & ~BSP_LED_0_MASK & ~m_alert_mask);
// in bonding fast blink LED_0
if (LED_IS_ON(BSP_LED_0_MASK))
{
LEDS_OFF(BSP_LED_0_MASK);
}
else
{
LEDS_ON(BSP_LED_0_MASK);
}
m_stable_state = indicate;
err_code =
app_timer_start(m_leds_timer_id, BSP_MS_TO_TICK(BONDING_INTERVAL), NULL);
break;
case BSP_INDICATE_CONNECTED:
LEDS_OFF(LEDS_MASK & ~BSP_LED_0_MASK & ~m_alert_mask);
LEDS_ON(BSP_LED_0_MASK);
m_stable_state = indicate;
break;
case BSP_INDICATE_SENT_OK:
// when sending shortly invert LED_1
LEDS_INVERT(BSP_LED_1_MASK);
err_code = app_timer_start(m_leds_timer_id, BSP_MS_TO_TICK(SENT_OK_INTERVAL), NULL);
break;
case BSP_INDICATE_SEND_ERROR:
// on receving error invert LED_1 for long time
LEDS_INVERT(BSP_LED_1_MASK);
err_code = app_timer_start(m_leds_timer_id, BSP_MS_TO_TICK(SEND_ERROR_INTERVAL), NULL);
break;
case BSP_INDICATE_RCV_OK:
// when receving shortly invert LED_1
LEDS_INVERT(BSP_LED_1_MASK);
err_code = app_timer_start(m_leds_timer_id, BSP_MS_TO_TICK(RCV_OK_INTERVAL), NULL);
break;
case BSP_INDICATE_RCV_ERROR:
// on receving error invert LED_1 for long time
LEDS_INVERT(BSP_LED_1_MASK);
err_code = app_timer_start(m_leds_timer_id, BSP_MS_TO_TICK(RCV_ERROR_INTERVAL), NULL);
break;
case BSP_INDICATE_FATAL_ERROR:
// on fatal error turn on all leds
LEDS_ON(LEDS_MASK);
m_stable_state = indicate;
break;
case BSP_INDICATE_ALERT_0:
case BSP_INDICATE_ALERT_1:
case BSP_INDICATE_ALERT_2:
case BSP_INDICATE_ALERT_3:
case BSP_INDICATE_ALERT_OFF:
err_code = app_timer_stop(m_alert_timer_id);
next_delay = (uint32_t)BSP_INDICATE_ALERT_OFF - (uint32_t)indicate;
// a little trick to find out that if it did not fall through ALERT_OFF
if (next_delay && (err_code == NRF_SUCCESS))
{
m_alert_mask = ALERT_LED_MASK;
if (next_delay > 1)
{
err_code = app_timer_start(m_alert_timer_id, BSP_MS_TO_TICK(
(next_delay * ALERT_INTERVAL)), NULL);
}
LEDS_ON(m_alert_mask);
}
else
{
LEDS_OFF(m_alert_mask);
m_alert_mask = 0;
}
break;
case BSP_INDICATE_USER_STATE_OFF:
LEDS_OFF(LEDS_MASK);
m_stable_state = indicate;
break;
case BSP_INDICATE_USER_STATE_0:
LEDS_OFF(LEDS_MASK & ~BSP_LED_0_MASK);
LEDS_ON(BSP_LED_0_MASK);
m_stable_state = indicate;
break;
case BSP_INDICATE_USER_STATE_1:
LEDS_OFF(LEDS_MASK & ~BSP_LED_1_MASK);
LEDS_ON(BSP_LED_1_MASK);
m_stable_state = indicate;
break;
case BSP_INDICATE_USER_STATE_2:
LEDS_OFF(LEDS_MASK & ~(BSP_LED_0_MASK | BSP_LED_1_MASK));
LEDS_ON(BSP_LED_0_MASK | BSP_LED_1_MASK);
m_stable_state = indicate;
break;
case BSP_INDICATE_USER_STATE_3:
case BSP_INDICATE_USER_STATE_ON:
LEDS_ON(LEDS_MASK);
m_stable_state = indicate;
break;
default:
break;
}
return err_code;
}
/**@brief Process ANT message on ANT mobile interface channel
*
* @details This function handles all events on the mobile interface channel.
* On EVENT_TX an ANT_MOBILE_MAIN_PAGE message is queue. The format is:
* byte[0] = page (1 = ANT_MOBILE_MAIN_PAGE)
* byte[1] = led state (1 = 0N, 0 = OFF)
* byte[2-6] = reserved (0xFF)
* byte[7] = relay slave channel status (0 = unnassigned, 1 = assigned, 2 = searching, 3 = tracking)
*
* On EVENT_RX the function will decode an ANT_MOBILE_COMMAND_PAGE. The format is:
* byte[0] = page (2 = ANT_MOBILE_COMMAND_PAGE)
* byte[1] = reserved (Set to 0xFF)
* byte[2] = command (1 = pairing, 2 = led on, 3 = led off)
* byte[3-7] = reserved (Set to 0xFF)
*
* @param[in] p_ant_event ANT message content.
*/
void ant_process_mobile(ant_evt_t* p_ant_event)
{
ANT_MESSAGE* p_ant_message = (ANT_MESSAGE*)p_ant_event->evt_buffer;
switch(p_ant_event->event)
{
case EVENT_RX:
{
switch(p_ant_message->ANT_MESSAGE_aucPayload[0])
{
case ANT_MOBILE_COMMAND_PAGE:
{
switch(p_ant_message->ANT_MESSAGE_aucPayload[2])
{
case ANT_COMMAND_ON:
{
LEDS_ON(BSP_LED_0_MASK);
m_led_change_counter++;
break;
}
case ANT_COMMAND_OFF:
{
LEDS_OFF(BSP_LED_0_MASK);
m_led_change_counter++;
break;
}
case ANT_COMMAND_PAIRING:
{
uint8_t channel_status;
uint32_t err_code = sd_ant_channel_status_get (ANT_RELAY_SLAVE_CHANNEL, &channel_status);
APP_ERROR_CHECK(err_code);
if((channel_status & STATUS_CHANNEL_STATE_MASK) == STATUS_ASSIGNED_CHANNEL)
{
err_code = sd_ant_channel_open(ANT_RELAY_SLAVE_CHANNEL);
APP_ERROR_CHECK(err_code);
}
break;
}
}
break;
}
default:
{
break;
}
}
break;
}
case EVENT_TX:
{
uint8_t status;
uint32_t err_code = sd_ant_channel_status_get(ANT_RELAY_SLAVE_CHANNEL, &status);
APP_ERROR_CHECK(err_code);
m_broadcast_data[0] = ANT_MOBILE_MAIN_PAGE;
m_broadcast_data[1] = ( LED_IS_ON(BSP_LED_0_MASK) )? 1 : 0;
m_broadcast_data[2] = 0xFF;
m_broadcast_data[3] = 0xFF;
m_broadcast_data[4] = 0xFF;
m_broadcast_data[5] = 0xFF;
m_broadcast_data[6] = 0xFF;
m_broadcast_data[7] = status & STATUS_CHANNEL_STATE_MASK;
err_code = sd_ant_broadcast_message_tx(ANT_MOBILE_CHANNEL, ANT_STANDARD_DATA_PAYLOAD_SIZE, m_broadcast_data);
APP_ERROR_CHECK(err_code);
break;
}
default:
{
break;
}
}
}
