void ant_sdm_sens_evt_handler(ant_sdm_profile_t * p_profile, ant_evt_t * p_ant_event)
{
ASSERT(p_profile != NULL);
ASSERT(p_ant_event != NULL);
if (p_ant_event->channel == p_profile->channel_number)
{
uint32_t err_code;
uint8_t p_message_payload[ANT_STANDARD_DATA_PAYLOAD_SIZE];
ant_sdm_sens_cb_t * p_sdm_cb = p_profile->_cb.p_sens_cb;
ant_request_controller_sens_evt_handler(&(p_sdm_cb->req_controller), p_ant_event);
switch (p_ant_event->event)
{
case EVENT_TX:
case EVENT_TRANSFER_TX_FAILED:
case EVENT_TRANSFER_TX_COMPLETED:
sens_message_encode(p_profile, p_message_payload);
if (ant_request_controller_ack_needed(&(p_sdm_cb->req_controller)))
{
err_code = sd_ant_acknowledge_message_tx(p_profile->channel_number, sizeof(p_message_payload), p_message_payload);
}
else
{
err_code = sd_ant_broadcast_message_tx(p_profile->channel_number, sizeof(p_message_payload), p_message_payload);
}
APP_ERROR_CHECK(err_code);
break;
default:
break;
}
}
}
/** @brief Processes a ANT messages while in the confirming state.
*
* @param[in] Pointer to the raw ant message received.
*/
static void ascs_process_message_confirming(uint8_t event, uint8_t * p_event_message_buffer)
{
switch (event)
{
case EVENT_TRANSFER_TX_FAILED:
{
int32_t err_code;
//Re-send the Confirm Acquire page (should still be loaded in the tx buffer).
err_code = sd_ant_acknowledge_message_tx(m_channel_number, ANT_STANDARD_DATA_PAYLOAD_SIZE, m_tx_buffer);
APP_ERROR_CHECK(err_code);
break;
}
case EVENT_TRANSFER_TX_COMPLETED:
{
ascs_set_state(ASSIGNED);
break;
}
case EVENT_CHANNEL_CLOSED:
case EVENT_RX: //Intentional fallthrough
default:
{
break;
}
}
}
static __INLINE void send_polling_message(void)
{
uint32_t err_code;
volatile asc_request_data_t request = {
m_current_shared_address_polling,
UPDATE_DATA_PID
};
asc_encode_request_data_page(request, m_tx_buffer);
err_code = sd_ant_acknowledge_message_tx(m_channel_number, ANT_STANDARD_DATA_PAYLOAD_SIZE, m_tx_buffer);
APP_ERROR_CHECK(err_code);
}
/** @brief Function for transmitting calibration request message.
*
* @return The ant_acknowledge_message_tx method return code.
*/
static uint32_t calibration_request_transmit(void)
{
static uint8_t tx_buffer[TX_BUFFER_SIZE];
// Format the manual calibration request.
tx_buffer[0] = BP_PAGE_1;
tx_buffer[1] = BP_CID_170;
tx_buffer[2] = BP_PAGE_RESERVE_BYTE;
tx_buffer[3] = BP_PAGE_RESERVE_BYTE;
tx_buffer[4] = BP_PAGE_RESERVE_BYTE;
tx_buffer[5] = BP_PAGE_RESERVE_BYTE;
tx_buffer[6] = BP_PAGE_RESERVE_BYTE;
tx_buffer[7] = BP_PAGE_RESERVE_BYTE;
return sd_ant_acknowledge_message_tx(BP_RX_ANT_CHANNEL, sizeof(tx_buffer), tx_buffer);
}
uint32_t ant_request_controller_request(ant_request_controller_t * p_controller,
uint8_t channel_number,
ant_common_page70_data_t * p_page_70)
{
ASSERT(p_controller != NULL);
ASSERT(p_page_70 != NULL);
ant_common_message_layout_t message;
message.page_number = ANT_COMMON_PAGE_70;
ant_common_page_70_encode(message.page_payload, p_page_70);
p_controller->state = ANT_REQUEST_CONTROLLER_SENDED;
return sd_ant_acknowledge_message_tx(channel_number, sizeof (message), (uint8_t *)&message);
}
ret_code_t ant_bpwr_calib_request(ant_bpwr_profile_t * p_profile, ant_bpwr_page1_data_t * p_page_1)
{
ant_bpwr_message_layout_t bpwr_message_payload;
if (p_profile->_cb.p_disp_cb->calib_stat == BPWR_DISP_CALIB_REQUESTED)
{
return NRF_SUCCESS; // calibration in progress, so omit this request
}
bpwr_message_payload.page_number = ANT_BPWR_PAGE_1;
ant_bpwr_page_1_encode(bpwr_message_payload.page_payload, p_page_1);
uint32_t err_code = sd_ant_acknowledge_message_tx(p_profile->channel_number,
sizeof (bpwr_message_payload),
(uint8_t *) &bpwr_message_payload);
if (err_code == NRF_SUCCESS)
{
p_profile->_cb.p_disp_cb->calib_timeout = BPWR_CALIB_INT_TIMEOUT; // initialize watch on calibration's time-out
p_profile->_cb.p_disp_cb->calib_stat = BPWR_DISP_CALIB_REQUESTED;
LOG_BPWR("Start calibration process\r\n");
}
return err_code;
}
/**@brief Send command to node with highest RSSI.
* If a global command was selected, send to all.
*/
static void send_command(void)
{
uint16_t device_number = 0;
uint8_t max_rssi = 0;
uint32_t err_code;
// Loop through nodes and pick highest rssi node
for(int node = 0; node < MAX_DEVICES; node++)
{
if(m_node_list[node].device_number != 0)
{
if(m_node_list[node].rssi > max_rssi)
{
max_rssi = m_node_list[node].rssi;
device_number = m_node_list[node].device_number;
}
}
}
// Do not send the command if no device was found
// Close scanning channel and return
if( device_number == 0 )
{
LEDS_ON(BSP_LED_2_MASK);
LEDS_OFF(BSP_LED_0_MASK);
err_code = sd_ant_channel_close(ANT_SCAN_CHANNEL_NUMBER);
APP_ERROR_CHECK(err_code);
return;
}
else
{
LEDS_OFF(BSP_LED_2_MASK);
}
err_code = sd_ant_channel_id_set(ANT_RESPONSE_CHANNEL_NUMBER,
device_number,
ANT_DEVICE_TYPE,
ANT_TRANSMISSION_TYPE);
APP_ERROR_CHECK(err_code);
switch( m_command )
{
case COMMAND_STATE_ON:
m_command = COMMAND_LIGHT_ON;
break;
case COMMAND_STATE_OFF:
m_command = COMMAND_LIGHT_OFF;
break;
case COMMAND_STATE_ALL_ON:
device_number = ADDRESS_ALL_NODES;
m_command = COMMAND_LIGHT_ON;
break;
case COMMAND_STATE_ALL_OFF:
device_number = ADDRESS_ALL_NODES;
m_command = COMMAND_LIGHT_OFF;
break;
default:
break;
}
m_tx_buffer[0] = MOBILE_COMMAND_PAGE;
m_tx_buffer[1] = 0xFF;
m_tx_buffer[2] = device_number;
m_tx_buffer[3] = 0xFF;
m_tx_buffer[4] = 0xFF;
m_tx_buffer[5] = 0xFF;
m_tx_buffer[6] = 0xFF;
m_tx_buffer[7] = m_command;
err_code = sd_ant_acknowledge_message_tx(ANT_RESPONSE_CHANNEL_NUMBER,
ANT_STANDARD_DATA_PAYLOAD_SIZE,
m_tx_buffer);
APP_ERROR_CHECK(err_code);
}
/**@brief Sets the state machine to the specified state.
*/
static void ascs_set_state(ascs_states_t new_state)
{
uint32_t err_code;
if(m_state != new_state)
{
switch (new_state)
{
case OFF:
{
m_state = new_state;
err_code = sd_ant_channel_close(m_channel_number);
APP_ERROR_CHECK(err_code);
break;
}
case SEARCHING:
{
//Check if we need to re-open the channel
if (m_state == OFF)
{
//Open slave channel
err_code = sd_ant_channel_open(m_channel_number);
APP_ERROR_CHECK(err_code);
}
m_state = new_state;
m_groups_assigned = NO_GROUPS;
m_shared_address = SEARCH_ADDRESS;
asc_encode_set_shared_address(m_shared_address, m_tx_buffer);
err_code = sd_ant_broadcast_message_tx (m_channel_number, ANT_STANDARD_DATA_PAYLOAD_SIZE, m_tx_buffer);
APP_ERROR_CHECK(err_code);
break;
}
case REQUESTING:
{
if(m_state != SEARCHING)
{
asc_event_set(&m_asc_event_flags, EVENT_ASC_DEVICE_IN_WRONG_STATE);
return;
}
m_state = new_state;
asc_encode_request_address_page(m_serial_number, m_tx_buffer);
err_code = sd_ant_acknowledge_message_tx(m_channel_number, ANT_STANDARD_DATA_PAYLOAD_SIZE, m_tx_buffer);
APP_ERROR_CHECK(err_code);
break;
}
case WAITING:
{
if(m_state != REQUESTING)
{
asc_event_set(&m_asc_event_flags, EVENT_ASC_DEVICE_IN_WRONG_STATE);
return;
}
m_state = new_state;
m_shared_address = REGISTER_ADDRESS;
asc_encode_set_shared_address(m_shared_address, m_tx_buffer);
err_code = sd_ant_broadcast_message_tx (m_channel_number, ANT_STANDARD_DATA_PAYLOAD_SIZE, m_tx_buffer);
APP_ERROR_CHECK(err_code);
break;
}
case CONFIRMING:
{
if(m_state != WAITING)
{
asc_event_set(&m_asc_event_flags, EVENT_ASC_DEVICE_IN_WRONG_STATE);
return;
}
m_state = new_state;
m_timeout_counter = 0;
asc_confirm_acquire_paramters_t params = {
.serial_number = m_serial_number,
.model_number = MODEL_NUMBER,
.hw_revision = HW_REVISION,
.sw_revision = SW_REVISION
};
asc_encode_confirm_acquire_page(params, m_tx_buffer);
err_code = sd_ant_acknowledge_message_tx(m_channel_number, ANT_STANDARD_DATA_PAYLOAD_SIZE, m_tx_buffer);
APP_ERROR_CHECK(err_code);
break;
}
case ASSIGNED:
{
if(m_state != CONFIRMING)
{
asc_event_set(&m_asc_event_flags, EVENT_ASC_DEVICE_IN_WRONG_STATE);
return;
}
ascs_states_t previous_state = m_state;
m_state = new_state;
m_timeout_counter = 0;
if(previous_state == CONFIRMING)
{
asc_encode_set_shared_address(m_shared_address, m_tx_buffer);
err_code = sd_ant_broadcast_message_tx (m_channel_number, ANT_STANDARD_DATA_PAYLOAD_SIZE, m_tx_buffer);
APP_ERROR_CHECK(err_code);
}
break;
}
default:
{
asc_event_set(&m_asc_event_flags, EVENT_ASC_DEVICE_IN_WRONG_STATE);
return;
}
}
asc_event_set(&m_asc_event_flags, EVENT_ASC_STATE_CHANGED);
}
}
/**@brief Processes an ANT messages while in the sending command state.
*
* @param[in] Pointer to the raw ant message received.
*/
static void process_message_sending_command(uint8_t* p_ant_message)
{
uint32_t err_code;
switch (p_ant_message[ANT_MESSAGE_ID_OFFSET])
{
case MESG_RESPONSE_EVENT_ID:
{
if (p_ant_message[ANT_MESSAGE_DATA0_OFFSET] == MESG_EVENT_ID) //Channel event
{
switch (p_ant_message[ANT_MESSAGE_DATA1_OFFSET])
{
case EVENT_TX:
{
//This event will be received if broadcast messages were used
//Automatically retry to increase the chances of a successful transmission
asc_encode_command_page(m_current_command_data, m_tx_buffer);
if (m_send_command_as_ack)
{
err_code = sd_ant_acknowledge_message_tx(m_channel_number, ANT_STANDARD_DATA_PAYLOAD_SIZE, m_tx_buffer);
}
else
{
err_code = sd_ant_broadcast_message_tx(m_channel_number, ANT_STANDARD_DATA_PAYLOAD_SIZE, m_tx_buffer);
}
APP_ERROR_CHECK(err_code);
if (++m_msg_counter_sending_command > m_retries)
{
m_is_command_pending = false;
ascm_set_state(m_previous_state);
}
break;
}
case EVENT_TRANSFER_TX_COMPLETED:
{
//The message was successfully received. No need to resend
m_is_command_pending = false;
ascm_set_state(m_previous_state);
break;
}
case EVENT_TRANSFER_TX_FAILED:
{
asc_encode_command_page(m_current_command_data, m_tx_buffer);
err_code = sd_ant_acknowledge_message_tx(m_channel_number, ANT_STANDARD_DATA_PAYLOAD_SIZE, m_tx_buffer);
APP_ERROR_CHECK(err_code);
//retry untitl success, or until too many retries have occured
if (++m_msg_counter_sending_command > m_retries)
{
m_is_command_pending = false;
ascm_set_state(m_previous_state);
}
break;
}
default:
{
break;
}
}
}
break;
}
case MESG_ACKNOWLEDGED_DATA_ID:
//fall-through
case MESG_BROADCAST_DATA_ID:
{
//Process by page
switch (p_ant_message[DECODE_PAGE_ID_BYTE])
{
case UPDATE_DATA_PID:
{
process_device_update(p_ant_message);
break;
}
default:
{
break;
}
}
break;
}
default:
{
break;
}
}
}
void ant_message_types_master_setup(void)
{
uint32_t err_code;
ant_channel_config_t channel_config =
{
.channel_number = ANT_CHANNEL_NUMBER,
.channel_type = CHANNEL_TYPE_MASTER,
.ext_assign = EXT_ASSIGN,
.rf_freq = RF_FREQUENCY,
.transmission_type = CHAN_ID_TRANS_TYPE,
.device_type = CHAN_ID_DEV_TYPE,
.device_number = (uint16_t) (NRF_FICR->DEVICEID[0]),
.channel_period = CHANNEL_PERIOD,
.network_number = ANT_CHANNEL_DEFAULT_NETWORK,
};
err_code = ant_channel_init(&channel_config);
APP_ERROR_CHECK(err_code);
//Set Tx Power
err_code = sd_ant_channel_radio_tx_power_set(ANT_CHANNEL_NUMBER, RADIO_TX_POWER_LVL_3, ANT_CUSTOM_TRANSMIT_POWER);
APP_ERROR_CHECK(err_code);
// Open channel.
err_code = sd_ant_channel_open(ANT_CHANNEL_NUMBER);
APP_ERROR_CHECK(err_code);
// Write counter value to last byte of the broadcast data.
// The last byte is chosen to get the data more visible in the end of an printout
// on the recieving end.
memset(m_tx_buffer, 0, BROADCAST_DATA_BUFFER_SIZE);
m_tx_buffer[BROADCAST_DATA_BUFFER_SIZE - 1] = m_counter;
// Configure the initial payload of the broadcast data
err_code = sd_ant_broadcast_message_tx(ANT_CHANNEL_NUMBER, BROADCAST_DATA_BUFFER_SIZE, m_tx_buffer);
APP_ERROR_CHECK(err_code);
//Set state to broadcasting
state_message_types = BROADCAST;
}
void ant_message_types_master_bsp_evt_handler(bsp_event_t evt)
{
switch (evt)
{
case BSP_EVENT_KEY_0:
state_message_types = BROADCAST;
break;
case BSP_EVENT_KEY_1:
state_message_types = ACKNOWLEDGED;
break;
case BSP_EVENT_KEY_2:
state_message_types = BURST;
break;
default:
break; // no implementation needed
}
}
void ant_message_types_master_event_handler(ant_evt_t * p_ant_evt)
{
uint32_t err_code;
uint32_t led_output = LED_BROADCAST;
switch (p_ant_evt->event)
{
// ANT broadcast/Acknowledged/Burst Success
// Send the next message according to the current state and increment the counter.
case EVENT_TX: // Intentional fall through
case EVENT_TRANSFER_TX_COMPLETED: // Intentional fall through
case EVENT_TRANSFER_TX_FAILED:
LEDS_OFF(LEDS_MASK);
m_tx_buffer[BROADCAST_DATA_BUFFER_SIZE - 1] = m_counter;
if(state_message_types == BROADCAST)
{
// Send as broadcast
err_code = sd_ant_broadcast_message_tx(ANT_CHANNEL_NUMBER,
BROADCAST_DATA_BUFFER_SIZE,
m_tx_buffer);
APP_ERROR_CHECK(err_code);
led_output = LED_BROADCAST;
}
else if(state_message_types == ACKNOWLEDGED)
{
// Send as acknowledged
err_code = sd_ant_acknowledge_message_tx(ANT_CHANNEL_NUMBER,
BROADCAST_DATA_BUFFER_SIZE,
m_tx_buffer);
APP_ERROR_CHECK(err_code);
led_output = LED_ACKNOWLEDGED;
}
else if(state_message_types == BURST)
{
// If this is a new message, populate the burst buffer
// with new dummy data. Otherwise, will retry sending the
// same content.
if(p_ant_evt->event != EVENT_TRANSFER_TX_FAILED)
{
for(uint32_t i = 0; i < BURST_BLOCK_SIZE; i++)
{
m_burst_data[i] = m_counter;
m_counter++;
}
}
// Queue a Burst Transfer. Since this is a small burst, queue entire burst.
err_code = sd_ant_burst_handler_request(ANT_CHANNEL_NUMBER,
BURST_BLOCK_SIZE,
m_burst_data,
(BURST_SEGMENT_START | BURST_SEGMENT_END));
APP_ERROR_CHECK(err_code);
led_output = LED_BURST;
}
// Activate LED for 20ms
LEDS_ON(led_output);
nrf_delay_ms(20);
LEDS_OFF(led_output);
m_counter++;
break;
case TRANSFER_IN_PROGRESS: //Intentional fall through
case TRANSFER_SEQUENCE_NUMBER_ERROR: //Intentional fall through
case TRANSFER_IN_ERROR: //Intentional fall through
case TRANSFER_BUSY:
// Ignore these events; will retry burst transfer when we get the EVENT_TRANSFER_TX_FAILED event.
break;
default:
break;
}
}
