void trickle_setup(uint32_t i_min, uint32_t i_max, uint8_t k)
{
g_i_min = i_min;
g_i_max = i_max;
g_k = k;
uint32_t error_code;
rng_index = 0;
/* Fill rng pool */
uint8_t bytes_available;
do
{
error_code =
sd_rand_application_bytes_available_get(&bytes_available);
APP_ERROR_CHECK(error_code);
if (bytes_available > 0)
{
uint8_t byte_count =
((bytes_available > TRICKLE_RNG_POOL_SIZE - rng_index)?
(TRICKLE_RNG_POOL_SIZE - rng_index) :
(bytes_available));
error_code =
sd_rand_application_vector_get(&rng_vals[rng_index],
byte_count);
APP_ERROR_CHECK(error_code);
rng_index += byte_count;
}
} while (rng_index < TRICKLE_RNG_POOL_SIZE);
}
/*
* nRF51 has a TRNG that we can access using SoftDevice.
*/
int eddystoneEntropyPoll(void *data, unsigned char *output, size_t len, size_t *olen)
{
uint8_t bytes_available = 0;
// get the number of random bytes available
if (sd_rand_application_bytes_available_get(&bytes_available) != NRF_SUCCESS) {
return MBEDTLS_ERR_ENTROPY_SOURCE_FAILED;
}
// if there is more bytes available that what is requested,
// truncate the number of bytes in output to len, otherwise use the total
// of bytes available.
const uint8_t output_len = bytes_available > len ? len : bytes_available;
if (output_len) {
// transfer "output_len" random bytes to output.
if (sd_rand_application_vector_get(output, output_len) != NRF_SUCCESS) {
return MBEDTLS_ERR_ENTROPY_SOURCE_FAILED;
}
}
// Everything went fine, commit the output_len to the output parameter
*olen = output_len;
return 0;
}
uint8_t RNG::getRandom8() {
uint8_t bytes_available = 0;
uint32_t err_code;
while (bytes_available < 1) {
err_code = sd_rand_application_bytes_available_get(&bytes_available);
APP_ERROR_CHECK(err_code);
}
err_code = sd_rand_application_vector_get(_randomBytes, 1);
APP_ERROR_CHECK(err_code);
return _randomBytes[0];
};
ret_code_t nrf_drv_rng_bytes_available(uint8_t * p_bytes_available)
{
ret_code_t result;
ASSERT(m_rng_cb.state == NRF_DRV_STATE_INITIALIZED);
#ifndef SOFTDEVICE_PRESENT
result = NRF_SUCCESS;
*p_bytes_available = FIFO_LENGTH(m_rng_cb.rand_pool);
#else
result = sd_rand_application_bytes_available_get(p_bytes_available);
#endif // SOFTDEVICE_PRESENT
return result;
}
void nrf_drv_rng_bytes_available(uint8_t * p_bytes_available)
{
ASSERT(m_rng_cb.state == NRFX_DRV_STATE_INITIALIZED);
#ifdef SOFTDEVICE_PRESENT
if (NRF_DRV_RNG_SD_IS_ENABLED())
{
if (NRF_SUCCESS == sd_rand_application_bytes_available_get(p_bytes_available))
{
return;
}
}
#endif // SOFTDEVICE_PRESENT
*p_bytes_available = nrf_queue_utilization_get(&m_rand_pool);
NRF_LOG_INFO("Function: %s, available bytes: %d.", (uint32_t)__func__, *p_bytes_available);
}
void random_create(uint8_t* p_result, uint8_t length)
{
uint32_t err_code;
while (length)
{
uint8_t available = 0;
err_code = sd_rand_application_bytes_available_get(&available);
APP_ERROR_CHECK(err_code);
if (available)
{
available = available < length ? available : length;
err_code = sd_rand_application_vector_get(p_result, available);
APP_ERROR_CHECK(err_code);
p_result += available;
length -= available;
}
}
}
uint16_t RNG::getRandom16() {
uint8_t bytes_available = 0;
uint32_t err_code;
while (bytes_available < 2) {
err_code = sd_rand_application_bytes_available_get(&bytes_available);
APP_ERROR_CHECK(err_code);
}
err_code = sd_rand_application_vector_get(_randomBytes, 2);
APP_ERROR_CHECK(err_code);
conv8_16 converter;
converter.a[0] = _randomBytes[0];
converter.a[1] = _randomBytes[1];
return converter.b;
};
uint32_t rand_hw_rng_get(uint8_t* p_result, uint16_t len)
{
#ifdef SOFTDEVICE_PRESENT
uint32_t error_code;
uint8_t bytes_available;
uint32_t count = 0;
while (count < len)
{
do
{
sd_rand_application_bytes_available_get(&bytes_available);
} while (bytes_available == 0);
if (bytes_available > len - count)
{
bytes_available = len - count;
}
error_code =
sd_rand_application_vector_get(&p_result[count],
bytes_available);
if (error_code != NRF_SUCCESS)
{
return NRF_ERROR_INTERNAL;
}
count += bytes_available;
}
#else
NRF_RNG->TASKS_START = 1;
while (len)
{
while (!NRF_RNG->EVENTS_VALRDY);
p_result[--len] = NRF_RNG->VALUE;
NRF_RNG->EVENTS_VALRDY = 0;
}
NRF_RNG->TASKS_STOP = 1;
#endif
return NRF_SUCCESS;
}
/** @brief Processes a ANT messages while in the requesting state.
*
* @param[in] Pointer to the raw ant message received.
*/
static void ascs_process_message_requesting(uint8_t event, uint8_t * p_event_message_buffer)
{
uint32_t err_code;
switch (event)
{
case EVENT_TRANSFER_TX_FAILED:
{
//Randomly get a backoff between MIN_BACKOFF to m_backoff_range
uint8_t num_rand_bytes_available;
err_code = sd_rand_application_bytes_available_get(&num_rand_bytes_available);
APP_ERROR_CHECK(err_code);
//update the backoff if there is a randon number available
if(num_rand_bytes_available > 0)
{
uint8_t rand_number;
err_code = sd_rand_application_vector_get(&rand_number, 1);
APP_ERROR_CHECK(err_code);
m_backoff = (uint8_t) (rand_number % m_backoff_range + MIN_BACKOFF);
}
ascs_set_state(SEARCHING);
break;
}
case EVENT_TRANSFER_TX_COMPLETED:
{
ascs_set_state(WAITING);
break;
}
case EVENT_CHANNEL_CLOSED:
case EVENT_RX: //Intentional fallthrough
default:
{
break;
}
}
}
