static void intervals_calculate(void)
{

    bool etlm_required = false;
    uint8_t no_of_eid_slots = eddystone_adv_slot_num_of_current_eids(NULL, &etlm_required);

    /*Buffers to hardcode a small shortening of the intervals just in case of any delays
    between all the running timer interrupts (scheduled to main context) + variance in encyrption time
    of eTLMs so that all slots have enough time to advertise before the next advertising interval comes around*/

    const uint8_t etlm_dist_buffer_ms = 25;
    const uint8_t slot_dist_buffer_ms = 25;

    /**@note From internal testing we can see that eTLM encryption takes about ~170 ms on the NRF52.
    Which means that the delay after the timer interrupt fires to advertise and the actual eTLM advertisement is ~170 ms,
    this is a significant limiting factor for the minimum advertising interval.

    Please read the comments above @ref timers_init to see what is the current scheme of
    advertising timing before continuing.

    Thus if there N EIDs configured (N > 0) in the beacon and at least 1 TLM configured, then the TLM frame auto switches
    to eTLM and cycles through the set of EIKs of the EIDs frames and advertises N eTLM frames, all within one slot interval,
    each encrypted with the EIK of one of the EID slots. Hence there must be enough time alotted in 1 slot interval for N*(~170 ms + buffer).
     */

     /*Minimum interval between two eTLM advertisements (2+ EIDs) in one eTLM slot in ms*/
     const uint16_t ETLM_INTERVAL_LIMIT = 225;  /*MUST be > ~170 ms + etlm_dist_buffer_ms */

    /*Minimum interval between two slots in ms.
     If eTLM is required then SLOT_INTERVAL_LIMIT becomes just the first half of the sum,
     else the second half (MIN_NON_CONN_ADV_INTERVAL) since there is no significant real-time encrytion delays*/
    const uint16_t SLOT_INTERVAL_LIMIT = (no_of_eid_slots*ETLM_INTERVAL_LIMIT)*(uint8_t)(etlm_required)
                                          + MIN_NON_CONN_ADV_INTERVAL*((uint8_t)(!etlm_required));

    DEBUG_PRINTF(0,"SLOT_INTERVAL_LIMIT: %d \r\n", SLOT_INTERVAL_LIMIT);
    //See if any slot is configured at all
    uint8_t no_of_currently_configed_slots = eddystone_adv_slot_num_of_configured_slots(m_currently_configured_slots);
    DEBUG_PRINTF(0,"Number of Configured Slots: %d \r\n", no_of_currently_configed_slots);

    //Gets slot 0's advertising interval since only global advertising interval is supported currently
    eddystone_adv_slot_params_t adv_slot_0_params;
    eddystone_adv_slot_params_get(0, &adv_slot_0_params);
    m_intervals.adv_intrvl = adv_slot_0_params.adv_intrvl;

    //Can happen when flash R/W for storing/loading slot configs did not behave as expected
    //which can crash the app_timer_start
    //TODO: might need a better error handling strategy for this...
    if (m_intervals.adv_intrvl == 0)
    {
        m_intervals.adv_intrvl = 1000;
    }

    if (no_of_currently_configed_slots == 0)
    {
        m_intervals.slot_slot_interval = 0;
        m_intervals.etlm_etlm_interval = 0;
    }
    else
    {
        //Slot-Slot Interval
        m_intervals.slot_slot_interval = (m_intervals.adv_intrvl/(no_of_currently_configed_slots)) - slot_dist_buffer_ms;
        if (m_intervals.slot_slot_interval < SLOT_INTERVAL_LIMIT)
        {
            ble_ecs_adv_intrvl_t adjusted_interval = (SLOT_INTERVAL_LIMIT + slot_dist_buffer_ms)*no_of_currently_configed_slots;
            m_intervals.adv_intrvl = adjusted_interval;

            DEBUG_PRINTF(0,"1 - ADV INTERVAL ADJUSTED BY ADV MGR: %d \r\n", adjusted_interval);
            adjusted_interval = BYTES_SWAP_16BIT(adjusted_interval);
            eddystone_adv_slot_adv_intrvl_set(0, &adjusted_interval, true);
            m_intervals.slot_slot_interval = m_intervals.adv_intrvl/no_of_currently_configed_slots - slot_dist_buffer_ms;
            DEBUG_PRINTF(0,"Slot-Slot Interval: %d \r\n", m_intervals.slot_slot_interval );
        }

        //eTLM-eTLM interval
        if (no_of_eid_slots != 0 && etlm_required == true)
        {
            m_intervals.etlm_etlm_interval = (m_intervals.slot_slot_interval/no_of_eid_slots) - etlm_dist_buffer_ms;

            if (m_intervals.etlm_etlm_interval < ETLM_INTERVAL_LIMIT)
            {
                m_intervals.etlm_etlm_interval = ETLM_INTERVAL_LIMIT;
                m_intervals.slot_slot_interval = (m_intervals.etlm_etlm_interval + etlm_dist_buffer_ms)*no_of_eid_slots - slot_dist_buffer_ms;

                ble_ecs_adv_intrvl_t adjusted_interval = (m_intervals.slot_slot_interval + slot_dist_buffer_ms)*no_of_currently_configed_slots;
                m_intervals.adv_intrvl = adjusted_interval;

                DEBUG_PRINTF(0,"2 - ADV INTERVAL ADJUSTED BY ADV MGR: %d \r\n", adjusted_interval);
                adjusted_interval = BYTES_SWAP_16BIT(adjusted_interval);
                eddystone_adv_slot_adv_intrvl_set(0, &adjusted_interval, true);

                DEBUG_PRINTF(0,"eTLM-eTLM Interval: %d \r\n", m_intervals.etlm_etlm_interval );
                DEBUG_PRINTF(0,"Slot-Slot Interval: %d \r\n", m_intervals.slot_slot_interval );
            }
        }
        else
        {
            m_intervals.etlm_etlm_interval = 0;
        }
    }
}
コード例 #2
0
ファイル: nrf_ble_escs.c プロジェクト: AaltoNEPPI/nRF52_dev
ret_code_t nrf_ble_escs_init(nrf_ble_escs_t * p_escs, const nrf_ble_escs_init_t * p_escs_init)
{
    uint32_t      err_code;
    ble_uuid_t    ble_uuid;
    ble_uuid128_t ecs_base_uuid = ESCS_BASE_UUID;
    uint8_t       zero_val = 0;

    VERIFY_PARAM_NOT_NULL(p_escs);
    VERIFY_PARAM_NOT_NULL(p_escs_init);

    // Initialize the service structure.
    p_escs->conn_handle       = BLE_CONN_HANDLE_INVALID;
    p_escs->write_evt_handler = p_escs_init->write_evt_handler;
    p_escs->read_evt_handler  = p_escs_init->read_evt_handler;

    // Add a custom base UUID.
    err_code = sd_ble_uuid_vs_add(&ecs_base_uuid, &p_escs->uuid_type);
    VERIFY_SUCCESS(err_code);

    ble_uuid.type = p_escs->uuid_type;
    ble_uuid.uuid = BLE_UUID_ESCS_SERVICE;

    // Add the service.
    err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY,
                                        &ble_uuid,
                                        &p_escs->service_handle);
    VERIFY_SUCCESS(err_code);

    m_handle_to_uuid_map_idx = 0;

    // Set up initial values for characteristics

    // Eddystone spec requires big endian
    nrf_ble_escs_broadcast_cap_t temp = p_escs_init->p_init_vals->broadcast_cap;
    temp.supp_frame_types = BYTES_SWAP_16BIT(temp.supp_frame_types);

    nrf_ble_escs_adv_interval_t temp_interval = p_escs_init->p_init_vals->adv_interval;
    temp_interval = BYTES_SWAP_16BIT(temp_interval);

    // Adding chracteristics

    err_code = char_add(&BROADCAST_CAP_CHAR_INIT, p_escs,
                        &temp, &p_escs->broadcast_cap_handles);
    VERIFY_SUCCESS(err_code);

    err_code = char_add(&ACTIVE_SLOT_CHAR_INIT, p_escs,
                        p_escs->p_active_slot, &p_escs->active_slot_handles);
    VERIFY_SUCCESS(err_code);

    err_code = char_add(&ADV_INTERVAL_CHAR_INIT, p_escs,
                        &temp_interval, &p_escs->adv_interval_handles);
    VERIFY_SUCCESS(err_code);

    err_code = char_add(&RADIO_TX_PWR_CHAR_INIT, p_escs,
                        &(p_escs_init->p_init_vals->radio_tx_pwr), &p_escs->radio_tx_pwr_handles);
    VERIFY_SUCCESS(err_code);

    err_code = char_add(&ADV_TX_PWR_CHAR_INIT, p_escs,
                        &(p_escs_init->p_init_vals->adv_tx_pwr), &p_escs->adv_tx_pwr_handles);
    VERIFY_SUCCESS(err_code);

    err_code = char_add(&LOCK_STATE_CHAR_INIT, p_escs,
                        p_escs->p_lock_state, &p_escs->lock_state_handles);
    VERIFY_SUCCESS(err_code);

    err_code = char_add(&UNLOCK_CHAR_INIT, p_escs,
                        &zero_val, &p_escs->unlock_handles);
    VERIFY_SUCCESS(err_code);

    err_code = char_add(&PUBLIC_ECDH_KEY_CHAR_INIT,  p_escs,
                        &zero_val, &p_escs->pub_ecdh_key_handles);
    VERIFY_SUCCESS(err_code);

    err_code = char_add(&EID_ID_KEY_CHAR_INIT, p_escs,
                        &zero_val, &p_escs->eid_id_key_handles);
    VERIFY_SUCCESS(err_code);

    err_code = char_add(&RW_ADV_SLOT_CHAR_INIT, p_escs,
                        &zero_val, &p_escs->rw_adv_slot_handles);
    VERIFY_SUCCESS(err_code);

    err_code = char_add(&FACTORY_RESET_CHAR_INIT, p_escs,
                        &(p_escs_init->p_init_vals->factory_reset), &p_escs->factory_reset_handles);
    VERIFY_SUCCESS(err_code);

    err_code = char_add(&REMAIN_CONNECTABLE_CHAR_INIT, p_escs,
                        &(p_escs_init->p_init_vals->remain_connectable.r_is_non_connectable_supported),
                        &p_escs->remain_connectable_handles);
    VERIFY_SUCCESS(err_code);

    return NRF_SUCCESS;
}