kelvin
/
spider-bot
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
spider-bot/fw/nrf52/nrf5_sdk/components/ant/ant_fs/antfs.c

2382 lines
97 KiB
C
Raw Blame History

/**
* This software is subject to the ANT+ Shared Source License
* www.thisisant.com/swlicenses
* Copyright (c) Garmin Canada Inc. 2012
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
*
* 1) Redistributions of source code must retain the above
* copyright notice, this list of conditions and the following
* disclaimer.
*
* 2) Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials
* provided with the distribution.
*
* 3) Neither the name of Garmin nor the names of its
* contributors may be used to endorse or promote products
* derived from this software without specific prior
* written permission.
*
* The following actions are prohibited:
*
* 1) Redistribution of source code containing the ANT+ Network
* Key. The ANT+ Network Key is available to ANT+ Adopters.
* Please refer to http://thisisant.com to become an ANT+
* Adopter and access the key.
*
* 2) Reverse engineering, decompilation, and/or disassembly of
* software provided in binary form under this license.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE HEREBY
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES(INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; DAMAGE TO ANY DEVICE, LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE. SOME STATES DO NOT ALLOW
* THE EXCLUSION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THE
* ABOVE LIMITATIONS MAY NOT APPLY TO YOU.
*
*/
#include "sdk_common.h"
#if NRF_MODULE_ENABLED(ANTFS)
#include "antfs.h"
#include <string.h>
#include "defines.h"
#include "app_error.h"
#include "app_timer.h"
#include "ant_error.h"
#include "ant_parameters.h"
#include "ant_interface.h"
#include "ant_key_manager.h"
#include "crc.h"
#if ANTFS_CONFIG_DEBUG_LED_ENABLED
#include "bsp.h"
#endif // ANTFS_CONFIG_DEBUG_LED_ENABLED
#define BURST_PACKET_SIZE 8u /**< The burst packet size. */
#define ANTFS_CONNECTION_TYPE_OFFSET 0x00u /**< The connection type offset within ANT-FS message. */
#define ANTFS_COMMAND_OFFSET 0x01u /**< The command offset within ANT-FS message. */
#define ANTFS_RESPONSE_OFFSET 0x01u /**< The response offset within ANT-FS message. */
#define ANTFS_CONTROL_OFFSET 0x02u /**< The control offset within ANT-FS message. */
#define ANTFS_DATA_OFFSET 0x03u /**< The data offset within ANT-FS message. */
#define ANTFS_BEACON_ID 0x43u /**< The ANT-FS beacon ID. */
#define ANTFS_COMMAND_ID 0x44u /**< The ANT-FS command ID. */
// Beacon definitions.
#define STATUS1_OFFSET 0x01u /**< The beacon status1 field offset. */
#define STATUS2_OFFSET 0x02u /**< The beacon status2 field offset. */
#define DEVICE_STATE_SHIFT 0x00u /**< Shift value for device state bitfield. */
#define DEVICE_STATE_MASK (0x0Fu << DEVICE_STATE_SHIFT) /**< Device state bitmask. */
#define DEVICE_STATE_LINK (0x00u << DEVICE_STATE_SHIFT) /**< Device is in link state. */
#define DEVICE_STATE_AUTHENTICATE (0x01u << DEVICE_STATE_SHIFT) /**< Device is in authenticate state. */
#define DEVICE_STATE_TRANSPORT (0x02u << DEVICE_STATE_SHIFT) /**< Device is in transport state. */
#define DEVICE_STATE_BUSY (0x03u << DEVICE_STATE_SHIFT) /**< Device is in busy state. */
#define DEVICE_DESCRIPTOR_OFFSET_0 0x04u /**< Beacon ANT-FS device descriptor LSB position. */
#define DEVICE_DESCRIPTOR_OFFSET_1 0x05u /**< Beacon ANT-FS device descriptor LSB + 1 position. */
#define DEVICE_DESCRIPTOR_OFFSET_2 0x06u /**< Beacon ANT-FS device descriptor LSB + 2 position. */
#define DEVICE_DESCRIPTOR_OFFSET_3 0x07u /**< Beacon ANT-FS device descriptor MSB position. */
// Commands.
#define ANTFS_CMD_NONE 0x00u /**< Used to identify that no ANT-FS command is in progress. */
#define ANTFS_CMD_LINK_ID 0x02u /**< ANT-FS link command ID. */
#define ANTFS_CMD_DISCONNECT_ID 0x03u /**< ANT-FS disconnect command ID. */
#define ANTFS_CMD_AUTHENTICATE_ID 0x04u /**< ANT-FS authenticate command ID. */
#define ANTFS_CMD_PING_ID 0x05u /**< ANT-FS ping command ID. */
#define ANTFS_CMD_DOWNLOAD_ID 0x09u /**< ANT-FS download request command ID. */
#define ANTFS_CMD_UPLOAD_REQUEST_ID 0x0Au /**< ANT-FS upload request command ID. */
#define ANTFS_CMD_ERASE_ID 0x0Bu /**< ANT-FS erase request command ID. */
#define ANTFS_CMD_UPLOAD_DATA_ID 0x0Cu /**< ANT-FS upload command ID. */
// Responses.
#define ANTFS_RSP_AUTHENTICATE_ID 0x84u /**< ANT-FS authenticate response command ID. */
#define ANTFS_RSP_DOWNLOAD_ID 0x89u /**< ANT-FS download request response command ID. */
#define ANTFS_RSP_UPLOAD_REQ_ID 0x8Au /**< ANT-FS upload request response command ID. */
#define ANTFS_RSP_ERASE_ID 0x8Bu /**< ANT-FS erase response command ID. */
#define ANTFS_RSP_UPLOAD_DATA_ID 0x8Cu /**< ANT-FS upload data response command ID. */
// Link command.
#define TRANSPORT_CHANNEL_FREQUENCY_OFFSET 0x02u /**< Channel frequency field offset within link command. */
#define TRANSPORT_MESSAGE_PERIOD_OFFSET 0x03u /**< Channel period field offset within link command. */
#define HOST_ID_OFFSET_0 0x04u /**< Host serial number period field LSB offset within link command. */
#define HOST_ID_OFFSET_1 0x05u /**< Host serial number period field LSB + 1 offset within link command. */
#define HOST_ID_OFFSET_2 0x06u /**< Host serial number period field LSB + 2 offset within link command. */
#define HOST_ID_OFFSET_3 0x07u /**< Host serial number period field MSB offset within link command. */
// Authenticate command.
#define COMMAND_TYPE_OFFSET 0x02u /**< Command type field offset within authenticate command. */
#define COMMAND_TYPE_PROCEED 0x00u /**< Command type proceed to transport in the authenticate command. */
#define COMMAND_TYPE_REQUEST_SERIAL 0x01u /**< Command type request client device serial number in the authenticate command. */
#define COMMAND_TYPE_REQUEST_PAIR 0x02u /**< Command type request pairing in the authenticate command. */
#define COMMAND_TYPE_REQUEST_PASSKEY 0x03u /**< Command type request passkey exchange in the authenticate command. */
// Authenticate response.
#define RESPONSE_TYPE_OFFSET 0x02u /**< Command type field offset within authenticate response command. */
#define AUTH_RESPONSE_N_A 0x00u /**< Command response type N/A (response for client serial number request). */
#define AUTH_RESPONSE_ACCEPT 0x01u /**< Command response type accept. */
#define AUTH_RESPONSE_REJECT 0x02u /**< Command response type reject. */
// Authenticate command/response.
#define AUTH_STRING_LENGTH_OFFSET 0x03u /**< Authenticate Command/Response authentication string length offset. */
#define SERIAL_NUMBER_OFFSET_0 0x04u /**< Authenticate Command/Response client/host serial number LSB offset. */
#define SERIAL_NUMBER_OFFSET_1 0x05u /**< Authenticate Command/Response client/host serial number LSB + 1 offset. */
#define SERIAL_NUMBER_OFFSET_2 0x06u /**< Authenticate Command/Response client/host serial number LSB + 2 offset. */
#define SERIAL_NUMBER_OFFSET_3 0x07u /**< Authenticate Command/Response client/host serial number MSB offset. */
// Download/Upload/Erase commands.
#define INITIAL_REQUEST_OFFSET 0x01u /**< Download/Upload/Erase command initial request command offset. */
#define DATA_INDEX_OFFSET_LOW 0x02u /**< Download/Upload/Erase command offset index low. */
#define DATA_INDEX_OFFSET_HIGH 0x03u /**< Download/Upload/Erase command offset index high. */
#define ADDRESS_PARAMETER_OFFSET_0 0x04u /**< Download/Upload command parameter LSB offset. */
#define ADDRESS_PARAMETER_OFFSET_1 0x05u /**< Download/Upload command parameter LSB + 1 offset. */
#define ADDRESS_PARAMETER_OFFSET_2 0x06u /**< Download/Upload command parameter LSB + 2 offset. */
#define ADDRESS_PARAMETER_OFFSET_3 0x07u /**< Download/Upload command parameter MSB offset. */
#define UPLOAD_CRC_OFFSET_LOW 0x06u /**< Upload data CRC offset low. */
#define UPLOAD_CRC_OFFSET_HIGH 0x07u /**< Upload data CRC offset high. */
// Authentication type. The highest level of authentication available is included in the beacon.
#if ANTFS_CONFIG_AUTH_TYPE_PASSKEY_ENABLED
#define AUTHENTICATION_TYPE COMMAND_TYPE_REQUEST_PASSKEY /**< Passkey and pairing only mode set as authentication type in beacon. */
#elif ANTFS_CONFIG_AUTH_TYPE_PAIRING_ENABLED
#define AUTHENTICATION_TYPE COMMAND_TYPE_REQUEST_PAIR /**< Pairing only mode set as authentication type in beacon. */
#elif ANTFS_CONFIG_AUTH_TYPE_PASSTHROUGH_ENABLED
#define AUTHENTICATION_TYPE COMMAND_TYPE_PROCEED /**< Pass-through mode set as authentication type in beacon. */
#else
#error "No valid auth type defined"
#endif
#define AUTHENTICATION_RETRIES 0x05u /**< Max number of retries for authentication responses */
#define ANTFS_EVENT_QUEUE_SIZE 0x04u /**< ANT-FS event queue size. */
#define SAVE_DISTANCE 256u /**< Save distance required because of nRF buffer to line up data offset on retry. */
// Buffer Indices.
#define BUFFER_INDEX_MESG_SIZE 0x00u /**< ANT message buffer index length offset. */
#define BUFFER_INDEX_MESG_ID 0x01u /**< ANT message buffer index ID offset. */
#define BUFFER_INDEX_CHANNEL_NUM 0x02u /**< ANT message buffer index channel number offset. */
#define BUFFER_INDEX_MESG_DATA 0x03u /**< ANT message buffer index begin of data offset. */
#define BUFFER_INDEX_RESPONSE_CODE 0x04u /**< ANT message buffer index response code offset. */
typedef struct
{
char friendly_name[ANTFS_FRIENDLY_NAME_MAX]; /**< Friendly Name. */
bool is_name_set; /**< Is the name set. */
uint32_t index; /**< Current index (for reading the friendly name). */
uint32_t friendly_name_size; /**< Friendly name size. */
} friendly_name_t;
typedef union
{
antfs_link_substate_t link_sub_state; /**< Sub-state (Link layer). */
antfs_authenticate_substate_t auth_sub_state; /**< Sub-state (Authentication layer). */
antfs_transport_substate_t trans_sub_state; /**< Sub-state (Transport layer). */
} antfs_substate_t;
typedef struct
{
antfs_state_t state; /**< ANT-FS state. */
antfs_substate_t sub_state; /**< ANT-FS sub-state. */
} antfs_states_t;
typedef struct
{
antfs_event_return_t * p_queue; /**< ANT-FS event queue. */
uint32_t head; /**< ANT-FS event queue head index. */
uint32_t tail; /**< ANT-FS event queue tail index. */
} antfs_event_queue_t;
static antfs_params_t m_initial_parameters; /**< Initial parameters. */
static antfs_beacon_status_byte1_t m_active_beacon_status1_field; /**< Status 1 field in beacon. */
static uint32_t m_active_beacon_frequency; /**< Active beacon frequency. */
static antfs_states_t m_current_state; /**< Current state. */
static friendly_name_t m_friendly_name; /**< Host's friendly name. */
static ulong_union_t m_link_host_serial_number; /**< Host's serial number. */
static uint32_t m_link_command_in_progress; /**< ANT-FS command in progress. */
static uint32_t m_authenticate_command_type; /**< Authenticate command type in progress. */
static volatile uint8_t m_burst_wait; /**< Polling status flag for data unlock on burst handler input. */
static uint8_t m_retry; /**< Retry counter */
APP_TIMER_DEF(m_timer_id); /**< Timer ID used with the timer module. */
#if ANTFS_CONFIG_AUTH_TYPE_PASSKEY_ENABLED
static uint32_t m_passkey_index; /**< Current location of Tx block (auth string). */
#endif // ANTFS_CONFIG_AUTH_TYPE_PASSKEY_ENABLED
// Download/upload.
static bool m_is_data_request_pending; /**< Requested data pending. */
static bool m_is_crc_pending; /**< CRC for data packets pending. */
static ushort_union_t m_file_index; /**< File index of current upload/download. */
static ulong_union_t m_file_size; /**< File size of current upload/download (bytes). */
static ulong_union_t m_max_block_size; /**< Maximum number of bytes expected to be downloaded in a single burst block of data (set by host). */
static ulong_union_t m_link_burst_index; /**< Current location of Tx block (bytes). */
static ulong_union_t m_bytes_remaining; /**< Total remaining data length (bytes). */
static ulong_union_t m_max_transfer_index; /**< Upper limit of the current Tx burst block (bytes). */
static uint32_t m_bytes_to_write; /**< Number of bytes to write to file (upload). */
static const uint8_t * mp_upload_data; /**< Address of begin of the buffer that holds data received from upload. */
#if ANTFS_CONFIG_UPLOAD_ENABLED
static ulong_union_t m_block_size; /**< Number of bytes the client can receive in a single burst. */
#endif // ANTFS_CONFIG_UPLOAD_ENABLED
// CRC verification.
static uint32_t m_saved_crc_offset; /**< CRC data offset (bytes) saved at last CRC update (save point). */
static uint32_t m_saved_buffer_crc_offset; /**< Data offset to track how much data has been buffered into nRF */
static uint32_t m_temp_crc_offset; /**< Temporary CRC data offset used in CRC calculation. */
static uint16_t m_compared_crc; /**< 16-bit CRC for all data packets in the block (provided by download request). */
static uint16_t m_transfer_crc; /**< 16-bit CRC for all data packets in the block (calculated by client). */
static uint16_t m_saved_transfer_crc; /**< 16-bit CRC saved at last CRC update (save point). */
static uint16_t m_saved_buffer_crc; /**< 16-bit CRC saved at last CRC update (save point) for buffering the nRF */
// ANT-FS event handling.
static antfs_event_return_t m_event_queue_buffer[ANTFS_EVENT_QUEUE_SIZE]; /**< Event queue storage. */
static antfs_event_queue_t m_event_queue; /**< Event queue. */
static antfs_burst_wait_handler_t m_burst_wait_handler = NULL; /**< Burst wait handler */
const char * antfs_hostname_get(void)
{
if (m_friendly_name.is_name_set)
{
return (m_friendly_name.friendly_name);
}
return NULL;
}
/**@brief Function for waiting for the burst transmission request to complete.
*/
static void wait_burst_request_to_complete(void)
{
while (m_burst_wait != 0)
{
if (m_burst_wait_handler != NULL)
{
m_burst_wait_handler();
}
};
}
/**@brief Function for stopping ANT-FS timeout, which is possibly currently running.
*/
static void timeout_disable(void)
{
m_link_command_in_progress = ANTFS_CMD_NONE;
const uint32_t err_code = app_timer_stop(m_timer_id);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for transmitting a beacon.
*
* Transmits a beacon either using a broadcast or burst transmission mode.
*
* @param[in] message_type Defines the used transmission mode.
*/
static void beacon_transmit(uint32_t message_type)
{
uint8_t beacon_status_byte2;
// Set beacon status byte 2.
if (m_link_command_in_progress == ANTFS_CMD_NONE)
{
switch (m_current_state.state)
{
case ANTFS_STATE_AUTH:
beacon_status_byte2 = DEVICE_STATE_AUTHENTICATE;
break;
case ANTFS_STATE_TRANS:
beacon_status_byte2 = DEVICE_STATE_TRANSPORT;
break;
default:
beacon_status_byte2 = DEVICE_STATE_LINK;
break;
}
}
else
{
beacon_status_byte2 = DEVICE_STATE_BUSY;
}
// Set remaining beacon fields.
uint8_t tx_buffer[BURST_PACKET_SIZE];
tx_buffer[0] = ANTFS_BEACON_ID;
tx_buffer[1] = m_active_beacon_status1_field.status;
tx_buffer[2] = beacon_status_byte2;
tx_buffer[3] = AUTHENTICATION_TYPE;
if ((m_current_state.state == ANTFS_STATE_AUTH) ||
(m_current_state.state == ANTFS_STATE_TRANS))
{
tx_buffer[4] = m_link_host_serial_number.bytes.byte0;
tx_buffer[5] = m_link_host_serial_number.bytes.byte1;
tx_buffer[6] = m_link_host_serial_number.bytes.byte2;
tx_buffer[7] = m_link_host_serial_number.bytes.byte3;
}
else
{
tx_buffer[4] = m_initial_parameters.beacon_device_type;
tx_buffer[5] = (m_initial_parameters.beacon_device_type >> 8u);
tx_buffer[6] = m_initial_parameters.beacon_device_manufacturing_id;
tx_buffer[7] = (m_initial_parameters.beacon_device_manufacturing_id >> 8u);
}
if (message_type == MESG_BROADCAST_DATA_ID)
{
if (sd_ant_broadcast_message_tx(ANTFS_CONFIG_CHANNEL_NUMBER, sizeof(tx_buffer), tx_buffer) != NRF_SUCCESS)
{
// @note: No implementation needed, as it is a valid and accepted use case for this call
// to fail. This call can fail if we are in middle of bursting.
}
}
else if (message_type == MESG_BURST_DATA_ID)
{
// Send as the first packet of a burst.
const uint32_t err_code = sd_ant_burst_handler_request(ANTFS_CONFIG_CHANNEL_NUMBER,
sizeof(tx_buffer),
tx_buffer,
BURST_SEGMENT_START);
APP_ERROR_CHECK(err_code);
wait_burst_request_to_complete();
// This is the first packet of a burst response, disable command timeout while bursting.
timeout_disable();
}
else
{
// This should not happen.
APP_ERROR_HANDLER(message_type);
}
}
/**@brief Function for transmitting a authenticate response message.
*
* @param[in] response_type Authenticate response code.
* @param[in] password_length Length of authentication string.
* @param[in] p_password Authentication string transmitted.
*/
static void authenticate_response_transmit(uint8_t response_type,
uint32_t password_length,
const uint8_t * p_password)
{
ulong_union_t serial_number;
serial_number.data = m_initial_parameters.client_serial_number;
// First packet is beacon.
beacon_transmit(MESG_BURST_DATA_ID);
uint8_t tx_buffer[BURST_PACKET_SIZE];
tx_buffer[ANTFS_CONNECTION_TYPE_OFFSET] = ANTFS_COMMAND_ID;
tx_buffer[ANTFS_RESPONSE_OFFSET] = ANTFS_RSP_AUTHENTICATE_ID;
tx_buffer[RESPONSE_TYPE_OFFSET] = response_type;
tx_buffer[AUTH_STRING_LENGTH_OFFSET] = password_length;
tx_buffer[SERIAL_NUMBER_OFFSET_0] = serial_number.bytes.byte0;
tx_buffer[SERIAL_NUMBER_OFFSET_1] = serial_number.bytes.byte1;
tx_buffer[SERIAL_NUMBER_OFFSET_2] = serial_number.bytes.byte2;
tx_buffer[SERIAL_NUMBER_OFFSET_3] = serial_number.bytes.byte3;
uint32_t err_code;
if ((m_current_state.state == ANTFS_STATE_AUTH) &&
(
(response_type != AUTH_RESPONSE_REJECT) &&
password_length &&
(password_length <= ANTFS_AUTH_STRING_MAX)
)
)
{
// Send second packet (auth response).
err_code = sd_ant_burst_handler_request(ANTFS_CONFIG_CHANNEL_NUMBER,
sizeof(tx_buffer),
tx_buffer,
BURST_SEGMENT_CONTINUE);
APP_ERROR_CHECK(err_code);
wait_burst_request_to_complete();
// Round size to a multiple of 8 bytes.
uint8_t tx_buffer_authenticate[ANTFS_AUTH_STRING_MAX + 1u];
memset(tx_buffer_authenticate, 0, ANTFS_AUTH_STRING_MAX + 1u);
memcpy(tx_buffer_authenticate, p_password, password_length);
// Round up total number bytes to a multiple of 8 to be sent to burst handler.
if (password_length & (BURST_PACKET_SIZE - 1u))
{
password_length &= ~(BURST_PACKET_SIZE - 1u);
password_length += BURST_PACKET_SIZE;
}
// Send auth string (last packets of the burst).
err_code = sd_ant_burst_handler_request(ANTFS_CONFIG_CHANNEL_NUMBER,
password_length,
tx_buffer_authenticate,
BURST_SEGMENT_END);
APP_ERROR_CHECK(err_code);
wait_burst_request_to_complete();
m_link_command_in_progress = ANTFS_RSP_AUTHENTICATE_ID;
}
else
{
// If the authorization is rejected or there is no valid password, the auth response is the
// last packet.
err_code = sd_ant_burst_handler_request(ANTFS_CONFIG_CHANNEL_NUMBER,
sizeof(tx_buffer),
tx_buffer,
BURST_SEGMENT_END);
APP_ERROR_CHECK(err_code);
wait_burst_request_to_complete();
}
// Switch to appropiate state.
if (response_type == AUTH_RESPONSE_REJECT)
{
m_current_state.sub_state.auth_sub_state = ANTFS_AUTH_SUBSTATE_REJECT;
}
else if (response_type == AUTH_RESPONSE_ACCEPT)
{
m_current_state.sub_state.auth_sub_state = ANTFS_AUTH_SUBSTATE_ACCEPT;
}
else
{
// No implementation needed.
}
}
bool antfs_pairing_resp_transmit(bool accept)
{
#if ANTFS_CONFIG_AUTH_TYPE_PAIRING_ENABLED
// This function should only be called when ANT-FS is in PAIRING mode.
if ((m_current_state.state != ANTFS_STATE_AUTH) ||
(m_current_state.sub_state.auth_sub_state != ANTFS_AUTH_SUBSTATE_PAIR))
{
return false;
}
m_link_command_in_progress = ANTFS_CMD_AUTHENTICATE_ID;
if (accept)
{
// Accept request and send passkey if authentication passed.
authenticate_response_transmit(AUTH_RESPONSE_ACCEPT,
ANTFS_PASSKEY_SIZE,
m_initial_parameters.p_pass_key);
}
else
{
// Reject authentication request.
authenticate_response_transmit(AUTH_RESPONSE_REJECT, 0, NULL);
}
return true;
#else
return false;
#endif // ANTFS_CONFIG_AUTH_TYPE_PAIRING_ENABLED
}
/**@brief Function for adding an ANT-FS event to the event queue.
*
* @param[in] event_code The event to be added.
*/
static void event_queue_write(antfs_event_t event_code)
{
antfs_event_return_t * p_event = NULL;
#if ANTFS_CONFIG_DEBUG_LED_ENABLED
uint32_t err_code;
#endif // ANTFS_CONFIG_DEBUG_LED_ENABLED
// Check if there is room in the queue for a new event.
if (((m_event_queue.head + 1u) & (ANTFS_EVENT_QUEUE_SIZE - 1u)) != m_event_queue.tail)
{
p_event = &(m_event_queue.p_queue[m_event_queue.head]);
}
if (p_event != NULL)
{
// Initialize event parameters.
p_event->event = event_code;
// Set parameters depending on event type.
switch (event_code)
{
case ANTFS_EVENT_ERASE_REQUEST:
p_event->file_index = m_file_index.data;
p_event->offset = 0;
p_event->bytes = 0;
p_event->crc = 0;
break;
case ANTFS_EVENT_DOWNLOAD_REQUEST:
p_event->file_index = m_file_index.data;
// Requested offset for the download.
p_event->offset = m_link_burst_index.data;
p_event->bytes = 0;
p_event->crc = 0;
break;
case ANTFS_EVENT_DOWNLOAD_REQUEST_DATA:
p_event->file_index = m_file_index.data;
// Current offset.
p_event->offset = m_link_burst_index.data;
if (m_bytes_remaining.data > (ANTFS_BURST_BLOCK_SIZE * BURST_PACKET_SIZE))
{
// If remaining bytes > burst block size then grab one block at a time.
p_event->bytes = ANTFS_BURST_BLOCK_SIZE * BURST_PACKET_SIZE;
}
else
{
p_event->bytes = m_bytes_remaining.data;
}
p_event->crc = 0;
break;
case ANTFS_EVENT_UPLOAD_REQUEST:
p_event->file_index = m_file_index.data;
// Requested offset for the upload.
p_event->offset = m_link_burst_index.data;
// Upper limit of the download (offset + remaining bytes).
p_event->bytes = m_max_transfer_index.data;
// CRC Seed (from last save point if resuming).
p_event->crc = m_transfer_crc;
break;
case ANTFS_EVENT_UPLOAD_DATA:
p_event->file_index = m_file_index.data;
// Current offset.
p_event->offset = m_link_burst_index.data;
// Current CRC.
p_event->crc = m_transfer_crc;
// Number of bytes to write.
p_event->bytes = m_bytes_to_write;
// Upload to appication data buffer.
memcpy(p_event->data, mp_upload_data, m_bytes_to_write);
break;
case ANTFS_EVENT_PAIRING_REQUEST:
#if ANTFS_CONFIG_DEBUG_LED_ENABLED
err_code = bsp_indication_set(BSP_INDICATE_BONDING);
APP_ERROR_CHECK(err_code);
#endif // ANTFS_CONFIG_DEBUG_LED_ENABLED
break;
default:
// No parameters need to be set.
p_event->file_index = 0;
p_event->offset = 0;
p_event->bytes = 0;
p_event->crc = 0;
break;
}
// Put the event in the queue.
m_event_queue.head = ((m_event_queue.head + 1u) & (ANTFS_EVENT_QUEUE_SIZE - 1u));
}
else
{
// No free space left in the queue.
APP_ERROR_HANDLER(0);
}
}
/**@brief Function for transmitting download request response message.
*
* @param[in] response Download response code.
*/
static void download_request_response_transmit(uint8_t response)
{
// First burst packet is beacon.
beacon_transmit(MESG_BURST_DATA_ID);
uint8_t tx_buffer[BURST_PACKET_SIZE];
// Next send the first part of the download response.
tx_buffer[0] = ANTFS_COMMAND_ID;
tx_buffer[1] = ANTFS_RSP_DOWNLOAD_ID;
tx_buffer[2] = response;
tx_buffer[3] = 0;
// Total number of bytes remaining in the data block.
tx_buffer[4] = m_bytes_remaining.bytes.byte0;
tx_buffer[5] = m_bytes_remaining.bytes.byte1;
tx_buffer[6] = m_bytes_remaining.bytes.byte2;
tx_buffer[7] = m_bytes_remaining.bytes.byte3;
uint32_t err_code = sd_ant_burst_handler_request(ANTFS_CONFIG_CHANNEL_NUMBER,
sizeof(tx_buffer),
tx_buffer,
BURST_SEGMENT_CONTINUE);
APP_ERROR_CHECK(err_code);
wait_burst_request_to_complete();
// Second part of the download response.
// The offset the data will start from in this block.
tx_buffer[0] = m_link_burst_index.bytes.byte0;
tx_buffer[1] = m_link_burst_index.bytes.byte1;
tx_buffer[2] = m_link_burst_index.bytes.byte2;
tx_buffer[3] = m_link_burst_index.bytes.byte3;
// The file size in the client device.
tx_buffer[4] = m_file_size.bytes.byte0;
tx_buffer[5] = m_file_size.bytes.byte1;
tx_buffer[6] = m_file_size.bytes.byte2;
tx_buffer[7] = m_file_size.bytes.byte3;
if (response || (m_bytes_remaining.data == 0))
{
// If the download was rejected or there is no data to send.
// Set response to end since we're not downloading any data.
err_code = sd_ant_burst_handler_request(ANTFS_CONFIG_CHANNEL_NUMBER,
sizeof(tx_buffer),
tx_buffer,
BURST_SEGMENT_END);
APP_ERROR_CHECK(err_code);
wait_burst_request_to_complete();
}
else
{
// Response will continue (data packets + CRC footer to follow).
err_code = sd_ant_burst_handler_request(ANTFS_CONFIG_CHANNEL_NUMBER,
sizeof(tx_buffer),
tx_buffer,
BURST_SEGMENT_CONTINUE);
APP_ERROR_CHECK(err_code);
wait_burst_request_to_complete();
}
m_link_command_in_progress = ANTFS_CMD_DOWNLOAD_ID;
if (response == 0)
{
// If we are going to download (response OK), enter the downloading substate.
m_current_state.sub_state.trans_sub_state = ANTFS_TRANS_SUBSTATE_DOWNLOADING;
event_queue_write(ANTFS_EVENT_DOWNLOAD_START);
}
else
{
// Download rejected.
event_queue_write(ANTFS_EVENT_DOWNLOAD_FAIL);
}
}
void antfs_download_req_resp_prepare(uint8_t response,
const antfs_request_info_t * const p_request_info)
{
// This function should only be called after receiving a download request.
APP_ERROR_CHECK_BOOL((m_current_state.state == ANTFS_STATE_TRANS) &&
(m_link_command_in_progress == ANTFS_CMD_DOWNLOAD_ID));
if (response == 0)
{
// Download request OK.
// File size of the requested download.
m_file_size.data = p_request_info->file_size.data;
if (m_link_burst_index.data > m_file_size.data)
{
// Offset should not exceed file size.
m_link_burst_index.data = m_file_size.data;
}
// If the host is not limiting download size or the file size does not exceed the host's
// download size limit.
if ((m_max_block_size.data == 0) || (m_file_size.data < m_max_block_size.data))
{
// Number of bytes remaining to be downloaded in this block is the file size.
m_bytes_remaining.data = m_file_size.data;
}
if ((m_file_size.data - m_link_burst_index.data) < m_bytes_remaining.data)
{
// Calculate number of remaining bytes in this block based on the offset.
m_bytes_remaining.data = m_file_size.data - m_link_burst_index.data;
}
// If the application is limiting the Tx block size.
if (m_bytes_remaining.data > p_request_info->max_burst_block_size.data)
{
// Number of remaining bytes in this block is the application defined block size.
m_bytes_remaining.data = p_request_info->max_burst_block_size.data;
}
// Find upper limit of the burst Tx.
m_max_transfer_index.data = m_link_burst_index.data + m_bytes_remaining.data;
if (m_saved_crc_offset == ANTFS_MAX_FILE_SIZE)
{
// CRC checking was set as invalid. An invalid download was requested, so reject it.
response = RESPONSE_INVALID_OPERATION;
}
}
if ((response != 0) || (m_file_size.data == 0))
{
// Send the response right away if the download request was rejected or there is no data to
// send.
download_request_response_transmit(response);
}
else
{
// Proceed to download data.
if (m_link_burst_index.data != m_saved_crc_offset)
{
uint32_t temp;
// If requesting to resume exactly where we left off, we can start from the same block.
if (m_link_burst_index.data == m_temp_crc_offset)
{
// Move last save point to end of last block sent.
m_saved_crc_offset = m_link_burst_index.data;
m_saved_transfer_crc = m_transfer_crc;
}
// To resume the download, request a block of data starting from the last save point.
// Update the remaining number of bytes per the last save point.
m_bytes_remaining.data += (m_link_burst_index.data - m_saved_crc_offset);
// Swap the current burst Tx index with the saved CRC index, to make sure we do not
// start updating the CRC until we get to the requested index.
temp = m_link_burst_index.data;
m_link_burst_index.data = m_saved_crc_offset;
m_saved_crc_offset = temp;
// Set CRC to previous save point, to check the CRC provided by the host.
m_transfer_crc = m_saved_transfer_crc;
}
m_temp_crc_offset = m_saved_crc_offset;
m_is_data_request_pending = true;
// Request data from application.
event_queue_write(ANTFS_EVENT_DOWNLOAD_REQUEST_DATA);
m_current_state.sub_state.trans_sub_state = ANTFS_TRANS_SUBSTATE_VERIFY_CRC;
}
}
uint32_t antfs_input_data_download(uint16_t index,
uint32_t offset,
uint32_t num_bytes,
const uint8_t * const p_message)
{
// Verify that this is the requested data.
APP_ERROR_CHECK_BOOL((offset == m_link_burst_index.data) && (index == m_file_index.data));
// If file offset is greater than the upper limit, this is not data we need.
APP_ERROR_CHECK_BOOL(offset <= m_max_transfer_index.data);
if ((m_current_state.state == ANTFS_STATE_TRANS) &&
(
(m_current_state.sub_state.trans_sub_state == ANTFS_TRANS_SUBSTATE_VERIFY_CRC) ||
// Only send data if we were processing a download request.
(m_current_state.sub_state.trans_sub_state == ANTFS_TRANS_SUBSTATE_DOWNLOADING)
)
)
{
uint32_t block_offset = 0;
if (m_current_state.sub_state.trans_sub_state == ANTFS_TRANS_SUBSTATE_VERIFY_CRC)
{
// Make sure download_request_response_transmit defaults to RESPONSE_INVALID_CRC.
uint32_t response = RESPONSE_MESSAGE_OK;
// Check CRC.
if (m_link_burst_index.data == m_saved_crc_offset)
{
// If indexes match, we can compare CRC directly.
if (m_transfer_crc != m_compared_crc)
{
response = RESPONSE_INVALID_CRC;
}
else
{
// Set up the save point
m_temp_crc_offset = m_link_burst_index.data; // Reset save point counter
m_saved_crc_offset = m_link_burst_index.data;
m_saved_buffer_crc_offset = m_link_burst_index.data;
// Set up the CRC save points
m_saved_transfer_crc = m_compared_crc;
m_saved_buffer_crc = m_compared_crc;
m_is_crc_pending = true;
}
// Start bursting beacon and the download response (3 burst packets).
download_request_response_transmit(response);
}
// If the data is in this block, advance to the requested offset
else if ((m_link_burst_index.data < m_saved_crc_offset) &&
((m_saved_crc_offset - m_link_burst_index.data) < num_bytes))
{
// Update the offset within this block for the requested transmission.
block_offset = m_saved_crc_offset - m_link_burst_index.data;
// Update the number of bytes that will actually be transmitted.
num_bytes -= block_offset;
// Update CRC calculation up to requested index.
m_transfer_crc = crc_crc16_update(m_transfer_crc, p_message, block_offset);
// Update the remaining number of bytes.
m_bytes_remaining.data -= block_offset;
// Check CRC
if (m_transfer_crc != m_compared_crc)
{
response = RESPONSE_INVALID_CRC;
}
else
{
// Move index back to point where transmission will resume.
m_link_burst_index.data = m_saved_crc_offset;
// Set up the save point
m_temp_crc_offset = m_link_burst_index.data; // Reset save point counter
m_saved_buffer_crc_offset = m_link_burst_index.data;
// Set up the CRC save points
m_saved_transfer_crc = m_compared_crc;
m_saved_buffer_crc = m_compared_crc;
m_is_crc_pending = true;
}
download_request_response_transmit(response);
}
// Data index has gone too far and it is not possible to check CRC, fail and let host retry
else if (m_link_burst_index.data > m_saved_crc_offset)
{
response = RESPONSE_INVALID_CRC;
download_request_response_transmit(response);
}
// Keep getting data and recalculate the CRC until the indexes match
else
{
m_is_data_request_pending = false;
// Update the current burst index and bytes remaining
m_link_burst_index.data += num_bytes;
m_bytes_remaining.data -= num_bytes;
// Update CRC
m_transfer_crc = crc_crc16_update(m_transfer_crc, p_message, num_bytes);
// Request more data.
event_queue_write(ANTFS_EVENT_DOWNLOAD_REQUEST_DATA);
}
}
// Append data.
if (m_current_state.sub_state.trans_sub_state == ANTFS_TRANS_SUBSTATE_DOWNLOADING)
{
uint32_t num_of_bytes_to_burst = num_bytes;
if (num_of_bytes_to_burst & (BURST_PACKET_SIZE - 1u))
{
// Round up total number bytes to a multiple of BURST_PACKET_SIZE to be sent to
// burst handler.
num_of_bytes_to_burst &= ~(BURST_PACKET_SIZE - 1u);
num_of_bytes_to_burst += BURST_PACKET_SIZE;
}
uint32_t err_code = sd_ant_burst_handler_request(ANTFS_CONFIG_CHANNEL_NUMBER,
num_of_bytes_to_burst,
(uint8_t*)&(p_message[block_offset]),
BURST_SEGMENT_CONTINUE);
if (err_code != NRF_ANT_ERROR_TRANSFER_SEQUENCE_NUMBER_ERROR)
{
// If burst failed before we are able to catch it, we will get a TRANSFER_SEQUENCE_NUMBER_ERROR
// The message processing will send client back to correct state
APP_ERROR_CHECK(err_code);
}
wait_burst_request_to_complete();
// Update current burst index.
m_link_burst_index.data += num_bytes;
// Update remaining bytes.
m_bytes_remaining.data -= num_bytes;
m_is_data_request_pending = false;
m_transfer_crc = crc_crc16_update(m_transfer_crc,
&(p_message[block_offset]),
num_bytes);
if ((m_link_burst_index.data - m_temp_crc_offset) > SAVE_DISTANCE)
{
// Set CRC save point
m_saved_transfer_crc = m_saved_buffer_crc; // Set CRC at buffer save point (will always be one behind to account for buffering)
m_saved_buffer_crc = m_transfer_crc; // Set CRC at save point
// Set offset save point
m_saved_crc_offset = m_saved_buffer_crc_offset; // Set offset at buffer save point (will always be one behind to account for buffering)
m_saved_buffer_crc_offset = m_link_burst_index.data; // Set buffer offset to current data offset
// Reset save counter offset
m_temp_crc_offset = m_link_burst_index.data; // Set to current location; next save point will take place after SAVE_DISTANCE bytes
}
if (!m_is_data_request_pending && (m_link_burst_index.data < m_max_transfer_index.data))
{
// If we have not finished the download.
// Request more data.
event_queue_write(ANTFS_EVENT_DOWNLOAD_REQUEST_DATA);
m_is_data_request_pending = true;
}
else if (m_link_burst_index.data >= m_max_transfer_index.data && m_is_crc_pending)
{
// We are done, send CRC footer.
uint8_t tx_buffer[BURST_PACKET_SIZE];
tx_buffer[0] = 0;
tx_buffer[1] = 0;
tx_buffer[2] = 0;
tx_buffer[3] = 0;
tx_buffer[4] = 0;
tx_buffer[5] = 0;
tx_buffer[6] = (uint8_t)m_transfer_crc;
tx_buffer[7] = (uint8_t)(m_transfer_crc >> 8u);
err_code = sd_ant_burst_handler_request(ANTFS_CONFIG_CHANNEL_NUMBER,
sizeof(tx_buffer),
tx_buffer,
BURST_SEGMENT_END);
if (err_code != NRF_ANT_ERROR_TRANSFER_SEQUENCE_NUMBER_ERROR)
{
// If burst failed before we are able to catch it, we will get a TRANSFER_SEQUENCE_NUMBER_ERROR
// The message processing will send client back to correct state
APP_ERROR_CHECK(err_code);
}
wait_burst_request_to_complete();
m_is_crc_pending = false;
m_max_transfer_index.data = 0;
}
// Return the number of bytes we accepted.
return num_bytes;
}
}
// No bytes were accepted.
return 0;
}
bool antfs_upload_req_resp_transmit(uint8_t response,
const antfs_request_info_t * const p_request_info)
{
#if ANTFS_CONFIG_UPLOAD_ENABLED
if (m_current_state.state != ANTFS_STATE_TRANS ||
// Only send the response if we were processing an upload request.
(m_link_command_in_progress != ANTFS_CMD_UPLOAD_REQUEST_ID))
{
return false;
}
// If the application is sending a response for a different file than requested, the upload
// will fail.
if (p_request_info->file_index.data != m_file_index.data)
{
event_queue_write(ANTFS_EVENT_UPLOAD_FAIL);
return false;
}
ulong_union_t max_mem_size;
// Set maximum number of bytes that can be written to the file.
max_mem_size.data = p_request_info->max_file_size;
if (p_request_info->max_burst_block_size.data != 0)
{
// If the client is limiting the block size set the block size requested by the client.
m_block_size.data = p_request_info->max_burst_block_size.data;
}
else
{
// Try to get the entire file in a single block.
m_block_size.data = max_mem_size.data;
}
if (response == 0)
{
if (m_max_transfer_index.data > max_mem_size.data)
{
// Not enough space to write file, reject download.
response = RESPONSE_MESSAGE_NOT_ENOUGH_SPACE;
}
}
// Get last valid CRC and last valid offset.
m_transfer_crc = p_request_info->file_crc;
m_link_burst_index.data = p_request_info->file_size.data;
// First packet to transmit is the beacon.
beacon_transmit(MESG_BURST_DATA_ID);
// Second packet.
uint8_t tx_buffer[BURST_PACKET_SIZE];
tx_buffer[0] = ANTFS_COMMAND_ID;
tx_buffer[1] = ANTFS_RSP_UPLOAD_REQ_ID;
tx_buffer[2] = response;
tx_buffer[3] = 0;
// Last valid data offset written to the file.
tx_buffer[4] = m_link_burst_index.bytes.byte0;
tx_buffer[5] = m_link_burst_index.bytes.byte1;
tx_buffer[6] = m_link_burst_index.bytes.byte2;
tx_buffer[7] = m_link_burst_index.bytes.byte3;
uint32_t err_code = sd_ant_burst_handler_request(ANTFS_CONFIG_CHANNEL_NUMBER,
sizeof(tx_buffer),
tx_buffer,
BURST_SEGMENT_CONTINUE);
APP_ERROR_CHECK(err_code);
wait_burst_request_to_complete();
// Third packet.
// Maximum number of bytes that can be written to the file.
tx_buffer[0] = max_mem_size.bytes.byte0;
tx_buffer[1] = max_mem_size.bytes.byte1;
tx_buffer[2] = max_mem_size.bytes.byte2;
tx_buffer[3] = max_mem_size.bytes.byte3;
// Maximum upload block size.
tx_buffer[4] = m_block_size.bytes.byte0;
tx_buffer[5] = m_block_size.bytes.byte1;
tx_buffer[6] = m_block_size.bytes.byte2;
tx_buffer[7] = m_block_size.bytes.byte3;
err_code = sd_ant_burst_handler_request(ANTFS_CONFIG_CHANNEL_NUMBER,
sizeof(tx_buffer),
tx_buffer,
BURST_SEGMENT_CONTINUE);
APP_ERROR_CHECK(err_code);
wait_burst_request_to_complete();
// Fourth packet.
tx_buffer[0] = 0;
tx_buffer[1] = 0;
tx_buffer[2] = 0;
tx_buffer[3] = 0;
tx_buffer[4] = 0;
tx_buffer[5] = 0;
// Value of CRC at last data offset.
tx_buffer[6] = (uint8_t) m_transfer_crc;
tx_buffer[7] = (uint8_t)(m_transfer_crc >> 8);
err_code = sd_ant_burst_handler_request(ANTFS_CONFIG_CHANNEL_NUMBER,
sizeof(tx_buffer),
tx_buffer,
BURST_SEGMENT_END);
APP_ERROR_CHECK(err_code);
wait_burst_request_to_complete();
m_link_command_in_progress = ANTFS_CMD_UPLOAD_REQUEST_ID;
if (response != 0)
{
// Failed upload request. Reset max transfer index to 0 (do not accept any data if the host
// sends it anyway).
m_max_transfer_index.data = 0;
}
else
{
// Wait for upload data request.
m_current_state.sub_state.trans_sub_state = ANTFS_TRANS_SUBSTATE_UPLOAD_WAIT_FOR_DATA;
}
return true;
#else
return false;
#endif // ANTFS_CONFIG_UPLOAD_ENABLED
}
bool antfs_upload_data_resp_transmit(bool data_upload_success)
{
#if ANTFS_CONFIG_UPLOAD_ENABLED
// Should be in TRANSPORT layer to send this response.
if (m_current_state.state != ANTFS_STATE_TRANS)
{
return false;
}
uint8_t tx_buffer[BURST_PACKET_SIZE];
// Response.
tx_buffer[0] = ANTFS_COMMAND_ID;
tx_buffer[1] = ANTFS_RSP_UPLOAD_DATA_ID;
tx_buffer[2] = (data_upload_success) ? RESPONSE_MESSAGE_OK : RESPONSE_MESSAGE_FAIL;
tx_buffer[3] = 0;
tx_buffer[4] = 0;
tx_buffer[5] = 0;
tx_buffer[6] = 0;
tx_buffer[7] = 0;
// First packet is beacon.
beacon_transmit(MESG_BURST_DATA_ID);
// Send last packet.
uint32_t err_code = sd_ant_burst_handler_request(ANTFS_CONFIG_CHANNEL_NUMBER,
sizeof(tx_buffer),
tx_buffer,
BURST_SEGMENT_END);
APP_ERROR_CHECK(err_code);
wait_burst_request_to_complete();
m_link_command_in_progress = ANTFS_CMD_UPLOAD_REQUEST_ID;
// Reset maximum index.
m_max_transfer_index.data = 0;
return true;
#else
return false;
#endif // ANTFS_CONFIG_UPLOAD_ENABLED
}
void antfs_erase_req_resp_transmit(uint8_t response)
{
// This function should only be called after receiving an erase request.
APP_ERROR_CHECK_BOOL((m_current_state.state == ANTFS_STATE_TRANS) &&
(m_link_command_in_progress == ANTFS_CMD_ERASE_ID));
beacon_transmit(MESG_BURST_DATA_ID);
uint8_t tx_buffer[BURST_PACKET_SIZE];
// Erase response.
tx_buffer[0] = ANTFS_COMMAND_ID;
tx_buffer[1] = ANTFS_RSP_ERASE_ID;
tx_buffer[2] = response;
tx_buffer[3] = 0;
tx_buffer[4] = 0;
tx_buffer[5] = 0;
tx_buffer[6] = 0;
tx_buffer[7] = 0;
uint32_t err_code = sd_ant_burst_handler_request(ANTFS_CONFIG_CHANNEL_NUMBER,
sizeof(tx_buffer),
tx_buffer,
BURST_SEGMENT_END);
APP_ERROR_CHECK(err_code);
wait_burst_request_to_complete();
}
bool antfs_event_extract(antfs_event_return_t * const p_event)
{
bool return_value = false;
if (m_event_queue.head != m_event_queue.tail)
{
// Pending events exist. Copy event parameters into return event.
p_event->event = m_event_queue.p_queue[m_event_queue.tail].event;
p_event->file_index = m_event_queue.p_queue[m_event_queue.tail].file_index;
p_event->offset = m_event_queue.p_queue[m_event_queue.tail].offset;
p_event->bytes = m_event_queue.p_queue[m_event_queue.tail].bytes;
p_event->crc = m_event_queue.p_queue[m_event_queue.tail].crc;
memcpy(p_event->data,
m_event_queue.p_queue[m_event_queue.tail].data,
sizeof(p_event->data));
// Release the event queue.
m_event_queue.tail = ((m_event_queue.tail + 1u) & (ANTFS_EVENT_QUEUE_SIZE - 1u));
return_value = true;
}
return return_value;
}
/**@brief Function for setting the channel period.
*
* Sets the channel period. The only allowed frequencies are 0.5, 1, 2, 4 and 8 Hz.
*
* @param[in] link_period Link period for the beacon transmission.
*/
static void channel_period_set(uint32_t link_period)
{
uint32_t period;
switch (link_period)
{
default:
// Shouldn't happen, but just in case default to 0,5Hz.
case BEACON_PERIOD_0_5_HZ:
period = 65535u;
break;
case BEACON_PERIOD_1_HZ:
period = 32768u;
break;
case BEACON_PERIOD_2_HZ:
period = 16384u;
break;
case BEACON_PERIOD_4_HZ:
period = 8192u;
break;
case BEACON_PERIOD_8_HZ:
period = 4096u;
break;
}
const uint32_t err_code = sd_ant_channel_period_set(ANTFS_CONFIG_CHANNEL_NUMBER, period);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for starting ANT-FS timeout.
*
* @param[in] timeout_in_secs Timeout requested in unit of seconds.
*/
static void timeout_start(uint32_t timeout_in_secs)
{
uint32_t err_code = app_timer_stop(m_timer_id);
APP_ERROR_CHECK(err_code);
err_code = app_timer_start(m_timer_id,
APP_TIMER_TICKS((uint32_t)(timeout_in_secs * 1000u)),
NULL);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for switching to authentication layer.
*/
static void authenticate_layer_transit(void)
{
if (m_current_state.state != ANTFS_STATE_OFF)
{
m_current_state.state = ANTFS_STATE_AUTH;
m_current_state.sub_state.auth_sub_state = ANTFS_AUTH_SUBSTATE_NONE;
m_link_command_in_progress = ANTFS_CMD_NONE;
timeout_start(ANTFS_CONFIG_LINK_COMMAND_TIMEOUT);
uint32_t err_code = sd_ant_channel_radio_freq_set(ANTFS_CONFIG_CHANNEL_NUMBER, m_active_beacon_frequency);
APP_ERROR_CHECK(err_code);
event_queue_write(ANTFS_EVENT_AUTH);
}
}
/**@brief Function for decoding an ANT-FS command received at the link layer.
*
* @param[in] p_command_buffer The ANT-FS command buffer.
*/
static void link_layer_cmd_decode(const uint8_t * p_command_buffer)
{
if (p_command_buffer[ANTFS_CONNECTION_TYPE_OFFSET] != ANTFS_COMMAND_ID)
{
return;
}
switch (p_command_buffer[ANTFS_COMMAND_OFFSET])
{
case ANTFS_CMD_LINK_ID:
// Channel frequency.
m_active_beacon_frequency =
p_command_buffer[TRANSPORT_CHANNEL_FREQUENCY_OFFSET];
// Channel message period.
m_active_beacon_status1_field.parameters.link_period =
p_command_buffer[TRANSPORT_MESSAGE_PERIOD_OFFSET];
// Host serial Number.
m_link_host_serial_number.bytes.byte0 =
p_command_buffer[HOST_ID_OFFSET_0];
m_link_host_serial_number.bytes.byte1 =
p_command_buffer[HOST_ID_OFFSET_1];
m_link_host_serial_number.bytes.byte2 =
p_command_buffer[HOST_ID_OFFSET_2];
m_link_host_serial_number.bytes.byte3 =
p_command_buffer[HOST_ID_OFFSET_3];
// Move to the channel period issued by the host.
channel_period_set(m_active_beacon_status1_field.parameters.link_period);
authenticate_layer_transit();
break;
default:
break;
}
}
/**@brief Function for switching to link layer.
*/
static void link_layer_transit(void)
{
if (m_current_state.state != ANTFS_STATE_OFF)
{
uint32_t err_code;
#if ANTFS_CONFIG_DEBUG_LED_ENABLED
err_code = bsp_indication_set(BSP_INDICATE_IDLE);
APP_ERROR_CHECK(err_code);
#endif // ANTFS_CONFIG_DEBUG_LED_ENABLED
m_current_state.state = ANTFS_STATE_LINK;
m_current_state.sub_state.link_sub_state = ANTFS_LINK_SUBSTATE_NONE;
m_link_command_in_progress = ANTFS_CMD_NONE;
m_active_beacon_status1_field = m_initial_parameters.beacon_status_byte1;
m_active_beacon_frequency = m_initial_parameters.beacon_frequency;
timeout_disable();
err_code = sd_ant_channel_radio_freq_set(ANTFS_CONFIG_CHANNEL_NUMBER, m_active_beacon_frequency);
APP_ERROR_CHECK(err_code);
event_queue_write(ANTFS_EVENT_LINK);
}
}
/**@brief Function for decoding an ANT-FS command received at the authenticate layer.
*
* @param[in] control_byte The command control byte.
* @param[in] p_command_buffer The ANT-FS command buffer.
*/
static void authenticate_layer_cmd_decode(uint8_t control_byte,
const uint8_t * p_command_buffer)
{
// @note: Response variable must have a static storage allocation as it keeps track of the
// passkey authentication progress between multiple burst packets.
#if ANTFS_CONFIG_AUTH_TYPE_PASSKEY_ENABLED
static uint32_t response;
#endif // ANTFS_CONFIG_AUTH_TYPE_PASSKEY_ENABLED
if ((control_byte & ~SEQUENCE_LAST_MESSAGE) == 0 && m_link_command_in_progress != ANTFS_CMD_NONE)
{
// This is something new, and we're busy processing something already, so don't respond
return;
}
if (p_command_buffer[ANTFS_CONNECTION_TYPE_OFFSET] == ANTFS_COMMAND_ID &&
m_link_command_in_progress == ANTFS_CMD_NONE)
{
if (p_command_buffer[ANTFS_COMMAND_OFFSET] == ANTFS_CMD_AUTHENTICATE_ID)
{
// Make sure it is the correct host
if (m_link_host_serial_number.bytes.byte0 != p_command_buffer[HOST_ID_OFFSET_0] ||
m_link_host_serial_number.bytes.byte1 != p_command_buffer[HOST_ID_OFFSET_1] ||
m_link_host_serial_number.bytes.byte2 != p_command_buffer[HOST_ID_OFFSET_2] ||
m_link_host_serial_number.bytes.byte3 != p_command_buffer[HOST_ID_OFFSET_3])
return;
m_link_command_in_progress = ANTFS_CMD_AUTHENTICATE_ID;
m_authenticate_command_type = p_command_buffer[COMMAND_TYPE_OFFSET];
m_retry = AUTHENTICATION_RETRIES;
}
}
if (m_link_command_in_progress == ANTFS_CMD_AUTHENTICATE_ID)
{
switch (m_authenticate_command_type)
{
case COMMAND_TYPE_REQUEST_SERIAL:
if (control_byte & SEQUENCE_LAST_MESSAGE)
{
// Don't do anything before the burst completes (last burst message received).
timeout_start(ANTFS_CONFIG_LINK_COMMAND_TIMEOUT);
authenticate_response_transmit(AUTH_RESPONSE_N_A,
ANTFS_REMOTE_FRIENDLY_NAME_MAX,
// Send device friendly name if it exists.
m_initial_parameters.p_remote_friendly_name);
}
break;
#if ANTFS_CONFIG_AUTH_TYPE_PASSTHROUGH_ENABLED
case COMMAND_TYPE_PROCEED:
if (control_byte & SEQUENCE_LAST_MESSAGE)
{
// Don't do anything before the burst completes (last burst message received).
timeout_start(ANTFS_CONFIG_LINK_COMMAND_TIMEOUT);
// Proceed directly to transport layer (no authentication required).
authenticate_response_transmit(AUTH_RESPONSE_ACCEPT, 0, NULL);
}
break;
#endif // ANTFS_CONFIG_AUTH_TYPE_PASSTHROUGH_ENABLED
#if ANTFS_CONFIG_AUTH_TYPE_PAIRING_ENABLED
case COMMAND_TYPE_REQUEST_PAIR:
if ((control_byte & SEQUENCE_NUMBER_ROLLOVER) == 0)
{
// First burst packet.
// Friendly name length.
m_friendly_name.friendly_name_size =
p_command_buffer[AUTH_STRING_LENGTH_OFFSET];
if (m_friendly_name.friendly_name_size > 0)
{
if (m_friendly_name.friendly_name_size > ANTFS_FRIENDLY_NAME_MAX)
{
m_friendly_name.friendly_name_size = ANTFS_FRIENDLY_NAME_MAX;
}
m_friendly_name.index = 0;
}
}
else
{
// Next burst packets: read host friendly name.
if (m_friendly_name.index < ANTFS_FRIENDLY_NAME_MAX)
{
uint32_t num_of_bytes = ANTFS_FRIENDLY_NAME_MAX - m_friendly_name.index;
if (num_of_bytes > 8u)
{
num_of_bytes = 8u;
}
memcpy((uint8_t*)&m_friendly_name.friendly_name[m_friendly_name.index],
p_command_buffer,
num_of_bytes);
m_friendly_name.index += num_of_bytes;
}
}
if (control_byte & SEQUENCE_LAST_MESSAGE)
{
// Last burst packet.
timeout_start(ANTFS_CONFIG_PAIRING_TIMEOUT);
if (m_friendly_name.friendly_name_size > 0)
{
m_friendly_name.is_name_set = true;
}
m_current_state.sub_state.auth_sub_state = ANTFS_AUTH_SUBSTATE_PAIR;
// If pairing is supported, send request to UI.
event_queue_write(ANTFS_EVENT_PAIRING_REQUEST);
}
break;
#endif // ANTFS_CONFIG_AUTH_TYPE_PAIRING_ENABLED
#if ANTFS_CONFIG_AUTH_TYPE_PASSKEY_ENABLED
case COMMAND_TYPE_REQUEST_PASSKEY:
if ((control_byte & SEQUENCE_NUMBER_ROLLOVER) == 0)
{
// First burst packet.
// Passkey length.
const uint32_t passkey_size = p_command_buffer[AUTH_STRING_LENGTH_OFFSET];
// Default the algorithm to accept.
response = AUTH_RESPONSE_ACCEPT;
// Check if the passkey length is valid.
if (passkey_size == ANTFS_PASSKEY_SIZE)
{
m_passkey_index = 0;
}
else
{
// Invalid lenght supplied - the authentication will be rejected.
response = AUTH_RESPONSE_REJECT;
}
}
else
{
// Next burst packets: read host friendly name.
if ((response == AUTH_RESPONSE_ACCEPT) &&
// Prevent buffer overrun.
(m_passkey_index != ANTFS_PASSKEY_SIZE))
{
// Passkey length was valid and the host supplied key matches so far.
uint32_t idx = 0;
// Check the current received burst packet for passkey match.
do
{
if (m_initial_parameters.p_pass_key[m_passkey_index++] !=
p_command_buffer[idx])
{
// Reject the authentication request and further processing of
// passkey matching if a mismatch is found.
response = AUTH_RESPONSE_REJECT;
break;
}
++idx;
}
while (idx < BURST_PACKET_SIZE);
}
}
if (control_byte & SEQUENCE_LAST_MESSAGE)
{
// Last burst packet.
if (m_passkey_index < ANTFS_PASSKEY_SIZE)
{
// We did not get the complete passkey, reject authentication request.
response = AUTH_RESPONSE_REJECT;
}
timeout_start(ANTFS_CONFIG_LINK_COMMAND_TIMEOUT);
m_current_state.sub_state.auth_sub_state = ANTFS_AUTH_SUBSTATE_PASSKEY;
authenticate_response_transmit(response, 0, NULL);
}
break;
#endif // ANTFS_CONFIG_AUTH_TYPE_PASSKEY_ENABLED
default:
break;
}
}
else if (p_command_buffer[ANTFS_COMMAND_OFFSET] == ANTFS_CMD_DISCONNECT_ID)
{
if (control_byte & SEQUENCE_LAST_MESSAGE)
{
// Don't do anything before the burst completes (last burst message received).
link_layer_transit();
}
}
else if (p_command_buffer[ANTFS_COMMAND_OFFSET] == ANTFS_CMD_PING_ID)
{
// Reset timeout.
timeout_start(ANTFS_CONFIG_LINK_COMMAND_TIMEOUT);
m_link_command_in_progress = ANTFS_CMD_NONE;
}
else
{
// No implementation needed.
}
}
/**@brief Function for decoding an ANT-FS command received at the transport layer.
*
* @param[in] control_byte The command control byte.
* @param[in] p_command_buffer The ANT-FS command buffer.
*/
static void transport_layer_cmd_decode(uint8_t control_byte, const uint8_t * p_command_buffer)
{
ulong_union_t host_serial_number = {0};
if (p_command_buffer[ANTFS_CONNECTION_TYPE_OFFSET] == ANTFS_COMMAND_ID)
{
m_link_command_in_progress = p_command_buffer[ANTFS_COMMAND_OFFSET];
}
switch (m_link_command_in_progress)
{
case ANTFS_CMD_PING_ID:
// Reset timeout.
timeout_start(ANTFS_CONFIG_LINK_COMMAND_TIMEOUT);
m_link_command_in_progress = ANTFS_CMD_NONE;
break;
case ANTFS_CMD_DISCONNECT_ID:
if (control_byte & SEQUENCE_LAST_MESSAGE)
{
// Don't do anything before the burst completes (last burst message received).
link_layer_transit();
}
break;
case ANTFS_CMD_ERASE_ID:
if (control_byte & SEQUENCE_LAST_MESSAGE)
{
// Don't do anything before the burst completes (last burst message received).
// Requested index.
m_file_index.bytes.low = p_command_buffer[DATA_INDEX_OFFSET_LOW];
m_file_index.bytes.high = p_command_buffer[DATA_INDEX_OFFSET_HIGH];
// Send erase request to the application.
event_queue_write(ANTFS_EVENT_ERASE_REQUEST);
timeout_start(ANTFS_CONFIG_LINK_COMMAND_TIMEOUT);
m_link_command_in_progress = ANTFS_CMD_ERASE_ID;
}
break;
case ANTFS_CMD_DOWNLOAD_ID:
if (m_current_state.sub_state.trans_sub_state != ANTFS_TRANS_SUBSTATE_NONE)
{
// Ignore the command if we are busy.
break;
}
if ((control_byte & SEQUENCE_NUMBER_MASK) == SEQUENCE_FIRST_MESSAGE)
{
// First burst packet.
if ((m_file_index.bytes.low != p_command_buffer[DATA_INDEX_OFFSET_LOW]) ||
(m_file_index.bytes.high != p_command_buffer[DATA_INDEX_OFFSET_HIGH]))
{
// This is a new index, so we can not check the CRC against the previous saved
// CRC.
// CRC seed checking is made invalid by setting the last saved offset to the
// maximum file size.
m_saved_crc_offset = ANTFS_MAX_FILE_SIZE;
}
// Requested data file index.
m_file_index.bytes.low = p_command_buffer[DATA_INDEX_OFFSET_LOW];
m_file_index.bytes.high = p_command_buffer[DATA_INDEX_OFFSET_HIGH];
// Initialize current position in the TX burst to the requested offset.
m_link_burst_index.bytes.byte0 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_0];
m_link_burst_index.bytes.byte1 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_1];
m_link_burst_index.bytes.byte2 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_2];
m_link_burst_index.bytes.byte3 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_3];
}
else if (control_byte & SEQUENCE_LAST_MESSAGE)
{
// Last burst packet (download command should be two packets long).
// Get CRC seed from host.
m_compared_crc = (uint16_t)p_command_buffer[DATA_INDEX_OFFSET_LOW];
m_compared_crc |= ((uint16_t)p_command_buffer[DATA_INDEX_OFFSET_HIGH] << 8u);
// Maximum block size allowed by host.
m_max_block_size.bytes.byte0 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_0];
m_max_block_size.bytes.byte1 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_1];
m_max_block_size.bytes.byte2 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_2];
m_max_block_size.bytes.byte3 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_3];
// Initialize number of remaining bytes for this block to the maximum block size.
m_bytes_remaining.data = m_max_block_size.data;
if (p_command_buffer[INITIAL_REQUEST_OFFSET])
{
// This request is the start of a new transfer.
// Initialize data offset for CRC calculation to the requested data offset.
m_saved_crc_offset = m_link_burst_index.data;
m_saved_buffer_crc_offset = m_link_burst_index.data;
// Use CRC seed provided by host for CRC checking of the data.
m_transfer_crc = m_compared_crc;
m_saved_transfer_crc = m_compared_crc;
m_saved_buffer_crc = m_compared_crc;
m_current_state.sub_state.trans_sub_state = ANTFS_TRANS_SUBSTATE_VERIFY_CRC;
}
else
{
// This is a request to resume a partially completed transfer.
if (m_saved_crc_offset > m_link_burst_index.data)
{
// We can not check the received CRC seed as the requested offset is before
// our last save point.
// Set CRC checking as invalid.
m_saved_crc_offset = ANTFS_MAX_FILE_SIZE;
}
else
{
m_current_state.sub_state.trans_sub_state = ANTFS_TRANS_SUBSTATE_VERIFY_CRC;
}
}
m_is_data_request_pending = false;
// Send download request to the application for further handling.
event_queue_write(ANTFS_EVENT_DOWNLOAD_REQUEST);
timeout_start(ANTFS_CONFIG_LINK_COMMAND_TIMEOUT);
m_link_command_in_progress = ANTFS_CMD_DOWNLOAD_ID;
}
break;
case ANTFS_CMD_UPLOAD_REQUEST_ID:
#if ANTFS_CONFIG_UPLOAD_ENABLED
if ((control_byte & ~SEQUENCE_LAST_MESSAGE) == 0x00)
{
// First burst packet.
if ((m_file_index.bytes.low != p_command_buffer[DATA_INDEX_OFFSET_LOW]) ||
(
(m_file_index.bytes.high != p_command_buffer[DATA_INDEX_OFFSET_HIGH]) ||
(m_current_state.sub_state.trans_sub_state == ANTFS_TRANS_SUBSTATE_NONE)
)
)
{
// If it is a new index or we completed the last upload.
// Get the file index.
m_file_index.bytes.low = p_command_buffer[DATA_INDEX_OFFSET_LOW];
m_file_index.bytes.high = p_command_buffer[DATA_INDEX_OFFSET_HIGH];
// As this is a new upload, reset save point to the beginning of the file.
// Set CRC to zero.
m_saved_crc_offset = 0;
m_saved_transfer_crc = 0;
}
// Get the upper limit of upload from request message.
m_max_transfer_index.bytes.byte0 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_0];
m_max_transfer_index.bytes.byte1 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_1];
m_max_transfer_index.bytes.byte2 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_2];
m_max_transfer_index.bytes.byte3 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_3];
}
else if (control_byte & SEQUENCE_LAST_MESSAGE)
{
// Last burst (second) packet.
// Get data offset the requested upload will start at.
m_link_burst_index.bytes.byte0 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_0];
m_link_burst_index.bytes.byte1 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_1];
m_link_burst_index.bytes.byte2 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_2];
m_link_burst_index.bytes.byte3 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_3];
if (m_link_burst_index.data != ANTFS_MAX_FILE_SIZE)
{
// If this is a new upload.
// The data offset specified in the upload request will be used.
m_saved_crc_offset = m_link_burst_index.data;
m_saved_transfer_crc = 0;
}
m_transfer_crc = m_saved_transfer_crc;
// Send upload request to the application for further handling.
event_queue_write(ANTFS_EVENT_UPLOAD_REQUEST);
timeout_start(ANTFS_CONFIG_LINK_COMMAND_TIMEOUT);
m_link_command_in_progress = ANTFS_CMD_UPLOAD_REQUEST_ID;
}
#endif // ANTFS_CONFIG_UPLOAD_ENABLED
break;
case ANTFS_CMD_UPLOAD_DATA_ID:
#if ANTFS_CONFIG_UPLOAD_ENABLED
if ((control_byte & ~SEQUENCE_LAST_MESSAGE) == 0x00)
{
// First burst packet.
if (m_current_state.sub_state.trans_sub_state ==
ANTFS_TRANS_SUBSTATE_UPLOAD_WAIT_FOR_DATA)
{
antfs_event_t event;
// Get CRC Seed from host.
m_compared_crc = (uint16_t)p_command_buffer[DATA_INDEX_OFFSET_LOW];
m_compared_crc |= ((uint16_t)p_command_buffer[DATA_INDEX_OFFSET_HIGH] << 8u);
// Set download offset.
m_link_burst_index.bytes.byte0 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_0];
m_link_burst_index.bytes.byte1 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_1];
m_link_burst_index.bytes.byte2 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_2];
m_link_burst_index.bytes.byte3 = p_command_buffer[ADDRESS_PARAMETER_OFFSET_3];
if ((m_link_burst_index.data + m_block_size.data) < m_max_transfer_index.data)
{
// Adjust block size as set by client.
m_max_transfer_index.data = m_link_burst_index.data + m_block_size.data;
}
if (m_compared_crc != m_transfer_crc)
{
// Check that the request matches the CRC sent on the upload response.
// Do not accept any data.
m_max_transfer_index.data = 0;
// Failure will be reported when upload is done.
event = (antfs_event_t)0;
}
// Set ready to receive a file.
m_current_state.sub_state.trans_sub_state = ANTFS_TRANS_SUBSTATE_UPLOADING;
event = ANTFS_EVENT_UPLOAD_START;
m_transfer_crc = m_compared_crc;
if (m_link_burst_index.data > m_max_transfer_index.data)
{
// If the requested offset is too high.
// Clear the max transfer index, so we'll report fail when the transfer
// finishes.
m_max_transfer_index.data = 0;
// Clear the event because we normally would not send an event at this point
// in this case.
event = (antfs_event_t)0;
}
if (control_byte & SEQUENCE_LAST_MESSAGE)
{
// If this upload contains no data.
// Leave the upload state.
m_current_state.sub_state.trans_sub_state = ANTFS_TRANS_SUBSTATE_NONE;
// if it was a valid index, report it as a successful upload, otherwise
// report it as a failure.
if (event == 0)
{
event = ANTFS_EVENT_UPLOAD_FAIL;
}
else
{
event = ANTFS_EVENT_UPLOAD_COMPLETE;
}
}
if (event != 0)
{
event_queue_write(event);
}
}
}
#endif // ANTFS_CONFIG_UPLOAD_ENABLED
break;
case ANTFS_CMD_LINK_ID:
host_serial_number.bytes.byte0 = p_command_buffer[HOST_ID_OFFSET_0];
host_serial_number.bytes.byte1 = p_command_buffer[HOST_ID_OFFSET_1];
host_serial_number.bytes.byte2 = p_command_buffer[HOST_ID_OFFSET_2];
host_serial_number.bytes.byte3 = p_command_buffer[HOST_ID_OFFSET_3];
if (m_link_host_serial_number.data == host_serial_number.data)
{
m_active_beacon_frequency = p_command_buffer[TRANSPORT_CHANNEL_FREQUENCY_OFFSET];
m_active_beacon_status1_field.parameters.link_period =
p_command_buffer[TRANSPORT_MESSAGE_PERIOD_OFFSET];
const uint32_t err_code = sd_ant_channel_radio_freq_set(ANTFS_CONFIG_CHANNEL_NUMBER,
m_active_beacon_frequency);
APP_ERROR_CHECK(err_code);
channel_period_set(m_active_beacon_status1_field.parameters.link_period);
}
m_link_command_in_progress = 0;
break;
default:
// Don't do anything, this is an invalid message.
m_link_command_in_progress = 0;
break;
}
}
/**@brief Function for handling data upload.
*
* @param[in] control_byte The command control byte.
* @param[in] p_buffer The data buffer.
*/
static void upload_data_process(uint8_t control_byte, const uint8_t * p_buffer)
{
#if ANTFS_CONFIG_UPLOAD_ENABLED
if (control_byte & SEQUENCE_LAST_MESSAGE)
{
// Last burst packet: upload complete.
m_current_state.sub_state.trans_sub_state = ANTFS_TRANS_SUBSTATE_NONE;
// CRC for data packets contained in this upload block.
m_compared_crc = p_buffer[UPLOAD_CRC_OFFSET_LOW ];
m_compared_crc |= (p_buffer[UPLOAD_CRC_OFFSET_HIGH] << 8u);
if (m_max_transfer_index.data && (m_compared_crc == m_transfer_crc))
{
// CRC OK, upload was completed successfully.
event_queue_write(ANTFS_EVENT_UPLOAD_COMPLETE);
}
else
{
// CRC mismatch, upload failed.
event_queue_write(ANTFS_EVENT_UPLOAD_FAIL);
}
m_max_transfer_index.data = 0;
}
else
{
// Not the last burst packet: upload not complete.
// Set initial number of bytes to 8 (size of burst packet).
m_bytes_to_write = BURST_PACKET_SIZE;
timeout_start(ANTFS_CONFIG_LINK_COMMAND_TIMEOUT);
if (m_link_burst_index.data > m_max_transfer_index.data)
{
// We are past the main index, we do not need to write any more data.
m_bytes_to_write = 0;
}
else
{
if ((m_bytes_to_write + m_link_burst_index.data) > m_max_transfer_index.data)
{
// if we're less than 8 bytes away from the end, adjust the number of bytes to write
// in this block.
m_bytes_to_write = m_max_transfer_index.data - m_link_burst_index.data;
}
}
if (m_bytes_to_write != 0)
{
APP_ERROR_CHECK_BOOL(m_bytes_to_write <= BURST_PACKET_SIZE);
// Store begin of upload data.
mp_upload_data = p_buffer;
m_transfer_crc = crc_crc16_update(m_transfer_crc, p_buffer, m_bytes_to_write);
// Send data to application.
event_queue_write(ANTFS_EVENT_UPLOAD_DATA);
// Update current offset.
m_link_burst_index.data += m_bytes_to_write;
// Store save point.
m_saved_crc_offset = m_link_burst_index.data;
m_saved_transfer_crc = m_transfer_crc;
}
}
#endif // ANTFS_CONFIG_UPLOAD_ENABLED
}
/**@brief Function for switching to transport layer.
*/
static void transport_layer_transit(void)
{
if (m_current_state.state != ANTFS_STATE_OFF)
{
#if ANTFS_CONFIG_DEBUG_LED_ENABLED
uint32_t err_code = bsp_indication_set(BSP_INDICATE_IDLE);
APP_ERROR_CHECK(err_code);
#endif // ANTFS_CONFIG_DEBUG_LED_ENABLED
m_current_state.state = ANTFS_STATE_TRANS;
m_current_state.sub_state.trans_sub_state = ANTFS_TRANS_SUBSTATE_NONE;
timeout_start(ANTFS_CONFIG_LINK_COMMAND_TIMEOUT);
beacon_transmit(MESG_BROADCAST_DATA_ID);
event_queue_write(ANTFS_EVENT_TRANS);
}
}
void antfs_message_process(uint8_t * p_message)
{
#if ANTFS_CONFIG_DEBUG_LED_ENABLED
uint32_t err_code;
#endif // ANTFS_CONFIG_DEBUG_LED_ENABLED
if (p_message != NULL)
{
if ((p_message[BUFFER_INDEX_CHANNEL_NUM] & CHANNEL_NUMBER_MASK) != ANTFS_CONFIG_CHANNEL_NUMBER)
{
// Only process messages corresponding to the ANT-FS channel here.
return;
}
if ((m_current_state.state == ANTFS_STATE_OFF) &&
(
!(
(p_message[BUFFER_INDEX_MESG_ID] == MESG_RESPONSE_EVENT_ID) &&
(p_message[BUFFER_INDEX_RESPONSE_CODE] == NO_EVENT)
)
)
)
{
return;
}
switch (p_message[BUFFER_INDEX_MESG_ID])
{
case MESG_BROADCAST_DATA_ID:
// We are not going to process broadcast messages or pass them to the app to handle.
break;
case MESG_ACKNOWLEDGED_DATA_ID:
// Mark it as being the last message if it's an ack message.
p_message[ANTFS_CONTROL_OFFSET] |= SEQUENCE_LAST_MESSAGE;
/* fall-through */
case MESG_BURST_DATA_ID:
switch (m_current_state.state)
{
case ANTFS_STATE_LINK:
link_layer_cmd_decode(&p_message[ANTFS_DATA_OFFSET]);
break;
case ANTFS_STATE_AUTH:
authenticate_layer_cmd_decode(p_message[ANTFS_CONTROL_OFFSET],
&p_message[ANTFS_DATA_OFFSET]);
break;
case ANTFS_STATE_TRANS:
if (m_current_state.sub_state.trans_sub_state !=
ANTFS_TRANS_SUBSTATE_UPLOADING)
{
transport_layer_cmd_decode(p_message[ANTFS_CONTROL_OFFSET],
&p_message[ANTFS_DATA_OFFSET]);
}
else
{
upload_data_process(p_message[ANTFS_CONTROL_OFFSET],
&p_message[ANTFS_DATA_OFFSET]);
}
break;
default:
// If in any other state or sub-state, do nothing.
break;
}
break;
case MESG_RESPONSE_EVENT_ID:
// Branch on event ID.
switch (p_message[BUFFER_INDEX_RESPONSE_CODE])
{
case EVENT_TRANSFER_TX_FAILED:
m_link_command_in_progress = ANTFS_CMD_NONE;
// Switch into the appropriate state after the failure. Must be ready for
// the host to do a retry.
switch (m_current_state.state)
{
case ANTFS_STATE_LINK:
link_layer_transit();
break;
case ANTFS_STATE_AUTH:
// Burst failed, retry sending the response
if (!m_retry)
{
authenticate_layer_transit(); // Reload beacon
}
else
{
if (m_current_state.sub_state.auth_sub_state == ANTFS_AUTH_SUBSTATE_ACCEPT)
{
if (m_authenticate_command_type == COMMAND_TYPE_REQUEST_PAIR)
{
authenticate_response_transmit(AUTH_RESPONSE_ACCEPT, ANTFS_PASSKEY_SIZE,
m_initial_parameters.p_pass_key);
}
else
{
authenticate_response_transmit(AUTH_RESPONSE_ACCEPT, 0, NULL);
}
}
else if (m_current_state.sub_state.auth_sub_state == ANTFS_AUTH_SUBSTATE_REJECT)
{
authenticate_response_transmit(AUTH_RESPONSE_REJECT, 0, NULL);
}
else if (m_authenticate_command_type == COMMAND_TYPE_REQUEST_SERIAL)
{
authenticate_response_transmit(AUTH_RESPONSE_N_A,
ANTFS_REMOTE_FRIENDLY_NAME_MAX,
// Send device friendly name if it exists.
m_initial_parameters.p_remote_friendly_name);
}
else
{
// No implementation needed
}
m_retry--;
}
break;
case ANTFS_STATE_TRANS:
if (m_current_state.sub_state.trans_sub_state ==
ANTFS_TRANS_SUBSTATE_DOWNLOADING)
{
event_queue_write(ANTFS_EVENT_DOWNLOAD_FAIL);
}
transport_layer_transit();
break;
default:
// No implementation needed.
break;
}
break;
case EVENT_TRANSFER_RX_FAILED:
m_link_command_in_progress = ANTFS_CMD_NONE;
if (m_current_state.sub_state.trans_sub_state ==
ANTFS_TRANS_SUBSTATE_UPLOADING)
{
event_queue_write(ANTFS_EVENT_UPLOAD_FAIL);
m_current_state.sub_state.trans_sub_state =
ANTFS_TRANS_SUBSTATE_UPLOAD_RESUME;
}
else
{
// No implementation needed
}
break;
case EVENT_TRANSFER_TX_COMPLETED:
m_link_command_in_progress = ANTFS_CMD_NONE;
// Switch into appropiate state after successful command.
switch (m_current_state.state)
{
case ANTFS_STATE_AUTH:
if (m_current_state.sub_state.auth_sub_state ==
ANTFS_AUTH_SUBSTATE_ACCEPT)
{
// We passed authentication, so go to transport state.
transport_layer_transit();
}
else if (m_current_state.sub_state.auth_sub_state ==
ANTFS_AUTH_SUBSTATE_REJECT)
{
// We failed authentication, so go to link state.
link_layer_transit();
}
else
{
// Reload beacon.
authenticate_layer_transit();
}
break;
case ANTFS_STATE_TRANS:
if (m_current_state.sub_state.trans_sub_state ==
ANTFS_TRANS_SUBSTATE_DOWNLOADING)
{
event_queue_write(ANTFS_EVENT_DOWNLOAD_COMPLETE);
}
if (m_current_state.sub_state.trans_sub_state !=
ANTFS_TRANS_SUBSTATE_UPLOAD_WAIT_FOR_DATA)
{
transport_layer_transit(); // Reload beacon.
}
break;
default:
link_layer_transit(); // Reload beacon.
break;
}
break;
case EVENT_TX:
#if ANTFS_CONFIG_DEBUG_LED_ENABLED
err_code = bsp_indication_set(BSP_INDICATE_SENT_OK);
APP_ERROR_CHECK(err_code);
#endif // ANTFS_CONFIG_DEBUG_LED_ENABLED
// Load beacon.
beacon_transmit(MESG_BROADCAST_DATA_ID);
break;
case EVENT_CHANNEL_CLOSED:
event_queue_write(ANTFS_EVENT_CLOSE_COMPLETE);
break;
case NO_EVENT:
// This shouldn't happen... command responses should not occur.
APP_ERROR_HANDLER(p_message[BUFFER_INDEX_RESPONSE_CODE]);
break;
default:
// No implementation needed.
return;
}
break;
default:
// No implementation needed.
return;
}
}
}
void antfs_channel_setup(void)
{
// Start channel configuration.
uint32_t err_code = ant_fs_key_set(ANTFS_CONFIG_NETWORK_NUMBER);
APP_ERROR_CHECK(err_code);
err_code = sd_ant_channel_assign(ANTFS_CONFIG_CHANNEL_NUMBER,
ANTFS_CHANNEL_TYPE,
ANTFS_CONFIG_NETWORK_NUMBER,
0);
APP_ERROR_CHECK(err_code);
// Use the lower 2 bytes of the ESN for device number.
uint16_t device_number = (uint16_t)(m_initial_parameters.client_serial_number & 0x0000FFFFu);
if (device_number == 0)
{
// Device number of 0 is not allowed.
device_number = 2;
}
err_code = sd_ant_channel_id_set(ANTFS_CONFIG_CHANNEL_NUMBER,
device_number,
ANTFS_CONFIG_DEVICE_TYPE,
ANTFS_CONFIG_TRANS_TYPE);
APP_ERROR_CHECK(err_code);
// Remain in initialization state until channel is open.
m_current_state.state = ANTFS_STATE_INIT;
// @note: Channel frequency is set by function below.
link_layer_transit();
m_current_state.state = ANTFS_STATE_INIT;
channel_period_set(m_active_beacon_status1_field.parameters.link_period);
err_code = sd_ant_channel_open(ANTFS_CONFIG_CHANNEL_NUMBER);
APP_ERROR_CHECK(err_code);
err_code = sd_ant_channel_radio_tx_power_set(ANTFS_CONFIG_CHANNEL_NUMBER,
ANTFS_CONFIG_TRANSMIT_POWER,
ANTFS_CONFIG_CUSTOM_TRANSMIT_POWER);
APP_ERROR_CHECK(err_code);
m_current_state.state = ANTFS_STATE_LINK;
m_current_state.sub_state.link_sub_state = ANTFS_LINK_SUBSTATE_NONE;
event_queue_write(ANTFS_EVENT_OPEN_COMPLETE);
// Start beacon broadcast.
beacon_transmit(MESG_BROADCAST_DATA_ID);
}
/**@brief Function for resetting the ANT-FS state machine.
*/
static void state_machine_reset(void)
{
m_current_state.state = ANTFS_STATE_OFF;
m_link_command_in_progress = ANTFS_CMD_NONE;
timeout_disable();
// Reset the ANT-FS event queue.
m_event_queue.p_queue = m_event_queue_buffer;
m_event_queue.head = 0;
m_event_queue.tail = 0;
// Set as invalid.
m_authenticate_command_type = 0xFFu;
m_retry = 0;
m_saved_crc_offset = 0xFFFFFFFFu;
m_max_transfer_index.data = 0;
m_is_crc_pending = false;
m_is_data_request_pending = false;
m_friendly_name.is_name_set = false;
m_friendly_name.index = 0;
memset(m_friendly_name.friendly_name, 0, ANTFS_FRIENDLY_NAME_MAX);
}
/**@brief Function for ANT-FS timer event.
*
* Handles pairing and command timeouts.
*
* @param[in] p_context The callback context.
*/
static void timeout_handle(void * p_context)
{
if (m_current_state.state == ANTFS_STATE_OFF)
{
return;
}
if ((m_current_state.state == ANTFS_STATE_AUTH) &&
// Pairing timeout.
(m_current_state.sub_state.auth_sub_state == ANTFS_AUTH_SUBSTATE_PAIR))
{
// Reject authentication request and send pairing timeout event.
authenticate_response_transmit(AUTH_RESPONSE_REJECT, 0, NULL);
event_queue_write(ANTFS_EVENT_PAIRING_TIMEOUT);
}
// Fall back to link layer when an ANT-FS event times out.
link_layer_transit();
}
void antfs_init(const antfs_params_t * const p_params,
antfs_burst_wait_handler_t burst_wait_handler)
{
m_initial_parameters = *p_params;
m_burst_wait_handler = burst_wait_handler;
m_active_beacon_status1_field = m_initial_parameters.beacon_status_byte1;
uint32_t err_code = app_timer_create(&m_timer_id, APP_TIMER_MODE_SINGLE_SHOT, timeout_handle);
APP_ERROR_CHECK(err_code);
state_machine_reset();
err_code = sd_ant_burst_handler_wait_flag_enable((uint8_t *)(&m_burst_wait));
APP_ERROR_CHECK(err_code);
}
#endif // NRF_MODULE_ENABLED(ANTFS)
Reference in New Issue View Git Blame Copy Permalink