Nordic stack and drivers for the mbed BLE API. Version to work around build bug.
Dependents: microbit_rubber_ducky microbit_mouse_BLE microbit_mouse_BLE_daybreak_version microbit_presenter
Fork of nRF51822 by
custom_helper.cpp
00001 /* mbed Microcontroller Library 00002 * Copyright (c) 2006-2013 ARM Limited 00003 * 00004 * Licensed under the Apache License, Version 2.0 (the "License"); 00005 * you may not use this file except in compliance with the License. 00006 * You may obtain a copy of the License at 00007 * 00008 * http://www.apache.org/licenses/LICENSE-2.0 00009 * 00010 * Unless required by applicable law or agreed to in writing, software 00011 * distributed under the License is distributed on an "AS IS" BASIS, 00012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00013 * See the License for the specific language governing permissions and 00014 * limitations under the License. 00015 */ 00016 00017 #include "custom_helper.h" 00018 00019 /* 00020 * The current version of the soft-device doesn't handle duplicate 128-bit UUIDs 00021 * very well. It is therefore necessary to filter away duplicates before 00022 * passing long UUIDs to sd_ble_uuid_vs_add(). The following types and data 00023 * structures involved in maintaining a local cache of 128-bit UUIDs. 00024 */ 00025 typedef struct { 00026 UUID::LongUUIDBytes_t uuid; 00027 uint8_t type; 00028 } converted_uuid_table_entry_t; 00029 static const unsigned UUID_TABLE_MAX_ENTRIES = 4; /* This is the maximum number of 128-bit UUIDs with distinct bases that 00030 * we expect to be in use; increase this limit if needed. */ 00031 static unsigned uuidTableEntries = 0; /* current usage of the table */ 00032 converted_uuid_table_entry_t convertedUUIDTable[UUID_TABLE_MAX_ENTRIES]; 00033 00034 /** 00035 * lookup the cache of previously converted 128-bit UUIDs to find a type value. 00036 * @param uuid base 128-bit UUID 00037 * @param recoveredType the type field of the 3-byte nRF's uuid. 00038 * @return true if a match is found. 00039 */ 00040 static bool 00041 lookupConvertedUUIDTable(const UUID::LongUUIDBytes_t uuid, uint8_t *recoveredType) 00042 { 00043 unsigned i; 00044 for (i = 0; i < uuidTableEntries; i++) { 00045 unsigned byteIndex; 00046 for (byteIndex = 0; byteIndex < UUID::LENGTH_OF_LONG_UUID; byteIndex++) { 00047 /* Skip bytes 2 and 3, because they contain the shortUUID (16-bit) version of the 00048 * long UUID; and we're comparing against the remainder. */ 00049 if ((byteIndex == 2) || (byteIndex == 3)) { 00050 continue; 00051 } 00052 00053 if (convertedUUIDTable[i].uuid[byteIndex] != uuid[byteIndex]) { 00054 break; 00055 } 00056 } 00057 00058 if (byteIndex == UUID::LENGTH_OF_LONG_UUID) { 00059 *recoveredType = convertedUUIDTable[i].type; 00060 return true; 00061 } 00062 } 00063 00064 return false; 00065 } 00066 00067 static void 00068 addToConvertedUUIDTable(const UUID::LongUUIDBytes_t uuid, uint8_t type) 00069 { 00070 if (uuidTableEntries == UUID_TABLE_MAX_ENTRIES) { 00071 return; /* recovery needed; or at least the user should be warned about this fact.*/ 00072 } 00073 00074 memcpy(convertedUUIDTable[uuidTableEntries].uuid, uuid, UUID::LENGTH_OF_LONG_UUID); 00075 convertedUUIDTable[uuidTableEntries].uuid[2] = 0; 00076 convertedUUIDTable[uuidTableEntries].uuid[3] = 0; 00077 convertedUUIDTable[uuidTableEntries].type = type; 00078 uuidTableEntries++; 00079 } 00080 00081 /** 00082 * The nRF transport has its own 3-byte representation of a UUID. If the user- 00083 * specified UUID is 128-bits wide, then the UUID base needs to be added to the 00084 * soft-device and converted to a 3-byte handle before being used further. This 00085 * function is responsible for this translation of user-specified UUIDs into 00086 * nRF's representation. 00087 * 00088 * @param[in] uuid 00089 * user-specified UUID 00090 * @return nRF 00091 * 3-byte UUID (containing a type and 16-bit UUID) representation 00092 * to be used with SVC calls. 00093 */ 00094 ble_uuid_t custom_convert_to_nordic_uuid(const UUID &uuid) 00095 { 00096 ble_uuid_t nordicUUID; 00097 nordicUUID.uuid = uuid.getShortUUID(); 00098 nordicUUID.type = BLE_UUID_TYPE_UNKNOWN; /* to be set below */ 00099 00100 if (uuid.shortOrLong() == UUID::UUID_TYPE_SHORT) { 00101 nordicUUID.type = BLE_UUID_TYPE_BLE; 00102 } else { 00103 if (!lookupConvertedUUIDTable(uuid.getBaseUUID(), &nordicUUID.type)) { 00104 nordicUUID.type = custom_add_uuid_base(uuid.getBaseUUID()); 00105 addToConvertedUUIDTable(uuid.getBaseUUID(), nordicUUID.type); 00106 } 00107 } 00108 00109 return nordicUUID; 00110 } 00111 00112 /**************************************************************************/ 00113 /*! 00114 @brief Adds the base UUID to the custom service. All UUIDs used 00115 by this service are based on this 128-bit UUID. 00116 00117 @note This UUID needs to be added to the SoftDevice stack before 00118 adding the service's primary service via 00119 'sd_ble_gatts_service_add' 00120 00121 @param[in] p_uuid_base A pointer to the 128-bit UUID array (8*16) 00122 00123 @returns The UUID type. 00124 A return value of 0 should be considered an error. 00125 00126 @retval 0x00 BLE_UUID_TYPE_UNKNOWN 00127 @retval 0x01 BLE_UUID_TYPE_BLE 00128 @retval 0x02 BLE_UUID_TYPE_VENDOR_BEGIN 00129 00130 @section EXAMPLE 00131 @code 00132 00133 // Take note that bytes 2/3 are blank since these are used to identify 00134 // the primary service and individual characteristics 00135 #define CFG_CUSTOM_UUID_BASE "\x6E\x40\x00\x00\xB5\xA3\xF3\x93\xE0\xA9\xE5\x0E\x24\xDC\xCA\x9E" 00136 00137 uint8_t uuid_type = custom_add_uuid_base(CFG_CUSTOM_UUID_BASE); 00138 ASSERT(uuid_type > 0, ERROR_NOT_FOUND); 00139 00140 // We can now safely add the primary service and any characteristics 00141 // for our custom service ... 00142 00143 @endcode 00144 */ 00145 /**************************************************************************/ 00146 uint8_t custom_add_uuid_base(uint8_t const *const p_uuid_base) 00147 { 00148 ble_uuid128_t base_uuid; 00149 uint8_t uuid_type = 0; 00150 00151 for (unsigned i = 0; i < UUID::LENGTH_OF_LONG_UUID; i++) { 00152 base_uuid.uuid128[i] = p_uuid_base[i]; 00153 } 00154 00155 ASSERT_INT( ERROR_NONE, sd_ble_uuid_vs_add( &base_uuid, &uuid_type ), 0); 00156 00157 return uuid_type; 00158 } 00159 00160 /**************************************************************************/ 00161 /*! 00162 00163 */ 00164 /**************************************************************************/ 00165 error_t custom_decode_uuid_base(uint8_t const *const p_uuid_base, 00166 ble_uuid_t *p_uuid) 00167 { 00168 UUID::LongUUIDBytes_t uuid_base_le; 00169 00170 for (uint8_t i = 0; i < UUID::LENGTH_OF_LONG_UUID; i++) { 00171 uuid_base_le[i] = p_uuid_base[i]; 00172 } 00173 00174 ASSERT_STATUS( sd_ble_uuid_decode(UUID::LENGTH_OF_LONG_UUID, uuid_base_le, p_uuid)); 00175 00176 return ERROR_NONE; 00177 } 00178 00179 /**************************************************************************/ 00180 /*! 00181 @brief Adds a new characteristic to the custom service, assigning 00182 properties, a UUID add-on value, etc. 00183 00184 @param[in] service_handle 00185 @param[in] p_uuid The 16-bit value to add to the base UUID 00186 for this characteristic (normally >1 00187 since 1 is typically used by the primary 00188 service). 00189 @param[in] char_props The characteristic properties, as 00190 defined by ble_gatt_char_props_t 00191 @param[in] max_length The maximum length of this characeristic 00192 @param[in] has_variable_len Whether the characteristic data has 00193 variable length. 00194 @param[out] p_char_handle 00195 00196 @returns 00197 @retval ERROR_NONE Everything executed normally 00198 */ 00199 /**************************************************************************/ 00200 error_t custom_add_in_characteristic(uint16_t service_handle, 00201 ble_uuid_t *p_uuid, 00202 uint8_t properties, 00203 SecurityManager::SecurityMode_t requiredSecurity, 00204 uint8_t *p_data, 00205 uint16_t length, 00206 uint16_t max_length, 00207 bool has_variable_len, 00208 const uint8_t *userDescriptionDescriptorValuePtr, 00209 uint16_t userDescriptionDescriptorValueLen, 00210 bool readAuthorization, 00211 bool writeAuthorization, 00212 ble_gatts_char_handles_t *p_char_handle) 00213 { 00214 /* Characteristic metadata */ 00215 ble_gatts_attr_md_t cccd_md; 00216 ble_gatt_char_props_t char_props; 00217 00218 memcpy(&char_props, &properties, 1); 00219 00220 if (char_props.notify || char_props.indicate) { 00221 /* Notification requires cccd */ 00222 memclr_( &cccd_md, sizeof(ble_gatts_attr_md_t)); 00223 cccd_md.vloc = BLE_GATTS_VLOC_STACK; 00224 BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.read_perm); 00225 BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.write_perm); 00226 } 00227 00228 ble_gatts_char_md_t char_md = {0}; 00229 00230 char_md.char_props = char_props; 00231 char_md.p_cccd_md = 00232 (char_props.notify || char_props.indicate) ? &cccd_md : NULL; 00233 if ((userDescriptionDescriptorValueLen > 0) && (userDescriptionDescriptorValuePtr != NULL)) { 00234 char_md.p_char_user_desc = const_cast<uint8_t *>(userDescriptionDescriptorValuePtr); 00235 char_md.char_user_desc_max_size = userDescriptionDescriptorValueLen; 00236 char_md.char_user_desc_size = userDescriptionDescriptorValueLen; 00237 } 00238 00239 /* Attribute declaration */ 00240 ble_gatts_attr_md_t attr_md = {0}; 00241 00242 attr_md.rd_auth = readAuthorization; 00243 attr_md.wr_auth = writeAuthorization; 00244 00245 attr_md.vloc = BLE_GATTS_VLOC_STACK; 00246 /* Always set variable size */ 00247 attr_md.vlen = has_variable_len; 00248 00249 if (char_props.read || char_props.notify || char_props.indicate) { 00250 switch (requiredSecurity) { 00251 case SecurityManager::SECURITY_MODE_ENCRYPTION_OPEN_LINK : 00252 BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.read_perm); 00253 break; 00254 case SecurityManager::SECURITY_MODE_ENCRYPTION_NO_MITM : 00255 BLE_GAP_CONN_SEC_MODE_SET_ENC_NO_MITM(&attr_md.read_perm); 00256 break; 00257 case SecurityManager::SECURITY_MODE_ENCRYPTION_WITH_MITM : 00258 BLE_GAP_CONN_SEC_MODE_SET_ENC_WITH_MITM(&attr_md.read_perm); 00259 break; 00260 case SecurityManager::SECURITY_MODE_SIGNED_NO_MITM : 00261 BLE_GAP_CONN_SEC_MODE_SET_SIGNED_NO_MITM(&attr_md.read_perm); 00262 break; 00263 case SecurityManager::SECURITY_MODE_SIGNED_WITH_MITM : 00264 BLE_GAP_CONN_SEC_MODE_SET_SIGNED_WITH_MITM(&attr_md.read_perm); 00265 break; 00266 default: 00267 break; 00268 }; 00269 } 00270 00271 if (char_props.write || char_props.write_wo_resp) { 00272 switch (requiredSecurity) { 00273 case SecurityManager::SECURITY_MODE_ENCRYPTION_OPEN_LINK : 00274 BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.write_perm); 00275 break; 00276 case SecurityManager::SECURITY_MODE_ENCRYPTION_NO_MITM : 00277 BLE_GAP_CONN_SEC_MODE_SET_ENC_NO_MITM(&attr_md.write_perm); 00278 break; 00279 case SecurityManager::SECURITY_MODE_ENCRYPTION_WITH_MITM : 00280 BLE_GAP_CONN_SEC_MODE_SET_ENC_WITH_MITM(&attr_md.write_perm); 00281 break; 00282 case SecurityManager::SECURITY_MODE_SIGNED_NO_MITM : 00283 BLE_GAP_CONN_SEC_MODE_SET_SIGNED_NO_MITM(&attr_md.write_perm); 00284 break; 00285 case SecurityManager::SECURITY_MODE_SIGNED_WITH_MITM : 00286 BLE_GAP_CONN_SEC_MODE_SET_SIGNED_WITH_MITM(&attr_md.write_perm); 00287 break; 00288 default: 00289 break; 00290 }; 00291 } 00292 00293 ble_gatts_attr_t attr_char_value = {0}; 00294 00295 attr_char_value.p_uuid = p_uuid; 00296 attr_char_value.p_attr_md = &attr_md; 00297 attr_char_value.init_len = length; 00298 attr_char_value.max_len = max_length; 00299 attr_char_value.p_value = p_data; 00300 00301 ASSERT_STATUS ( sd_ble_gatts_characteristic_add(service_handle, 00302 &char_md, 00303 &attr_char_value, 00304 p_char_handle)); 00305 00306 return ERROR_NONE; 00307 } 00308 00309 00310 00311 /**************************************************************************/ 00312 /*! 00313 @brief Adds a new descriptor to the custom service, assigning 00314 value, a UUID add-on value, etc. 00315 00316 @param[in] char_handle 00317 @param[in] p_uuid The 16-bit value to add to the base UUID 00318 for this descriptor (normally >1 00319 since 1 is typically used by the primary 00320 service). 00321 @param[in] max_length The maximum length of this descriptor 00322 @param[in] has_variable_len Whether the characteristic data has 00323 variable length. 00324 00325 @returns 00326 @retval ERROR_NONE Everything executed normally 00327 */ 00328 /**************************************************************************/ 00329 error_t custom_add_in_descriptor(uint16_t char_handle, 00330 ble_uuid_t *p_uuid, 00331 uint8_t *p_data, 00332 uint16_t length, 00333 uint16_t max_length, 00334 bool has_variable_len, 00335 uint16_t *p_desc_handle) 00336 { 00337 /* Descriptor metadata */ 00338 ble_gatts_attr_md_t desc_md = {0}; 00339 00340 desc_md.vloc = BLE_GATTS_VLOC_STACK; 00341 /* Always set variable size */ 00342 desc_md.vlen = has_variable_len; 00343 00344 /* Make it readable and writable */ 00345 BLE_GAP_CONN_SEC_MODE_SET_OPEN(&desc_md.read_perm); 00346 BLE_GAP_CONN_SEC_MODE_SET_OPEN(&desc_md.write_perm); 00347 00348 ble_gatts_attr_t attr_desc = {0}; 00349 00350 attr_desc.p_uuid = p_uuid; 00351 attr_desc.p_attr_md = &desc_md; 00352 attr_desc.init_len = length; 00353 attr_desc.max_len = max_length; 00354 attr_desc.p_value = p_data; 00355 00356 ASSERT_STATUS ( sd_ble_gatts_descriptor_add(char_handle, 00357 &attr_desc, 00358 p_desc_handle)); 00359 00360 return ERROR_NONE; 00361 }
Generated on Tue Jul 12 2022 19:52:03 by 1.7.2