Cefn Hoile / nRF51822

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   nrf51-sdk

Dependents:   microbit-dal

Fork of nRF51822 by Lancaster University

nordic-sdk/components/ble/common/ble_advdata.c@346:14b090482fd2, 2015-06-19 (annotated)

Committer:
rgrover1
Date:
Fri Jun 19 15:55:35 2015 +0100
Revision:
346:14b090482fd2
Parent:
345:dfde56236c36
Child:
361:d2405f5a4853
Synchronized with git rev bb88aaad

Author: Rohit Grover

renamed BLEDevice to BLE

Who changed what in which revision?

UserRevisionLine numberNew contents of line
rgrover1 346:14b090482fd2 1 /*
rgrover1 346:14b090482fd2 2 * Copyright (c) Nordic Semiconductor ASA
rgrover1 346:14b090482fd2 3 * All rights reserved.
rgrover1 346:14b090482fd2 4 *
rgrover1 346:14b090482fd2 5 * Redistribution and use in source and binary forms, with or without modification,
rgrover1 346:14b090482fd2 6 * are permitted provided that the following conditions are met:
rgrover1 346:14b090482fd2 7 *
rgrover1 346:14b090482fd2 8 * 1. Redistributions of source code must retain the above copyright notice, this
rgrover1 346:14b090482fd2 9 * list of conditions and the following disclaimer.
rgrover1 346:14b090482fd2 10 *
rgrover1 346:14b090482fd2 11 * 2. Redistributions in binary form must reproduce the above copyright notice, this
rgrover1 346:14b090482fd2 12 * list of conditions and the following disclaimer in the documentation and/or
rgrover1 346:14b090482fd2 13 * other materials provided with the distribution.
rgrover1 346:14b090482fd2 14 *
rgrover1 346:14b090482fd2 15 * 3. Neither the name of Nordic Semiconductor ASA nor the names of other
rgrover1 346:14b090482fd2 16 * contributors to this software may be used to endorse or promote products
rgrover1 346:14b090482fd2 17 * derived from this software without specific prior written permission.
rgrover1 346:14b090482fd2 18 *
rgrover1 346:14b090482fd2 19 *
rgrover1 346:14b090482fd2 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
rgrover1 346:14b090482fd2 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
rgrover1 346:14b090482fd2 22 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
rgrover1 346:14b090482fd2 23 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
rgrover1 346:14b090482fd2 24 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
rgrover1 346:14b090482fd2 25 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
rgrover1 346:14b090482fd2 26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
rgrover1 346:14b090482fd2 27 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
rgrover1 346:14b090482fd2 28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
rgrover1 346:14b090482fd2 29 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
rgrover1 346:14b090482fd2 30 *
rgrover1 346:14b090482fd2 31 */
rgrover1 346:14b090482fd2 32
rgrover1 346:14b090482fd2 33 #include "ble_advdata.h"
rgrover1 346:14b090482fd2 34 #include "nordic_common.h"
rgrover1 346:14b090482fd2 35 #include "nrf_error.h"
rgrover1 346:14b090482fd2 36 #include "ble_gap.h"
rgrover1 346:14b090482fd2 37 #include "ble_srv_common.h"
rgrover1 346:14b090482fd2 38 #include "app_util.h"
rgrover1 346:14b090482fd2 39
rgrover1 346:14b090482fd2 40
rgrover1 346:14b090482fd2 41 // Offset from where advertisement data other than flags information can start.
rgrover1 346:14b090482fd2 42 #define ADV_FLAG_OFFSET 2
rgrover1 346:14b090482fd2 43
rgrover1 346:14b090482fd2 44 // Offset for Advertising Data.
rgrover1 346:14b090482fd2 45 // Offset is 2 as each Advertising Data contain 1 octet of Adveritising Data Type and
rgrover1 346:14b090482fd2 46 // one octet Advertising Data Length.
rgrover1 346:14b090482fd2 47 #define ADV_DATA_OFFSET 2
rgrover1 346:14b090482fd2 48
rgrover1 346:14b090482fd2 49 // NOTE: For now, Security Manager TK Value and Security Manager Out of Band Flags (OOB) are omitted
rgrover1 346:14b090482fd2 50 // from the advertising data.
rgrover1 346:14b090482fd2 51
rgrover1 346:14b090482fd2 52
rgrover1 346:14b090482fd2 53 static uint32_t name_encode(const ble_advdata_t * p_advdata,
rgrover1 346:14b090482fd2 54 uint8_t * p_encoded_data,
rgrover1 346:14b090482fd2 55 uint8_t * p_len)
rgrover1 346:14b090482fd2 56 {
rgrover1 346:14b090482fd2 57 uint32_t err_code;
rgrover1 346:14b090482fd2 58 uint16_t rem_adv_data_len;
rgrover1 346:14b090482fd2 59 uint16_t actual_length;
rgrover1 346:14b090482fd2 60 uint8_t adv_data_format;
rgrover1 346:14b090482fd2 61 uint8_t adv_offset;
rgrover1 346:14b090482fd2 62
rgrover1 346:14b090482fd2 63 adv_offset = *p_len;
rgrover1 346:14b090482fd2 64
rgrover1 346:14b090482fd2 65
rgrover1 346:14b090482fd2 66 // Check for buffer overflow.
rgrover1 346:14b090482fd2 67 if ((adv_offset + ADV_DATA_OFFSET > BLE_GAP_ADV_MAX_SIZE) ||
rgrover1 346:14b090482fd2 68 ((p_advdata->short_name_len + ADV_DATA_OFFSET) > BLE_GAP_ADV_MAX_SIZE))
rgrover1 346:14b090482fd2 69 {
rgrover1 346:14b090482fd2 70 return NRF_ERROR_DATA_SIZE;
rgrover1 346:14b090482fd2 71 }
rgrover1 346:14b090482fd2 72 actual_length = rem_adv_data_len = (BLE_GAP_ADV_MAX_SIZE - adv_offset - ADV_FLAG_OFFSET);
rgrover1 346:14b090482fd2 73
rgrover1 346:14b090482fd2 74 // Get GAP device name and length
rgrover1 346:14b090482fd2 75 err_code = sd_ble_gap_device_name_get(&p_encoded_data[adv_offset + ADV_DATA_OFFSET],
rgrover1 346:14b090482fd2 76 &actual_length);
rgrover1 346:14b090482fd2 77 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 78 {
rgrover1 346:14b090482fd2 79 return err_code;
rgrover1 346:14b090482fd2 80 }
rgrover1 346:14b090482fd2 81
rgrover1 346:14b090482fd2 82 // Check if device internd to use short name and it can fit available data size.
rgrover1 346:14b090482fd2 83 if ((p_advdata->name_type == BLE_ADVDATA_FULL_NAME) && (actual_length <= rem_adv_data_len))
rgrover1 346:14b090482fd2 84 {
rgrover1 346:14b090482fd2 85 // Complete device name can fit, setting Complete Name in Adv Data.
rgrover1 346:14b090482fd2 86 adv_data_format = BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME;
rgrover1 346:14b090482fd2 87 rem_adv_data_len = actual_length;
rgrover1 346:14b090482fd2 88 }
rgrover1 346:14b090482fd2 89 else
rgrover1 346:14b090482fd2 90 {
rgrover1 346:14b090482fd2 91 // Else short name needs to be used. Or application has requested use of short name.
rgrover1 346:14b090482fd2 92 adv_data_format = BLE_GAP_AD_TYPE_SHORT_LOCAL_NAME;
rgrover1 346:14b090482fd2 93
rgrover1 346:14b090482fd2 94 // If application has set a preference on the short name size, it needs to be considered,
rgrover1 346:14b090482fd2 95 // else fit what can be fit.
rgrover1 346:14b090482fd2 96 if ((p_advdata->short_name_len != 0) && (p_advdata->short_name_len <= rem_adv_data_len))
rgrover1 346:14b090482fd2 97 {
rgrover1 346:14b090482fd2 98 // Short name fits available size.
rgrover1 346:14b090482fd2 99 rem_adv_data_len = p_advdata->short_name_len;
rgrover1 346:14b090482fd2 100 }
rgrover1 346:14b090482fd2 101 // Else whatever can fit the data buffer will be packed.
rgrover1 346:14b090482fd2 102 else
rgrover1 346:14b090482fd2 103 {
rgrover1 346:14b090482fd2 104 rem_adv_data_len = actual_length;
rgrover1 346:14b090482fd2 105 }
rgrover1 346:14b090482fd2 106 }
rgrover1 346:14b090482fd2 107
rgrover1 346:14b090482fd2 108 // Complete name field in encoded data.
rgrover1 346:14b090482fd2 109 p_encoded_data[adv_offset++] = rem_adv_data_len + 1;
rgrover1 346:14b090482fd2 110 p_encoded_data[adv_offset++] = adv_data_format;
rgrover1 346:14b090482fd2 111 (*p_len) += (rem_adv_data_len + ADV_DATA_OFFSET);
rgrover1 346:14b090482fd2 112
rgrover1 346:14b090482fd2 113 return NRF_SUCCESS;
rgrover1 346:14b090482fd2 114 }
rgrover1 346:14b090482fd2 115
rgrover1 346:14b090482fd2 116
rgrover1 346:14b090482fd2 117 static uint32_t appearance_encode(uint8_t * p_encoded_data, uint8_t * p_len)
rgrover1 346:14b090482fd2 118 {
rgrover1 346:14b090482fd2 119 uint32_t err_code;
rgrover1 346:14b090482fd2 120 uint16_t appearance;
rgrover1 346:14b090482fd2 121
rgrover1 346:14b090482fd2 122 // Check for buffer overflow.
rgrover1 346:14b090482fd2 123 if ((*p_len) + 4 > BLE_GAP_ADV_MAX_SIZE)
rgrover1 346:14b090482fd2 124 {
rgrover1 346:14b090482fd2 125 return NRF_ERROR_DATA_SIZE;
rgrover1 346:14b090482fd2 126 }
rgrover1 346:14b090482fd2 127
rgrover1 346:14b090482fd2 128 // Get GAP appearance field.
rgrover1 346:14b090482fd2 129 err_code = sd_ble_gap_appearance_get(&appearance);
rgrover1 346:14b090482fd2 130 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 131 {
rgrover1 346:14b090482fd2 132 return err_code;
rgrover1 346:14b090482fd2 133 }
rgrover1 346:14b090482fd2 134
rgrover1 346:14b090482fd2 135 // Encode Length, AD Type and Appearance.
rgrover1 346:14b090482fd2 136 p_encoded_data[(*p_len)++] = 3;
rgrover1 346:14b090482fd2 137 p_encoded_data[(*p_len)++] = BLE_GAP_AD_TYPE_APPEARANCE;
rgrover1 346:14b090482fd2 138
rgrover1 346:14b090482fd2 139 (*p_len) += uint16_encode(appearance, &p_encoded_data[*p_len]);
rgrover1 346:14b090482fd2 140
rgrover1 346:14b090482fd2 141 return NRF_SUCCESS;
rgrover1 346:14b090482fd2 142 }
rgrover1 346:14b090482fd2 143
rgrover1 346:14b090482fd2 144
rgrover1 346:14b090482fd2 145 static uint32_t tx_power_level_encode(int8_t tx_power_level,
rgrover1 346:14b090482fd2 146 uint8_t * p_encoded_data,
rgrover1 346:14b090482fd2 147 uint8_t * p_len)
rgrover1 346:14b090482fd2 148 {
rgrover1 346:14b090482fd2 149 // Check for buffer overflow.
rgrover1 346:14b090482fd2 150 if ((*p_len) + 3 > BLE_GAP_ADV_MAX_SIZE)
rgrover1 346:14b090482fd2 151 {
rgrover1 346:14b090482fd2 152 return NRF_ERROR_DATA_SIZE;
rgrover1 346:14b090482fd2 153 }
rgrover1 346:14b090482fd2 154
rgrover1 346:14b090482fd2 155 // Encode TX Power Level.
rgrover1 346:14b090482fd2 156 p_encoded_data[(*p_len)++] = 2;
rgrover1 346:14b090482fd2 157 p_encoded_data[(*p_len)++] = BLE_GAP_AD_TYPE_TX_POWER_LEVEL;
rgrover1 346:14b090482fd2 158 p_encoded_data[(*p_len)++] = (uint8_t)tx_power_level;
rgrover1 346:14b090482fd2 159
rgrover1 346:14b090482fd2 160 return NRF_SUCCESS;
rgrover1 346:14b090482fd2 161 }
rgrover1 346:14b090482fd2 162
rgrover1 346:14b090482fd2 163
rgrover1 346:14b090482fd2 164 static uint32_t uuid_list_sized_encode(const ble_advdata_uuid_list_t * p_uuid_list,
rgrover1 346:14b090482fd2 165 uint8_t adv_type,
rgrover1 346:14b090482fd2 166 uint8_t uuid_size,
rgrover1 346:14b090482fd2 167 uint8_t * p_encoded_data,
rgrover1 346:14b090482fd2 168 uint8_t * p_len)
rgrover1 346:14b090482fd2 169 {
rgrover1 346:14b090482fd2 170 int i;
rgrover1 346:14b090482fd2 171 bool is_heading_written = false;
rgrover1 346:14b090482fd2 172 uint8_t start_pos = *p_len;
rgrover1 346:14b090482fd2 173
rgrover1 346:14b090482fd2 174 for (i = 0; i < p_uuid_list->uuid_cnt; i++)
rgrover1 346:14b090482fd2 175 {
rgrover1 346:14b090482fd2 176 uint32_t err_code;
rgrover1 346:14b090482fd2 177 uint8_t encoded_size;
rgrover1 346:14b090482fd2 178 ble_uuid_t uuid = p_uuid_list->p_uuids[i];
rgrover1 346:14b090482fd2 179
rgrover1 346:14b090482fd2 180 // Find encoded uuid size.
rgrover1 346:14b090482fd2 181 err_code = sd_ble_uuid_encode(&uuid, &encoded_size, NULL);
rgrover1 346:14b090482fd2 182 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 183 {
rgrover1 346:14b090482fd2 184 return err_code;
rgrover1 346:14b090482fd2 185 }
rgrover1 346:14b090482fd2 186
rgrover1 346:14b090482fd2 187 // Check size.
rgrover1 346:14b090482fd2 188 if (encoded_size == uuid_size)
rgrover1 346:14b090482fd2 189 {
rgrover1 346:14b090482fd2 190 uint8_t heading_bytes = (is_heading_written) ? 0 : 2;
rgrover1 346:14b090482fd2 191
rgrover1 346:14b090482fd2 192 // Check for buffer overflow
rgrover1 346:14b090482fd2 193 if (*p_len + encoded_size + heading_bytes > BLE_GAP_ADV_MAX_SIZE)
rgrover1 346:14b090482fd2 194 {
rgrover1 346:14b090482fd2 195 return NRF_ERROR_DATA_SIZE;
rgrover1 346:14b090482fd2 196 }
rgrover1 346:14b090482fd2 197
rgrover1 346:14b090482fd2 198 if (!is_heading_written)
rgrover1 346:14b090482fd2 199 {
rgrover1 346:14b090482fd2 200 // Write AD structure heading.
rgrover1 346:14b090482fd2 201 (*p_len)++;
rgrover1 346:14b090482fd2 202 p_encoded_data[(*p_len)++] = adv_type;
rgrover1 346:14b090482fd2 203 is_heading_written = true;
rgrover1 346:14b090482fd2 204 }
rgrover1 346:14b090482fd2 205
rgrover1 346:14b090482fd2 206 // Write UUID.
rgrover1 346:14b090482fd2 207 err_code = sd_ble_uuid_encode(&uuid, &encoded_size, &p_encoded_data[*p_len]);
rgrover1 346:14b090482fd2 208 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 209 {
rgrover1 346:14b090482fd2 210 return err_code;
rgrover1 346:14b090482fd2 211 }
rgrover1 346:14b090482fd2 212 (*p_len) += encoded_size;
rgrover1 346:14b090482fd2 213 }
rgrover1 346:14b090482fd2 214 }
rgrover1 346:14b090482fd2 215
rgrover1 346:14b090482fd2 216 if (is_heading_written)
rgrover1 346:14b090482fd2 217 {
rgrover1 346:14b090482fd2 218 // Write length.
rgrover1 346:14b090482fd2 219 p_encoded_data[start_pos] = (*p_len) - (start_pos + 1);
rgrover1 346:14b090482fd2 220 }
rgrover1 346:14b090482fd2 221
rgrover1 346:14b090482fd2 222 return NRF_SUCCESS;
rgrover1 346:14b090482fd2 223 }
rgrover1 346:14b090482fd2 224
rgrover1 346:14b090482fd2 225
rgrover1 346:14b090482fd2 226 static uint32_t uuid_list_encode(const ble_advdata_uuid_list_t * p_uuid_list,
rgrover1 346:14b090482fd2 227 uint8_t adv_type_16,
rgrover1 346:14b090482fd2 228 uint8_t adv_type_128,
rgrover1 346:14b090482fd2 229 uint8_t * p_encoded_data,
rgrover1 346:14b090482fd2 230 uint8_t * p_len)
rgrover1 346:14b090482fd2 231 {
rgrover1 346:14b090482fd2 232 uint32_t err_code;
rgrover1 346:14b090482fd2 233
rgrover1 346:14b090482fd2 234 // Encode 16 bit UUIDs.
rgrover1 346:14b090482fd2 235 err_code = uuid_list_sized_encode(p_uuid_list,
rgrover1 346:14b090482fd2 236 adv_type_16,
rgrover1 346:14b090482fd2 237 sizeof(uint16_le_t),
rgrover1 346:14b090482fd2 238 p_encoded_data,
rgrover1 346:14b090482fd2 239 p_len);
rgrover1 346:14b090482fd2 240 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 241 {
rgrover1 346:14b090482fd2 242 return err_code;
rgrover1 346:14b090482fd2 243 }
rgrover1 346:14b090482fd2 244
rgrover1 346:14b090482fd2 245 // Encode 128 bit UUIDs.
rgrover1 346:14b090482fd2 246 err_code = uuid_list_sized_encode(p_uuid_list,
rgrover1 346:14b090482fd2 247 adv_type_128,
rgrover1 346:14b090482fd2 248 sizeof(ble_uuid128_t),
rgrover1 346:14b090482fd2 249 p_encoded_data,
rgrover1 346:14b090482fd2 250 p_len);
rgrover1 346:14b090482fd2 251 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 252 {
rgrover1 346:14b090482fd2 253 return err_code;
rgrover1 346:14b090482fd2 254 }
rgrover1 346:14b090482fd2 255
rgrover1 346:14b090482fd2 256 return NRF_SUCCESS;
rgrover1 346:14b090482fd2 257 }
rgrover1 346:14b090482fd2 258
rgrover1 346:14b090482fd2 259
rgrover1 346:14b090482fd2 260 static uint32_t conn_int_check(const ble_advdata_conn_int_t *p_conn_int)
rgrover1 346:14b090482fd2 261 {
rgrover1 346:14b090482fd2 262 // Check Minimum Connection Interval.
rgrover1 346:14b090482fd2 263 if ((p_conn_int->min_conn_interval < 0x0006) ||
rgrover1 346:14b090482fd2 264 (
rgrover1 346:14b090482fd2 265 (p_conn_int->min_conn_interval > 0x0c80) &&
rgrover1 346:14b090482fd2 266 (p_conn_int->min_conn_interval != 0xffff)
rgrover1 346:14b090482fd2 267 )
rgrover1 346:14b090482fd2 268 )
rgrover1 346:14b090482fd2 269 {
rgrover1 346:14b090482fd2 270 return NRF_ERROR_INVALID_PARAM;
rgrover1 346:14b090482fd2 271 }
rgrover1 346:14b090482fd2 272
rgrover1 346:14b090482fd2 273 // Check Maximum Connection Interval.
rgrover1 346:14b090482fd2 274 if ((p_conn_int->max_conn_interval < 0x0006) ||
rgrover1 346:14b090482fd2 275 (
rgrover1 346:14b090482fd2 276 (p_conn_int->max_conn_interval > 0x0c80) &&
rgrover1 346:14b090482fd2 277 (p_conn_int->max_conn_interval != 0xffff)
rgrover1 346:14b090482fd2 278 )
rgrover1 346:14b090482fd2 279 )
rgrover1 346:14b090482fd2 280 {
rgrover1 346:14b090482fd2 281 return NRF_ERROR_INVALID_PARAM;
rgrover1 346:14b090482fd2 282 }
rgrover1 346:14b090482fd2 283
rgrover1 346:14b090482fd2 284 // Make sure Minimum Connection Interval is not bigger than Maximum Connection Interval.
rgrover1 346:14b090482fd2 285 if ((p_conn_int->min_conn_interval != 0xffff) &&
rgrover1 346:14b090482fd2 286 (p_conn_int->max_conn_interval != 0xffff) &&
rgrover1 346:14b090482fd2 287 (p_conn_int->min_conn_interval > p_conn_int->max_conn_interval)
rgrover1 346:14b090482fd2 288 )
rgrover1 346:14b090482fd2 289 {
rgrover1 346:14b090482fd2 290 return NRF_ERROR_INVALID_PARAM;
rgrover1 346:14b090482fd2 291 }
rgrover1 346:14b090482fd2 292
rgrover1 346:14b090482fd2 293 return NRF_SUCCESS;
rgrover1 346:14b090482fd2 294 }
rgrover1 346:14b090482fd2 295
rgrover1 346:14b090482fd2 296
rgrover1 346:14b090482fd2 297 static uint32_t conn_int_encode(const ble_advdata_conn_int_t * p_conn_int,
rgrover1 346:14b090482fd2 298 uint8_t * p_encoded_data,
rgrover1 346:14b090482fd2 299 uint8_t * p_len)
rgrover1 346:14b090482fd2 300 {
rgrover1 346:14b090482fd2 301 uint32_t err_code;
rgrover1 346:14b090482fd2 302
rgrover1 346:14b090482fd2 303 // Check for buffer overflow.
rgrover1 346:14b090482fd2 304 if ((*p_len) + ADV_DATA_OFFSET + 2 * sizeof(uint16_le_t) > BLE_GAP_ADV_MAX_SIZE)
rgrover1 346:14b090482fd2 305 {
rgrover1 346:14b090482fd2 306 return NRF_ERROR_DATA_SIZE;
rgrover1 346:14b090482fd2 307 }
rgrover1 346:14b090482fd2 308
rgrover1 346:14b090482fd2 309 // Check parameters.
rgrover1 346:14b090482fd2 310 err_code = conn_int_check(p_conn_int);
rgrover1 346:14b090482fd2 311 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 312 {
rgrover1 346:14b090482fd2 313 return err_code;
rgrover1 346:14b090482fd2 314 }
rgrover1 346:14b090482fd2 315
rgrover1 346:14b090482fd2 316 // Encode Length and AD Type.
rgrover1 346:14b090482fd2 317 p_encoded_data[(*p_len)++] = 1 + 2 * sizeof(uint16_le_t);
rgrover1 346:14b090482fd2 318 p_encoded_data[(*p_len)++] = BLE_GAP_AD_TYPE_SLAVE_CONNECTION_INTERVAL_RANGE;
rgrover1 346:14b090482fd2 319
rgrover1 346:14b090482fd2 320 // Encode Minimum and Maximum Connection Intervals.
rgrover1 346:14b090482fd2 321 (*p_len) += uint16_encode(p_conn_int->min_conn_interval, &p_encoded_data[*p_len]);
rgrover1 346:14b090482fd2 322 (*p_len) += uint16_encode(p_conn_int->max_conn_interval, &p_encoded_data[*p_len]);
rgrover1 346:14b090482fd2 323
rgrover1 346:14b090482fd2 324 return NRF_SUCCESS;
rgrover1 346:14b090482fd2 325 }
rgrover1 346:14b090482fd2 326
rgrover1 346:14b090482fd2 327
rgrover1 346:14b090482fd2 328 static uint32_t manuf_specific_data_encode(const ble_advdata_manuf_data_t * p_manuf_sp_data,
rgrover1 346:14b090482fd2 329 uint8_t * p_encoded_data,
rgrover1 346:14b090482fd2 330 uint8_t * p_len)
rgrover1 346:14b090482fd2 331 {
rgrover1 346:14b090482fd2 332 uint8_t data_size = sizeof(uint16_le_t) + p_manuf_sp_data->data.size;
rgrover1 346:14b090482fd2 333
rgrover1 346:14b090482fd2 334 // Check for buffer overflow.
rgrover1 346:14b090482fd2 335 if ((*p_len) + ADV_DATA_OFFSET + data_size > BLE_GAP_ADV_MAX_SIZE)
rgrover1 346:14b090482fd2 336 {
rgrover1 346:14b090482fd2 337 return NRF_ERROR_DATA_SIZE;
rgrover1 346:14b090482fd2 338 }
rgrover1 346:14b090482fd2 339
rgrover1 346:14b090482fd2 340 // Encode Length and AD Type.
rgrover1 346:14b090482fd2 341 p_encoded_data[(*p_len)++] = 1 + data_size;
rgrover1 346:14b090482fd2 342 p_encoded_data[(*p_len)++] = BLE_GAP_AD_TYPE_MANUFACTURER_SPECIFIC_DATA;
rgrover1 346:14b090482fd2 343
rgrover1 346:14b090482fd2 344 // Encode Company Identifier.
rgrover1 346:14b090482fd2 345 (*p_len) += uint16_encode(p_manuf_sp_data->company_identifier, &p_encoded_data[*p_len]);
rgrover1 346:14b090482fd2 346
rgrover1 346:14b090482fd2 347 // Encode additional manufacturer specific data.
rgrover1 346:14b090482fd2 348 if (p_manuf_sp_data->data.size > 0)
rgrover1 346:14b090482fd2 349 {
rgrover1 346:14b090482fd2 350 if (p_manuf_sp_data->data.p_data == NULL)
rgrover1 346:14b090482fd2 351 {
rgrover1 346:14b090482fd2 352 return NRF_ERROR_INVALID_PARAM;
rgrover1 346:14b090482fd2 353 }
rgrover1 346:14b090482fd2 354 memcpy(&p_encoded_data[*p_len], p_manuf_sp_data->data.p_data, p_manuf_sp_data->data.size);
rgrover1 346:14b090482fd2 355 (*p_len) += p_manuf_sp_data->data.size;
rgrover1 346:14b090482fd2 356 }
rgrover1 346:14b090482fd2 357
rgrover1 346:14b090482fd2 358 return NRF_SUCCESS;
rgrover1 346:14b090482fd2 359 }
rgrover1 346:14b090482fd2 360
rgrover1 346:14b090482fd2 361
rgrover1 346:14b090482fd2 362 static uint32_t service_data_encode(const ble_advdata_t * p_advdata,
rgrover1 346:14b090482fd2 363 uint8_t * p_encoded_data,
rgrover1 346:14b090482fd2 364 uint8_t * p_len)
rgrover1 346:14b090482fd2 365 {
rgrover1 346:14b090482fd2 366 uint8_t i;
rgrover1 346:14b090482fd2 367
rgrover1 346:14b090482fd2 368 // Check parameter consistency.
rgrover1 346:14b090482fd2 369 if (p_advdata->p_service_data_array == NULL)
rgrover1 346:14b090482fd2 370 {
rgrover1 346:14b090482fd2 371 return NRF_ERROR_INVALID_PARAM;
rgrover1 346:14b090482fd2 372 }
rgrover1 346:14b090482fd2 373
rgrover1 346:14b090482fd2 374 for (i = 0; i < p_advdata->service_data_count; i++)
rgrover1 346:14b090482fd2 375 {
rgrover1 346:14b090482fd2 376 ble_advdata_service_data_t * p_service_data;
rgrover1 346:14b090482fd2 377 uint8_t data_size;
rgrover1 346:14b090482fd2 378
rgrover1 346:14b090482fd2 379 p_service_data = &p_advdata->p_service_data_array[i];
rgrover1 346:14b090482fd2 380 data_size = sizeof(uint16_le_t) + p_service_data->data.size;
rgrover1 346:14b090482fd2 381
rgrover1 346:14b090482fd2 382 // Encode Length and AD Type.
rgrover1 346:14b090482fd2 383 p_encoded_data[(*p_len)++] = 1 + data_size;
rgrover1 346:14b090482fd2 384 p_encoded_data[(*p_len)++] = BLE_GAP_AD_TYPE_SERVICE_DATA;
rgrover1 346:14b090482fd2 385
rgrover1 346:14b090482fd2 386 // Encode service UUID.
rgrover1 346:14b090482fd2 387 (*p_len) += uint16_encode(p_service_data->service_uuid, &p_encoded_data[*p_len]);
rgrover1 346:14b090482fd2 388
rgrover1 346:14b090482fd2 389 // Encode additional service data.
rgrover1 346:14b090482fd2 390 if (p_service_data->data.size > 0)
rgrover1 346:14b090482fd2 391 {
rgrover1 346:14b090482fd2 392 if (p_service_data->data.p_data == NULL)
rgrover1 346:14b090482fd2 393 {
rgrover1 346:14b090482fd2 394 return NRF_ERROR_INVALID_PARAM;
rgrover1 346:14b090482fd2 395 }
rgrover1 346:14b090482fd2 396 memcpy(&p_encoded_data[*p_len], p_service_data->data.p_data, p_service_data->data.size);
rgrover1 346:14b090482fd2 397 (*p_len) += p_service_data->data.size;
rgrover1 346:14b090482fd2 398 }
rgrover1 346:14b090482fd2 399 }
rgrover1 346:14b090482fd2 400
rgrover1 346:14b090482fd2 401 return NRF_SUCCESS;
rgrover1 346:14b090482fd2 402 }
rgrover1 346:14b090482fd2 403
rgrover1 346:14b090482fd2 404
rgrover1 346:14b090482fd2 405 static uint32_t adv_data_encode(const ble_advdata_t * p_advdata,
rgrover1 346:14b090482fd2 406 uint8_t * p_encoded_data,
rgrover1 346:14b090482fd2 407 uint8_t * p_len)
rgrover1 346:14b090482fd2 408 {
rgrover1 346:14b090482fd2 409 uint32_t err_code = NRF_SUCCESS;
rgrover1 346:14b090482fd2 410
rgrover1 346:14b090482fd2 411 *p_len = 0;
rgrover1 346:14b090482fd2 412
rgrover1 346:14b090482fd2 413 // Encode name.
rgrover1 346:14b090482fd2 414 if (p_advdata->name_type != BLE_ADVDATA_NO_NAME)
rgrover1 346:14b090482fd2 415 {
rgrover1 346:14b090482fd2 416 err_code = name_encode(p_advdata, p_encoded_data, p_len);
rgrover1 346:14b090482fd2 417 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 418 {
rgrover1 346:14b090482fd2 419 return err_code;
rgrover1 346:14b090482fd2 420 }
rgrover1 346:14b090482fd2 421 }
rgrover1 346:14b090482fd2 422
rgrover1 346:14b090482fd2 423 // Encode appearance.
rgrover1 346:14b090482fd2 424 if (p_advdata->include_appearance)
rgrover1 346:14b090482fd2 425 {
rgrover1 346:14b090482fd2 426 err_code = appearance_encode(p_encoded_data, p_len);
rgrover1 346:14b090482fd2 427 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 428 {
rgrover1 346:14b090482fd2 429 return err_code;
rgrover1 346:14b090482fd2 430 }
rgrover1 346:14b090482fd2 431 }
rgrover1 346:14b090482fd2 432
rgrover1 346:14b090482fd2 433 if(p_advdata->flags != 0 )
rgrover1 346:14b090482fd2 434 {
rgrover1 346:14b090482fd2 435 // Encode flags.
rgrover1 346:14b090482fd2 436 p_encoded_data[(*p_len)++] = 1 + sizeof(uint8_t);
rgrover1 346:14b090482fd2 437 p_encoded_data[(*p_len)++] = BLE_GAP_AD_TYPE_FLAGS;
rgrover1 346:14b090482fd2 438 p_encoded_data[(*p_len)++] = p_advdata->flags;
rgrover1 346:14b090482fd2 439 }
rgrover1 346:14b090482fd2 440
rgrover1 346:14b090482fd2 441 // Encode TX power level.
rgrover1 346:14b090482fd2 442 if (p_advdata->p_tx_power_level != NULL)
rgrover1 346:14b090482fd2 443 {
rgrover1 346:14b090482fd2 444 err_code = tx_power_level_encode(*p_advdata->p_tx_power_level, p_encoded_data, p_len);
rgrover1 346:14b090482fd2 445 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 446 {
rgrover1 346:14b090482fd2 447 return err_code;
rgrover1 346:14b090482fd2 448 }
rgrover1 346:14b090482fd2 449 }
rgrover1 346:14b090482fd2 450
rgrover1 346:14b090482fd2 451 // Encode 'more available' uuid list.
rgrover1 346:14b090482fd2 452 if (p_advdata->uuids_more_available.uuid_cnt > 0)
rgrover1 346:14b090482fd2 453 {
rgrover1 346:14b090482fd2 454 err_code = uuid_list_encode(&p_advdata->uuids_more_available,
rgrover1 346:14b090482fd2 455 BLE_GAP_AD_TYPE_16BIT_SERVICE_UUID_MORE_AVAILABLE,
rgrover1 346:14b090482fd2 456 BLE_GAP_AD_TYPE_128BIT_SERVICE_UUID_MORE_AVAILABLE,
rgrover1 346:14b090482fd2 457 p_encoded_data,
rgrover1 346:14b090482fd2 458 p_len);
rgrover1 346:14b090482fd2 459 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 460 {
rgrover1 346:14b090482fd2 461 return err_code;
rgrover1 346:14b090482fd2 462 }
rgrover1 346:14b090482fd2 463 }
rgrover1 346:14b090482fd2 464
rgrover1 346:14b090482fd2 465 // Encode 'complete' uuid list.
rgrover1 346:14b090482fd2 466 if (p_advdata->uuids_complete.uuid_cnt > 0)
rgrover1 346:14b090482fd2 467 {
rgrover1 346:14b090482fd2 468 err_code = uuid_list_encode(&p_advdata->uuids_complete,
rgrover1 346:14b090482fd2 469 BLE_GAP_AD_TYPE_16BIT_SERVICE_UUID_COMPLETE,
rgrover1 346:14b090482fd2 470 BLE_GAP_AD_TYPE_128BIT_SERVICE_UUID_COMPLETE,
rgrover1 346:14b090482fd2 471 p_encoded_data,
rgrover1 346:14b090482fd2 472 p_len);
rgrover1 346:14b090482fd2 473 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 474 {
rgrover1 346:14b090482fd2 475 return err_code;
rgrover1 346:14b090482fd2 476 }
rgrover1 346:14b090482fd2 477 }
rgrover1 346:14b090482fd2 478
rgrover1 346:14b090482fd2 479 // Encode 'solicited service' uuid list.
rgrover1 346:14b090482fd2 480 if (p_advdata->uuids_solicited.uuid_cnt > 0)
rgrover1 346:14b090482fd2 481 {
rgrover1 346:14b090482fd2 482 err_code = uuid_list_encode(&p_advdata->uuids_solicited,
rgrover1 346:14b090482fd2 483 BLE_GAP_AD_TYPE_SOLICITED_SERVICE_UUIDS_16BIT,
rgrover1 346:14b090482fd2 484 BLE_GAP_AD_TYPE_SOLICITED_SERVICE_UUIDS_128BIT,
rgrover1 346:14b090482fd2 485 p_encoded_data,
rgrover1 346:14b090482fd2 486 p_len);
rgrover1 346:14b090482fd2 487 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 488 {
rgrover1 346:14b090482fd2 489 return err_code;
rgrover1 346:14b090482fd2 490 }
rgrover1 346:14b090482fd2 491 }
rgrover1 346:14b090482fd2 492
rgrover1 346:14b090482fd2 493 // Encode Slave Connection Interval Range.
rgrover1 346:14b090482fd2 494 if (p_advdata->p_slave_conn_int != NULL)
rgrover1 346:14b090482fd2 495 {
rgrover1 346:14b090482fd2 496 err_code = conn_int_encode(p_advdata->p_slave_conn_int, p_encoded_data, p_len);
rgrover1 346:14b090482fd2 497 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 498 {
rgrover1 346:14b090482fd2 499 return err_code;
rgrover1 346:14b090482fd2 500 }
rgrover1 346:14b090482fd2 501 }
rgrover1 346:14b090482fd2 502
rgrover1 346:14b090482fd2 503 // Encode Manufacturer Specific Data.
rgrover1 346:14b090482fd2 504 if (p_advdata->p_manuf_specific_data != NULL)
rgrover1 346:14b090482fd2 505 {
rgrover1 346:14b090482fd2 506 err_code = manuf_specific_data_encode(p_advdata->p_manuf_specific_data,
rgrover1 346:14b090482fd2 507 p_encoded_data,
rgrover1 346:14b090482fd2 508 p_len);
rgrover1 346:14b090482fd2 509 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 510 {
rgrover1 346:14b090482fd2 511 return err_code;
rgrover1 346:14b090482fd2 512 }
rgrover1 346:14b090482fd2 513 }
rgrover1 346:14b090482fd2 514
rgrover1 346:14b090482fd2 515 // Encode Service Data.
rgrover1 346:14b090482fd2 516 if (p_advdata->service_data_count > 0)
rgrover1 346:14b090482fd2 517 {
rgrover1 346:14b090482fd2 518 err_code = service_data_encode(p_advdata, p_encoded_data, p_len);
rgrover1 346:14b090482fd2 519 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 520 {
rgrover1 346:14b090482fd2 521 return err_code;
rgrover1 346:14b090482fd2 522 }
rgrover1 346:14b090482fd2 523 }
rgrover1 346:14b090482fd2 524
rgrover1 346:14b090482fd2 525 return err_code;
rgrover1 346:14b090482fd2 526 }
rgrover1 346:14b090482fd2 527
rgrover1 346:14b090482fd2 528
rgrover1 346:14b090482fd2 529 static uint32_t advdata_check(const ble_advdata_t * p_advdata)
rgrover1 346:14b090482fd2 530 {
rgrover1 346:14b090482fd2 531 // Flags must be included in advertising data, and the BLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED flag must be set.
rgrover1 346:14b090482fd2 532 if (
rgrover1 346:14b090482fd2 533 ((p_advdata->flags & BLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED) == 0)
rgrover1 346:14b090482fd2 534 )
rgrover1 346:14b090482fd2 535 {
rgrover1 346:14b090482fd2 536 return NRF_ERROR_INVALID_PARAM;
rgrover1 346:14b090482fd2 537 }
rgrover1 346:14b090482fd2 538
rgrover1 346:14b090482fd2 539 return NRF_SUCCESS;
rgrover1 346:14b090482fd2 540 }
rgrover1 346:14b090482fd2 541
rgrover1 346:14b090482fd2 542
rgrover1 346:14b090482fd2 543 static uint32_t srdata_check(const ble_advdata_t * p_srdata)
rgrover1 346:14b090482fd2 544 {
rgrover1 346:14b090482fd2 545 // Flags shall not be included in the scan response data.
rgrover1 346:14b090482fd2 546 if (p_srdata->flags)
rgrover1 346:14b090482fd2 547 {
rgrover1 346:14b090482fd2 548 return NRF_ERROR_INVALID_PARAM;
rgrover1 346:14b090482fd2 549 }
rgrover1 346:14b090482fd2 550
rgrover1 346:14b090482fd2 551 return NRF_SUCCESS;
rgrover1 346:14b090482fd2 552 }
rgrover1 346:14b090482fd2 553
rgrover1 346:14b090482fd2 554
rgrover1 346:14b090482fd2 555 uint32_t ble_advdata_set(const ble_advdata_t * p_advdata, const ble_advdata_t * p_srdata)
rgrover1 346:14b090482fd2 556 {
rgrover1 346:14b090482fd2 557 uint32_t err_code;
rgrover1 346:14b090482fd2 558 uint8_t len_advdata = 0;
rgrover1 346:14b090482fd2 559 uint8_t len_srdata = 0;
rgrover1 346:14b090482fd2 560 uint8_t encoded_advdata[BLE_GAP_ADV_MAX_SIZE];
rgrover1 346:14b090482fd2 561 uint8_t encoded_srdata[BLE_GAP_ADV_MAX_SIZE];
rgrover1 346:14b090482fd2 562 uint8_t * p_encoded_advdata;
rgrover1 346:14b090482fd2 563 uint8_t * p_encoded_srdata;
rgrover1 346:14b090482fd2 564
rgrover1 346:14b090482fd2 565 // Encode advertising data (if supplied).
rgrover1 346:14b090482fd2 566 if (p_advdata != NULL)
rgrover1 346:14b090482fd2 567 {
rgrover1 346:14b090482fd2 568 err_code = advdata_check(p_advdata);
rgrover1 346:14b090482fd2 569 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 570 {
rgrover1 346:14b090482fd2 571 return err_code;
rgrover1 346:14b090482fd2 572 }
rgrover1 346:14b090482fd2 573
rgrover1 346:14b090482fd2 574 err_code = adv_data_encode(p_advdata, encoded_advdata, &len_advdata);
rgrover1 346:14b090482fd2 575 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 576 {
rgrover1 346:14b090482fd2 577 return err_code;
rgrover1 346:14b090482fd2 578 }
rgrover1 346:14b090482fd2 579 p_encoded_advdata = encoded_advdata;
rgrover1 346:14b090482fd2 580 }
rgrover1 346:14b090482fd2 581 else
rgrover1 346:14b090482fd2 582 {
rgrover1 346:14b090482fd2 583 p_encoded_advdata = NULL;
rgrover1 346:14b090482fd2 584 }
rgrover1 346:14b090482fd2 585
rgrover1 346:14b090482fd2 586 // Encode scan response data (if supplied).
rgrover1 346:14b090482fd2 587 if (p_srdata != NULL)
rgrover1 346:14b090482fd2 588 {
rgrover1 346:14b090482fd2 589 err_code = srdata_check(p_srdata);
rgrover1 346:14b090482fd2 590 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 591 {
rgrover1 346:14b090482fd2 592 return err_code;
rgrover1 346:14b090482fd2 593 }
rgrover1 346:14b090482fd2 594
rgrover1 346:14b090482fd2 595 err_code = adv_data_encode(p_srdata, encoded_srdata, &len_srdata);
rgrover1 346:14b090482fd2 596 if (err_code != NRF_SUCCESS)
rgrover1 346:14b090482fd2 597 {
rgrover1 346:14b090482fd2 598 return err_code;
rgrover1 346:14b090482fd2 599 }
rgrover1 346:14b090482fd2 600 p_encoded_srdata = encoded_srdata;
rgrover1 346:14b090482fd2 601 }
rgrover1 346:14b090482fd2 602 else
rgrover1 346:14b090482fd2 603 {
rgrover1 346:14b090482fd2 604 p_encoded_srdata = NULL;
rgrover1 346:14b090482fd2 605 }
rgrover1 346:14b090482fd2 606
rgrover1 346:14b090482fd2 607 // Pass encoded advertising data and/or scan response data to the stack.
rgrover1 346:14b090482fd2 608 return sd_ble_gap_adv_data_set(p_encoded_advdata, len_advdata, p_encoded_srdata, len_srdata);
rgrover1 346:14b090482fd2 609 }