/* Function Definitions */
static void test_mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
const mxArray *outputs[1];
const mxArray *inputs[1];
int n = 0;
int nOutputs = (nlhs < 1 ? 1 : nlhs);
int nInputs = nrhs;
emlrtStack st = { NULL, NULL, NULL };
/* Module initialization. */
test_initialize(&emlrtContextGlobal);
st.tls = emlrtRootTLSGlobal;
/* Check for proper number of arguments. */
if (nrhs != 1) {
emlrtErrMsgIdAndTxt(&st, "EMLRT:runTime:WrongNumberOfInputs", 5, mxINT32_CLASS, 1, mxCHAR_CLASS, 4, "test");
} else if (nlhs > 1) {
emlrtErrMsgIdAndTxt(&st, "EMLRT:runTime:TooManyOutputArguments", 3, mxCHAR_CLASS, 4, "test");
}
/* Temporary copy for mex inputs. */
for (n = 0; n < nInputs; ++n) {
inputs[n] = prhs[n];
}
/* Call the function. */
test_api(inputs, outputs);
/* Copy over outputs to the caller. */
for (n = 0; n < nOutputs; ++n) {
plhs[n] = emlrtReturnArrayR2009a(outputs[n]);
}
/* Module finalization. */
test_terminate();
}
/**@brief Function for handling BLE_GAP_EVT_DISCONNECTED events.
* Unset the connection handle and terminate the test.
*/
void on_ble_gap_evt_disconnected(ble_gap_evt_t const * p_gap_evt)
{
m_conn_handle = BLE_CONN_HANDLE_INVALID;
NRF_LOG_INFO("Disconnected (reason 0x%x).\r\n", p_gap_evt->params.disconnected.reason);
if (m_run_test)
{
NRF_LOG_WARNING("GAP disconnection event received while test was running.\r\n")
}
bsp_board_leds_off();
test_terminate();
}
/**@brief AMT Client Handler.
*/
void amtc_evt_handler(nrf_ble_amtc_t * p_amt_c, nrf_ble_amtc_evt_t * p_evt)
{
uint32_t err_code;
switch (p_evt->evt_type)
{
case NRF_BLE_AMT_C_EVT_DISCOVERY_COMPLETE:
{
NRF_LOG_INFO("AMT service discovered on peer.\r\n");
err_code = nrf_ble_amtc_handles_assign(p_amt_c ,
p_evt->conn_handle,
&p_evt->params.peer_db);
APP_ERROR_CHECK(err_code);
// Enable notifications.
err_code = nrf_ble_amtc_notif_enable(p_amt_c);
APP_ERROR_CHECK(err_code);
} break;
case NRF_BLE_AMT_C_EVT_NOTIFICATION:
{
static uint32_t bytes_cnt = 0;
static uint32_t kbytes_cnt = 0;
if (p_evt->params.hvx.bytes_sent == 0)
{
bytes_cnt = 0;
kbytes_cnt = 0;
}
bytes_cnt += p_evt->params.hvx.notif_len;
if (bytes_cnt > 1024)
{
bsp_board_led_invert(LED_PROGRESS);
bytes_cnt -= 1024;
kbytes_cnt++;
NRF_LOG_INFO("Received %u kbytes\r\n", kbytes_cnt);
nrf_ble_amts_rbc_set(&m_amts, p_evt->params.hvx.bytes_rcvd);
}
if (p_evt->params.hvx.bytes_rcvd >= AMT_BYTE_TRANSFER_CNT)
{
bsp_board_led_off(LED_PROGRESS);
bytes_cnt = 0;
kbytes_cnt = 0;
NRF_LOG_INFO("Transfer complete, received %u bytes of ATT payload.\r\n",
p_evt->params.hvx.bytes_rcvd);
nrf_ble_amts_rbc_set(&m_amts, p_evt->params.hvx.bytes_rcvd);
}
} break;
case NRF_BLE_AMT_C_EVT_RBC_READ_RSP:
{
NRF_LOG_INFO("Peer received %u bytes of ATT payload.\r\n", (p_evt->params.rcv_bytes_cnt));
test_terminate();
} break;
default:
break;
}
}
/**@brief AMT Service Handler.
*/
static void amts_evt_handler(nrf_ble_amts_evt_t evt)
{
ret_code_t err_code;
switch (evt.evt_type)
{
case SERVICE_EVT_NOTIF_ENABLED:
{
NRF_LOG_INFO("Notifications enabled.\r\n");
bsp_board_led_on(LED_READY);
m_notif_enabled = true;
if (m_board_role != BOARD_TESTER)
{
return;
}
if (m_gap_role == BLE_GAP_ROLE_PERIPH)
{
m_conn_interval_configured = false;
m_conn_param.min_conn_interval = m_test_params.conn_interval;
m_conn_param.max_conn_interval = m_test_params.conn_interval + 1;
err_code = ble_conn_params_change_conn_params(&m_conn_param);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("ble_conn_params_change_conn_params() failed: 0x%x.\r\n",
err_code);
}
}
if (m_gap_role == BLE_GAP_ROLE_CENTRAL)
{
m_conn_interval_configured = true;
m_conn_param.min_conn_interval = m_test_params.conn_interval;
m_conn_param.max_conn_interval = m_test_params.conn_interval;
err_code = sd_ble_gap_conn_param_update(m_conn_handle, &m_conn_param);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("sd_ble_gap_conn_param_update() failed: 0x%x.\r\n", err_code);
}
}
} break;
case SERVICE_EVT_NOTIF_DISABLED:
{
NRF_LOG_INFO("Notifications disabled.\r\n");
bsp_board_led_off(LED_READY);
} break;
case SERVICE_EVT_TRANSFER_1KB:
{
NRF_LOG_INFO("Sent %u KBytes\r\n", (evt.bytes_transfered_cnt / 1024));
bsp_board_led_invert(LED_PROGRESS);
} break;
case SERVICE_EVT_TRANSFER_FINISHED:
{
// Stop counter as soon as possible.
counter_stop();
bsp_board_led_off(LED_PROGRESS);
bsp_board_led_on(LED_FINISHED);
uint32_t time_ms = counter_get();
uint32_t bit_count = (evt.bytes_transfered_cnt * 8);
float throughput = (((float)(bit_count * 100) / time_ms) / 1024);
NRF_LOG_INFO("Done.\r\n\r\n");
NRF_LOG_INFO("=============================\r\n");
NRF_LOG_INFO("Time: %u.%.2u seconds elapsed.\r\n",
(counter_get() / 100), (counter_get() % 100));
NRF_LOG_INFO("Throughput: " NRF_LOG_FLOAT_MARKER " Kbits/s.\r\n",
NRF_LOG_FLOAT(throughput));
NRF_LOG_INFO("=============================\r\n");
NRF_LOG_INFO("Sent %u bytes of ATT payload.\r\n", evt.bytes_transfered_cnt);
NRF_LOG_INFO("Retrieving amount of bytes received from peer...\r\n");
err_code = nrf_ble_amtc_rcb_read(&m_amtc);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("nrf_ble_amtc_rcb_read() failed: 0x%x.\r\n", err_code);
test_terminate();
}
} break;
}
}
void post()
{
test_terminate();
}
