Francesco Pavoni / Mbed 2 deprecated BLE_Nano_Central_Type3_1

new version for central test two peripherals

Dependencies:   BLE_API mbed nRF51822

Fork of BLE_Nano_Central_Type3 by Francesco Pavoni

main.cpp@6:d37a6e3c17c4, 2016-06-02 (annotated)

Committer:
FranKP2138
Date:
Thu Jun 02 15:42:04 2016 +0000
Revision:
6:d37a6e3c17c4
Parent:
5:68a31613f28a 
Set pre state for search characteristic

Who changed what in which revision?

UserRevisionLine numberNew contents of line
FranKP2138 4:722dfc6fe1de 1 /*
FranKP2138 4:722dfc6fe1de 2 * Copyright (c) 2016 RedBear
FranKP2138 4:722dfc6fe1de 3 *
FranKP2138 4:722dfc6fe1de 4 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
FranKP2138 4:722dfc6fe1de 5 * to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
FranKP2138 4:722dfc6fe1de 6 * and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
FranKP2138 4:722dfc6fe1de 7 *
FranKP2138 4:722dfc6fe1de 8 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
FranKP2138 4:722dfc6fe1de 9 *
FranKP2138 4:722dfc6fe1de 10 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FranKP2138 4:722dfc6fe1de 11 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
FranKP2138 4:722dfc6fe1de 12 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
FranKP2138 4:722dfc6fe1de 13 * IN THE SOFTWARE.
FranKP2138 4:722dfc6fe1de 14 */
FranKP2138 4:722dfc6fe1de 15 /**
FranKP2138 4:722dfc6fe1de 16 * @brief This example is used to demonstrate central functions.
FranKP2138 4:722dfc6fe1de 17 * Device with this application will try to connect to example "BLE_HRM" or "BLE_simplePeripheral"
FranKP2138 4:722dfc6fe1de 18 * If connecting to "BLE_HRM", will get heart rate
FranKP2138 4:722dfc6fe1de 19 * If connecting to "BLE_simplePeripheral, will discovery all services and characteristics
FranKP2138 4:722dfc6fe1de 20 */
mbed_tw_hoehoe 0:83b5c6efd8d7 21 #include "mbed.h"
mbed_tw_hoehoe 0:83b5c6efd8d7 22 #include "ble/BLE.h"
mbed_tw_hoehoe 0:83b5c6efd8d7 23 #include "ble/DiscoveredCharacteristic.h"
mbed_tw_hoehoe 0:83b5c6efd8d7 24 #include "ble/DiscoveredService.h"
mbed_tw_hoehoe 3:d6f80e11a7f4 25 #include "ble/GapScanningParams.h"
mbed_tw_hoehoe 2:4b53d13d9851 26 #include "ble_radio_notification.h"
mbed_tw_hoehoe 3:d6f80e11a7f4 27 #include "ble_gap.h"
mbed_tw_hoehoe 0:83b5c6efd8d7 28
mbed_tw_hoehoe 0:83b5c6efd8d7 29 BLE ble;
mbed_tw_hoehoe 1:2f1203d70643 30 Serial pc(USBTX, USBRX);
mbed_tw_hoehoe 0:83b5c6efd8d7 31
FranKP2138 4:722dfc6fe1de 32 //const uint8_t MPU6050_service_uuid[] = {0x45,0x35,0x56,0x80,0x0F,0xD8,0x5F,0xB5,0x51,0x48,0x30,0x27,0x06,0x9B,0x3F,0xD9};
FranKP2138 4:722dfc6fe1de 33 //const uint8_t MPU6050_Accel_Characteristic_uuid[] = {0x45,0x35,0x56,0x81,0x0F,0xD8,0x5F,0xB5,0x51,0x48,0x30,0x27,0x06,0x9B,0x3F,0xD9};
FranKP2138 4:722dfc6fe1de 34
FranKP2138 4:722dfc6fe1de 35 static uint8_t service1_uuid[] = {0x71, 0x3D, 0, 0, 0x50, 0x3E, 0x4C, 0x75, 0xBA, 0x94, 0x31, 0x48, 0xF1, 0x8D, 0x94, 0x1E};
FranKP2138 4:722dfc6fe1de 36 static uint8_t service1_chars1[] = {0x71, 0x3D, 0, 2, 0x50, 0x3E, 0x4C, 0x75, 0xBA, 0x94, 0x31, 0x48, 0xF1, 0x8D, 0x94, 0x1E};
FranKP2138 4:722dfc6fe1de 37 static uint8_t service1_chars2[] = {0x71, 0x3D, 0, 3, 0x50, 0x3E, 0x4C, 0x75, 0xBA, 0x94, 0x31, 0x48, 0xF1, 0x8D, 0x94, 0x1E};
FranKP2138 4:722dfc6fe1de 38 static uint8_t service1_chars3[] = {0x71, 0x3D, 0, 4, 0x50, 0x3E, 0x4C, 0x75, 0xBA, 0x94, 0x31, 0x48, 0xF1, 0x8D, 0x94, 0x1E};
FranKP2138 4:722dfc6fe1de 39
FranKP2138 4:722dfc6fe1de 40
FranKP2138 5:68a31613f28a 41 UUID service_uuid(0x180D); // (1) this change in sensor PWM
FranKP2138 4:722dfc6fe1de 42 UUID chars_uuid1(0x2A37);
FranKP2138 4:722dfc6fe1de 43 UUID chars_uuid2(service1_chars2);
FranKP2138 4:722dfc6fe1de 44 UUID chars_uuid3(service1_chars3);
FranKP2138 4:722dfc6fe1de 45
FranKP2138 4:722dfc6fe1de 46 static uint8_t device_is_hrm = 0;
FranKP2138 4:722dfc6fe1de 47 static uint8_t device_is_simple_peripheral = 0;
mbed_tw_hoehoe 0:83b5c6efd8d7 48
FranKP2138 4:722dfc6fe1de 49 // When found the match characteristic, set 1.
FranKP2138 4:722dfc6fe1de 50 static uint8_t characteristic_is_fond = 0;
FranKP2138 4:722dfc6fe1de 51 // When found the match descriptor, set 1.
FranKP2138 4:722dfc6fe1de 52 static uint8_t descriptor_is_found = 0;
FranKP2138 4:722dfc6fe1de 53 // To save the hrm characteristic and descriptor
FranKP2138 4:722dfc6fe1de 54 static DiscoveredCharacteristic chars_hrm;
FranKP2138 4:722dfc6fe1de 55 static DiscoveredCharacteristicDescriptor desc_of_chars_hrm(NULL,GattAttribute::INVALID_HANDLE,GattAttribute::INVALID_HANDLE,UUID::ShortUUIDBytes_t(0));
mbed_tw_hoehoe 0:83b5c6efd8d7 56
FranKP2138 4:722dfc6fe1de 57 static void scanCallback(const Gap::AdvertisementCallbackParams_t *params);
FranKP2138 4:722dfc6fe1de 58 static void discoveredServiceCallBack(const DiscoveredService *service);
FranKP2138 4:722dfc6fe1de 59 static void discoveredCharacteristicCallBack(const DiscoveredCharacteristic *chars);
FranKP2138 4:722dfc6fe1de 60 static void discoveryTerminationCallBack(Gap::Handle_t connectionHandle);
FranKP2138 4:722dfc6fe1de 61 static void discoveredCharsDescriptorCallBack(const CharacteristicDescriptorDiscovery::DiscoveryCallbackParams_t *params);
FranKP2138 4:722dfc6fe1de 62 static void discoveredDescTerminationCallBack(const CharacteristicDescriptorDiscovery::TerminationCallbackParams_t *params) ;
mbed_tw_hoehoe 0:83b5c6efd8d7 63
FranKP2138 4:722dfc6fe1de 64 //DiscoveredCharacteristic accelChar;
FranKP2138 4:722dfc6fe1de 65 //UUID serviceUUID(MPU6050_service_uuid);
FranKP2138 4:722dfc6fe1de 66 //UUID accelUUID(MPU6050_Accel_Characteristic_uuid);
FranKP2138 4:722dfc6fe1de 67
FranKP2138 4:722dfc6fe1de 68 #define NUMBER_OF_PERIPHERALS 2
mbed_tw_hoehoe 3:d6f80e11a7f4 69
mbed_tw_hoehoe 3:d6f80e11a7f4 70 typedef struct {
mbed_tw_hoehoe 3:d6f80e11a7f4 71 Gap::Handle_t handle;
mbed_tw_hoehoe 3:d6f80e11a7f4 72 Gap::Address_t address;
mbed_tw_hoehoe 3:d6f80e11a7f4 73 bool connected;
mbed_tw_hoehoe 3:d6f80e11a7f4 74 uint8_t* deviceName;
mbed_tw_hoehoe 3:d6f80e11a7f4 75 } peripheral_t;
mbed_tw_hoehoe 3:d6f80e11a7f4 76
mbed_tw_hoehoe 3:d6f80e11a7f4 77 static peripheral_t gs_peripheral[NUMBER_OF_PERIPHERALS];
mbed_tw_hoehoe 3:d6f80e11a7f4 78
mbed_tw_hoehoe 3:d6f80e11a7f4 79 uint32_t ble_advdata_parser(uint8_t type, uint8_t advdata_len, uint8_t *p_advdata, uint8_t *len, uint8_t *p_field_data)
mbed_tw_hoehoe 3:d6f80e11a7f4 80 {
FranKP2138 5:68a31613f28a 81 pc.printf("ble_advdata_parse \r\n");
FranKP2138 5:68a31613f28a 82
mbed_tw_hoehoe 3:d6f80e11a7f4 83 uint8_t index=0;
mbed_tw_hoehoe 3:d6f80e11a7f4 84 uint8_t field_length, field_type;
mbed_tw_hoehoe 3:d6f80e11a7f4 85
mbed_tw_hoehoe 3:d6f80e11a7f4 86 while(index<advdata_len)
mbed_tw_hoehoe 3:d6f80e11a7f4 87 {
mbed_tw_hoehoe 3:d6f80e11a7f4 88 field_length = p_advdata[index];
mbed_tw_hoehoe 3:d6f80e11a7f4 89 field_type = p_advdata[index+1];
mbed_tw_hoehoe 3:d6f80e11a7f4 90 if(field_type == type)
mbed_tw_hoehoe 3:d6f80e11a7f4 91 {
mbed_tw_hoehoe 3:d6f80e11a7f4 92 memcpy(p_field_data, &p_advdata[index+2], (field_length-1));
mbed_tw_hoehoe 3:d6f80e11a7f4 93 *len = field_length - 1;
mbed_tw_hoehoe 3:d6f80e11a7f4 94 return NRF_SUCCESS;
mbed_tw_hoehoe 3:d6f80e11a7f4 95 }
FranKP2138 5:68a31613f28a 96 pc.printf("FOUND \r\n");
mbed_tw_hoehoe 3:d6f80e11a7f4 97 index += field_length + 1;
mbed_tw_hoehoe 3:d6f80e11a7f4 98 }
FranKP2138 5:68a31613f28a 99 pc.printf("NRF_ERROR_NOT_FOUND \r\n");
mbed_tw_hoehoe 3:d6f80e11a7f4 100 return NRF_ERROR_NOT_FOUND;
mbed_tw_hoehoe 3:d6f80e11a7f4 101 }
mbed_tw_hoehoe 0:83b5c6efd8d7 102
FranKP2138 4:722dfc6fe1de 103
FranKP2138 4:722dfc6fe1de 104 void startDiscovery(uint16_t handle) {
FranKP2138 4:722dfc6fe1de 105 /**
FranKP2138 4:722dfc6fe1de 106 * Launch service discovery. Once launched, application callbacks will beinvoked for matching services or characteristics.
FranKP2138 4:722dfc6fe1de 107 * isServiceDiscoveryActive() can be used to determine status, and a termination callback (if one was set up)will be invoked at the end.
FranKP2138 4:722dfc6fe1de 108 * Service discovery can be terminated prematurely,if needed, using terminateServiceDiscovery().
FranKP2138 4:722dfc6fe1de 109 *
FranKP2138 4:722dfc6fe1de 110 * @param[in] connectionHandle Handle for the connection with the peer.
FranKP2138 4:722dfc6fe1de 111 * @param[in] sc This is the application callback for a matching service. Taken as NULL by default.
FranKP2138 4:722dfc6fe1de 112 * Note: service discovery may still be active when this callback is issued;
FranKP2138 4:722dfc6fe1de 113 * calling asynchronous BLE-stack APIs from within this application callback might cause the stack to abort service discovery.
FranKP2138 4:722dfc6fe1de 114 * If this becomes an issue, it may be better to make a local copy of the discoveredService and wait for service discovery to terminate before operating on the service.
FranKP2138 4:722dfc6fe1de 115 * @param[in] cc This is the application callback for a matching characteristic.Taken as NULL by default.
FranKP2138 4:722dfc6fe1de 116 * Note: service discovery may still be active when this callback is issued;
FranKP2138 4:722dfc6fe1de 117 * calling asynchronous BLE-stack APIs from within this application callback might cause the stack to abort service discovery.
FranKP2138 4:722dfc6fe1de 118 * If this becomes an issue, it may be better to make a local copy of the discoveredCharacteristic and wait for service discovery to terminate before operating on the characteristic.
FranKP2138 4:722dfc6fe1de 119 * @param[in] matchingServiceUUID UUID-based filter for specifying a service in which the application is interested.
FranKP2138 4:722dfc6fe1de 120 * By default it is set as the wildcard UUID_UNKNOWN, in which case it matches all services.
FranKP2138 4:722dfc6fe1de 121 * @param[in] matchingCharacteristicUUIDIn UUID-based filter for specifying characteristic in which the application is interested.
FranKP2138 4:722dfc6fe1de 122 * By default it is set as the wildcard UUID_UKNOWN to match against any characteristic.
FranKP2138 4:722dfc6fe1de 123 *
FranKP2138 4:722dfc6fe1de 124 * @note Using wildcard values for both service-UUID and characteristic-UUID will result in complete service discovery:
FranKP2138 4:722dfc6fe1de 125 * callbacks being called for every service and characteristic.
FranKP2138 4:722dfc6fe1de 126 *
FranKP2138 4:722dfc6fe1de 127 * @note Providing NULL for the characteristic callback will result in characteristic discovery being skipped for each matching service.
FranKP2138 4:722dfc6fe1de 128 * This allows for an inexpensive method to discover only services.
FranKP2138 4:722dfc6fe1de 129 *
FranKP2138 4:722dfc6fe1de 130 * @return BLE_ERROR_NONE if service discovery is launched successfully; else an appropriate error.
FranKP2138 4:722dfc6fe1de 131 */
FranKP2138 5:68a31613f28a 132 pc.printf("start discovery \r\n");
FranKP2138 6:d37a6e3c17c4 133 if(device_is_hrm) {
FranKP2138 6:d37a6e3c17c4 134 pc.printf("device_is_hrm \r\n");
FranKP2138 6:d37a6e3c17c4 135 ble.gattClient().launchServiceDiscovery(handle, discoveredServiceCallBack, discoveredCharacteristicCallBack, service_uuid, chars_uuid1);}
FranKP2138 6:d37a6e3c17c4 136 if(device_is_simple_peripheral){
FranKP2138 6:d37a6e3c17c4 137 pc.printf("device_is_simple_peripheral \r\n");
FranKP2138 6:d37a6e3c17c4 138 ble.gattClient().launchServiceDiscovery(handle, discoveredServiceCallBack, discoveredCharacteristicCallBack);}
FranKP2138 4:722dfc6fe1de 139 }
FranKP2138 4:722dfc6fe1de 140
FranKP2138 4:722dfc6fe1de 141 /**
FranKP2138 4:722dfc6fe1de 142 * @brief Callback handle for scanning device
FranKP2138 4:722dfc6fe1de 143 *
FranKP2138 4:722dfc6fe1de 144 * @param[in] *params params->peerAddr The peer's BLE address
FranKP2138 4:722dfc6fe1de 145 * params->rssi The advertisement packet RSSI value
FranKP2138 4:722dfc6fe1de 146 * params->isScanResponse Whether this packet is the response to a scan request
FranKP2138 4:722dfc6fe1de 147 * params->type The type of advertisement
FranKP2138 4:722dfc6fe1de 148 * (enum from 0 ADV_CONNECTABLE_UNDIRECTED,ADV_CONNECTABLE_DIRECTED,ADV_SCANNABLE_UNDIRECTED,ADV_NON_CONNECTABLE_UNDIRECTED)
FranKP2138 4:722dfc6fe1de 149 * params->advertisingDataLen Length of the advertisement data
FranKP2138 4:722dfc6fe1de 150 * params->advertisingData Pointer to the advertisement packet's data
FranKP2138 4:722dfc6fe1de 151 */
FranKP2138 4:722dfc6fe1de 152
FranKP2138 4:722dfc6fe1de 153 void scanCallback(const Gap::AdvertisementCallbackParams_t *params) {
mbed_tw_hoehoe 1:2f1203d70643 154 pc.printf("adv peerAddr[%02x %02x %02x %02x %02x %02x] rssi %d, isScanResponse %u, AdvertisementType %u\r\n",
mbed_tw_hoehoe 0:83b5c6efd8d7 155 params->peerAddr[5], params->peerAddr[4], params->peerAddr[3], params->peerAddr[2], params->peerAddr[1], params->peerAddr[0],
mbed_tw_hoehoe 0:83b5c6efd8d7 156 params->rssi, params->isScanResponse, params->type);
mbed_tw_hoehoe 0:83b5c6efd8d7 157
mbed_tw_hoehoe 3:d6f80e11a7f4 158 uint8_t len;
mbed_tw_hoehoe 3:d6f80e11a7f4 159 uint8_t adv_name[31];
mbed_tw_hoehoe 3:d6f80e11a7f4 160 if( NRF_SUCCESS == ble_advdata_parser(BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME,
mbed_tw_hoehoe 3:d6f80e11a7f4 161 params->advertisingDataLen,
mbed_tw_hoehoe 3:d6f80e11a7f4 162 (uint8_t *)params->advertisingData, &len, adv_name)){
FranKP2138 6:d37a6e3c17c4 163 pc.printf("NRF_Success \r\n");
mbed_tw_hoehoe 3:d6f80e11a7f4 164
FranKP2138 4:722dfc6fe1de 165 // Cycle fo rconnect two peripheral
FranKP2138 4:722dfc6fe1de 166 for(uint8_t i=0; i<2; i++){
FranKP2138 6:d37a6e3c17c4 167 pc.printf("Cycle go connect \r\n");
mbed_tw_hoehoe 3:d6f80e11a7f4 168 if(gs_peripheral[i].connected == false){
FranKP2138 6:d37a6e3c17c4 169 pc.printf("If connect == false -> Connect \r\n");
mbed_tw_hoehoe 3:d6f80e11a7f4 170 memcpy(gs_peripheral[i].address, params->peerAddr, sizeof(params->peerAddr));
mbed_tw_hoehoe 3:d6f80e11a7f4 171 gs_peripheral[i].deviceName = adv_name;
mbed_tw_hoehoe 3:d6f80e11a7f4 172 ble.connect(params->peerAddr, BLEProtocol::AddressType::RANDOM_STATIC, NULL, NULL);
FranKP2138 6:d37a6e3c17c4 173 // (5) forsatura da eliminare
FranKP2138 6:d37a6e3c17c4 174 device_is_simple_peripheral = 1;
FranKP2138 6:d37a6e3c17c4 175
FranKP2138 6:d37a6e3c17c4 176
FranKP2138 4:722dfc6fe1de 177 // new edit add FP
FranKP2138 5:68a31613f28a 178 // (2) Make set name peripheral with button
FranKP2138 4:722dfc6fe1de 179 if( memcmp("TXRX", adv_name, 4) == 0x00 ) {
FranKP2138 6:d37a6e3c17c4 180 pc.printf("peripheral type simpleControl \r\n");
FranKP2138 4:722dfc6fe1de 181 device_is_simple_peripheral = 1;
FranKP2138 6:d37a6e3c17c4 182 // On Led 4
FranKP2138 4:722dfc6fe1de 183 }
FranKP2138 5:68a31613f28a 184 // (3) make set name peripheral with sensor
FranKP2138 4:722dfc6fe1de 185 if(memcmp("Nordic_HRM", adv_name, 10) == 0x00) {
FranKP2138 6:d37a6e3c17c4 186 pc.printf("peripheral type Nordic_HRM \r\n");
FranKP2138 4:722dfc6fe1de 187 device_is_hrm = 1;
FranKP2138 6:d37a6e3c17c4 188 // On led 5
FranKP2138 4:722dfc6fe1de 189 }
FranKP2138 4:722dfc6fe1de 190 // end
FranKP2138 4:722dfc6fe1de 191
mbed_tw_hoehoe 3:d6f80e11a7f4 192 break;
mbed_tw_hoehoe 3:d6f80e11a7f4 193 }
mbed_tw_hoehoe 3:d6f80e11a7f4 194 }
FranKP2138 6:d37a6e3c17c4 195 pc.printf("Stop Scan \r\n");
mbed_tw_hoehoe 3:d6f80e11a7f4 196 ble.stopScan();
mbed_tw_hoehoe 3:d6f80e11a7f4 197 }
mbed_tw_hoehoe 0:83b5c6efd8d7 198 }
mbed_tw_hoehoe 0:83b5c6efd8d7 199
FranKP2138 4:722dfc6fe1de 200 /** @brief Connection callback handle
FranKP2138 4:722dfc6fe1de 201 *
FranKP2138 4:722dfc6fe1de 202 * @param[in] *params params->handle : The ID for this connection
FranKP2138 4:722dfc6fe1de 203 * params->role : PERIPHERAL = 0x1, // Peripheral Role
FranKP2138 4:722dfc6fe1de 204 * CENTRAL = 0x2, // Central Role.
FranKP2138 4:722dfc6fe1de 205 * params->peerAddrType : The peer's BLE address type
FranKP2138 4:722dfc6fe1de 206 * params->peerAddr : The peer's BLE address
FranKP2138 4:722dfc6fe1de 207 * params->ownAddrType : This device's BLE address type
FranKP2138 4:722dfc6fe1de 208 * params->ownAddr : This devices's BLE address
FranKP2138 4:722dfc6fe1de 209 * params->connectionParams->minConnectionInterval
FranKP2138 4:722dfc6fe1de 210 * params->connectionParams->maxConnectionInterval
FranKP2138 4:722dfc6fe1de 211 * params->connectionParams->slaveLatency
FranKP2138 4:722dfc6fe1de 212 * params->connectionParams->connectionSupervisionTimeout
FranKP2138 4:722dfc6fe1de 213 */
FranKP2138 4:722dfc6fe1de 214 // Comment 1
FranKP2138 4:722dfc6fe1de 215 void connectionCallBack( const Gap::ConnectionCallbackParams_t *params ) {
FranKP2138 4:722dfc6fe1de 216 /*
FranKP2138 4:722dfc6fe1de 217 uint8_t index;
FranKP2138 4:722dfc6fe1de 218
FranKP2138 4:722dfc6fe1de 219 Serial.print("The conn handle : ");
FranKP2138 4:722dfc6fe1de 220 Serial.println(params->handle, HEX);
FranKP2138 4:722dfc6fe1de 221 Serial.print(" The peerAddr : ");
FranKP2138 4:722dfc6fe1de 222 for(index=0; index<6; index++) {
FranKP2138 4:722dfc6fe1de 223 Serial.print(params->peerAddr[index], HEX);
FranKP2138 4:722dfc6fe1de 224 Serial.print(" ");
FranKP2138 4:722dfc6fe1de 225 }
FranKP2138 4:722dfc6fe1de 226 Serial.println(" ");*/
FranKP2138 4:722dfc6fe1de 227
FranKP2138 4:722dfc6fe1de 228 // start to discovery
FranKP2138 4:722dfc6fe1de 229 // Attention Comment
FranKP2138 4:722dfc6fe1de 230 // this state is set in startDiscovery
FranKP2138 4:722dfc6fe1de 231 /*
FranKP2138 4:722dfc6fe1de 232 pc.printf("GAP_EVT_CONNECTED\r\n");
FranKP2138 4:722dfc6fe1de 233 if (params->role == Gap::CENTRAL) {
FranKP2138 4:722dfc6fe1de 234
FranKP2138 4:722dfc6fe1de 235 for(uint8_t i=0; i<2; i++){
FranKP2138 4:722dfc6fe1de 236 if(gs_peripheral[i].connected == false){
FranKP2138 4:722dfc6fe1de 237 gs_peripheral[i].handle = params->handle;
FranKP2138 4:722dfc6fe1de 238 gs_peripheral[i].connected = true;
FranKP2138 4:722dfc6fe1de 239 break;
FranKP2138 4:722dfc6fe1de 240 }
FranKP2138 4:722dfc6fe1de 241 }
FranKP2138 4:722dfc6fe1de 242 ble.gattClient().launchServiceDiscovery(params->handle, serviceDiscoveryCallback, characteristicDiscoveryCallback, serviceUUID, accelUUID);
FranKP2138 4:722dfc6fe1de 243 //ble.gattClient().launchServiceDiscovery(params->handle, discoveredServiceCallBack, discoveredCharacteristicCallBack, service_uuid(0x180D));
FranKP2138 4:722dfc6fe1de 244
FranKP2138 4:722dfc6fe1de 245 }*/
FranKP2138 4:722dfc6fe1de 246
FranKP2138 4:722dfc6fe1de 247
FranKP2138 4:722dfc6fe1de 248 //Comment 3
FranKP2138 4:722dfc6fe1de 249 // check is set Ok
FranKP2138 5:68a31613f28a 250 pc.printf("connectionCallBack \r\n");
FranKP2138 4:722dfc6fe1de 251 startDiscovery(params->handle);
FranKP2138 4:722dfc6fe1de 252 }
FranKP2138 4:722dfc6fe1de 253
FranKP2138 4:722dfc6fe1de 254 /** @brief Disconnect callback handle
FranKP2138 4:722dfc6fe1de 255 *
FranKP2138 4:722dfc6fe1de 256 * @param[in] *params params->handle : connect handle
FranKP2138 4:722dfc6fe1de 257 * params->reason : CONNECTION_TIMEOUT = 0x08,
FranKP2138 4:722dfc6fe1de 258 * REMOTE_USER_TERMINATED_CONNECTION = 0x13,
FranKP2138 4:722dfc6fe1de 259 * REMOTE_DEV_TERMINATION_DUE_TO_LOW_RESOURCES = 0x14, // Remote device terminated connection due to low resources.
FranKP2138 4:722dfc6fe1de 260 * REMOTE_DEV_TERMINATION_DUE_TO_POWER_OFF = 0x15, // Remote device terminated connection due to power off.
FranKP2138 4:722dfc6fe1de 261 * LOCAL_HOST_TERMINATED_CONNECTION = 0x16,
FranKP2138 4:722dfc6fe1de 262 * CONN_INTERVAL_UNACCEPTABLE = 0x3B,
FranKP2138 4:722dfc6fe1de 263 */
FranKP2138 4:722dfc6fe1de 264 // Comment 2
FranKP2138 4:722dfc6fe1de 265
FranKP2138 4:722dfc6fe1de 266 void disconnectionCallBack(const Gap::DisconnectionCallbackParams_t *params) {
FranKP2138 4:722dfc6fe1de 267 // Serial.println("Disconnected, start to scanning");
FranKP2138 5:68a31613f28a 268 pc.printf("Disconnected, start to scanning \r\n");
FranKP2138 5:68a31613f28a 269
FranKP2138 4:722dfc6fe1de 270 // New edit FP
FranKP2138 4:722dfc6fe1de 271 device_is_simple_peripheral = 0;
FranKP2138 4:722dfc6fe1de 272 device_is_hrm = 0;
FranKP2138 4:722dfc6fe1de 273 characteristic_is_fond = 0;
FranKP2138 4:722dfc6fe1de 274 descriptor_is_found = 0;
FranKP2138 4:722dfc6fe1de 275 ble.startScan(scanCallback); // scanCallback
FranKP2138 4:722dfc6fe1de 276 // end
FranKP2138 4:722dfc6fe1de 277
FranKP2138 4:722dfc6fe1de 278 pc.printf("disconnected\r\n");
FranKP2138 4:722dfc6fe1de 279
FranKP2138 5:68a31613f28a 280 for(uint8_t i=0; i<2; i++){
FranKP2138 4:722dfc6fe1de 281 if(gs_peripheral[i].handle == params->handle){
FranKP2138 4:722dfc6fe1de 282 gs_peripheral[i].connected = false;
FranKP2138 4:722dfc6fe1de 283 gs_peripheral[i].handle = 0xFFFF;
FranKP2138 4:722dfc6fe1de 284 }
FranKP2138 4:722dfc6fe1de 285 }
FranKP2138 4:722dfc6fe1de 286 wait(8.0);
FranKP2138 4:722dfc6fe1de 287 ble.gap().startScan(scanCallback);
FranKP2138 4:722dfc6fe1de 288 }
FranKP2138 4:722dfc6fe1de 289
FranKP2138 4:722dfc6fe1de 290 /** @brief Discovered service callback handle
FranKP2138 4:722dfc6fe1de 291 *
FranKP2138 4:722dfc6fe1de 292 * @param[in] *service service->getUUID() The UUID of service
FranKP2138 4:722dfc6fe1de 293 * service->getStartHandle()
FranKP2138 4:722dfc6fe1de 294 * service->getEndHandle()
FranKP2138 4:722dfc6fe1de 295 */
FranKP2138 4:722dfc6fe1de 296
FranKP2138 4:722dfc6fe1de 297 static void discoveredServiceCallBack(const DiscoveredService *service) {
mbed_tw_hoehoe 1:2f1203d70643 298 pc.printf("service found...\r\n");
mbed_tw_hoehoe 0:83b5c6efd8d7 299 }
mbed_tw_hoehoe 0:83b5c6efd8d7 300
FranKP2138 4:722dfc6fe1de 301 /** @brief Discovered characteristics callback handle
FranKP2138 4:722dfc6fe1de 302 *
FranKP2138 4:722dfc6fe1de 303 * @param[in] *chars chars->getUUID() The UUID of service
FranKP2138 4:722dfc6fe1de 304 * chars->getProperties() broadcast() : Check if broadcasting is permitted. True is permited.
FranKP2138 4:722dfc6fe1de 305 * read() : Check reading is permitted.
FranKP2138 4:722dfc6fe1de 306 * writeWoResp() : Check if writing with Write Command is permitted
FranKP2138 4:722dfc6fe1de 307 * write() : Check if writing with Write Request is permitted.
FranKP2138 4:722dfc6fe1de 308 * notify() : Check notifications are permitted.
FranKP2138 4:722dfc6fe1de 309 * indicate() : Check if indications are permitted.
FranKP2138 4:722dfc6fe1de 310 * authSignedWrite() : Check if writing with Signed Write Command is permitted.
FranKP2138 4:722dfc6fe1de 311 * chars->getDeclHandle() characteristic's declaration attribute handle
FranKP2138 4:722dfc6fe1de 312 * chars->getValueHandle() characteristic's value attribute handle
FranKP2138 4:722dfc6fe1de 313 * chars->getLastHandle() characteristic's last attribute handle
FranKP2138 4:722dfc6fe1de 314 */
FranKP2138 4:722dfc6fe1de 315 static void discoveredCharacteristicCallBack(const DiscoveredCharacteristic *characteristicP) {
mbed_tw_hoehoe 1:2f1203d70643 316 pc.printf("characteristicDiscoveryCallback\r\n");
mbed_tw_hoehoe 2:4b53d13d9851 317
FranKP2138 4:722dfc6fe1de 318 //accelChar = *characteristicP;
FranKP2138 5:68a31613f28a 319 // (4) change serial.print -> println how make ?
FranKP2138 4:722dfc6fe1de 320 // New edit FP
FranKP2138 4:722dfc6fe1de 321 if(characteristicP->getUUID().shortOrLong() == UUID::UUID_TYPE_SHORT) {
FranKP2138 6:d37a6e3c17c4 322 pc.printf("characteristicDiscoveryCallback -1- \r\n");
FranKP2138 4:722dfc6fe1de 323 //Serial.println(chars->getUUID().getShortUUID(), HEX);
FranKP2138 4:722dfc6fe1de 324 if(characteristicP->getUUID().getShortUUID() == 0x2A37) {
FranKP2138 6:d37a6e3c17c4 325 pc.printf("characteristicDiscoveryCallback -2- \r\n");
FranKP2138 4:722dfc6fe1de 326 //Serial.println("Found HRM characteristic ");
FranKP2138 4:722dfc6fe1de 327 characteristic_is_fond = 1;
FranKP2138 4:722dfc6fe1de 328 chars_hrm = *characteristicP;
FranKP2138 4:722dfc6fe1de 329 }
FranKP2138 4:722dfc6fe1de 330 } else {
FranKP2138 6:d37a6e3c17c4 331 pc.printf("characteristicDiscoveryCallback -3- \r\n");
FranKP2138 4:722dfc6fe1de 332 uint8_t index;
FranKP2138 4:722dfc6fe1de 333 const uint8_t *uuid = characteristicP->getUUID().getBaseUUID();
FranKP2138 4:722dfc6fe1de 334 for(index=0; index<16; index++) {
FranKP2138 6:d37a6e3c17c4 335 pc.printf("characteristicDiscoveryCallback -4- \r\n");
FranKP2138 4:722dfc6fe1de 336 // Serial.print(uuid[index], HEX);
FranKP2138 4:722dfc6fe1de 337 //Serial.print(" ");
FranKP2138 4:722dfc6fe1de 338 }
FranKP2138 4:722dfc6fe1de 339 //Serial.println(" ");
FranKP2138 4:722dfc6fe1de 340 }
FranKP2138 4:722dfc6fe1de 341 // end
FranKP2138 4:722dfc6fe1de 342
FranKP2138 4:722dfc6fe1de 343
FranKP2138 4:722dfc6fe1de 344 for(uint8_t i=0; i<2; i++){
FranKP2138 6:d37a6e3c17c4 345 pc.printf("characteristicDiscoveryCallback -5- \r\n");
mbed_tw_hoehoe 3:d6f80e11a7f4 346 if(gs_peripheral[i].connected){
FranKP2138 6:d37a6e3c17c4 347 pc.printf("characteristicDiscoveryCallback -6- \r\n");
mbed_tw_hoehoe 3:d6f80e11a7f4 348 ble.gattClient().read(characteristicP->getConnectionHandle(), characteristicP->getValueHandle(), 0);
mbed_tw_hoehoe 2:4b53d13d9851 349 }
mbed_tw_hoehoe 2:4b53d13d9851 350 }
mbed_tw_hoehoe 2:4b53d13d9851 351
mbed_tw_hoehoe 0:83b5c6efd8d7 352 }
mbed_tw_hoehoe 0:83b5c6efd8d7 353
FranKP2138 4:722dfc6fe1de 354
FranKP2138 4:722dfc6fe1de 355 // Coomet 4
FranKP2138 4:722dfc6fe1de 356 static void discoveryTerminationCallBack(Gap::Handle_t connectionHandle) {
FranKP2138 4:722dfc6fe1de 357 pc.printf("terminated SD for handle %u\r\n", connectionHandle);
FranKP2138 4:722dfc6fe1de 358
FranKP2138 4:722dfc6fe1de 359 // New edit FP
FranKP2138 4:722dfc6fe1de 360 if(characteristic_is_fond == 1) {
FranKP2138 4:722dfc6fe1de 361 ble.gattClient().discoverCharacteristicDescriptors(chars_hrm, discoveredCharsDescriptorCallBack, discoveredDescTerminationCallBack);
FranKP2138 4:722dfc6fe1de 362 }
FranKP2138 4:722dfc6fe1de 363 // end
FranKP2138 4:722dfc6fe1de 364 }
FranKP2138 4:722dfc6fe1de 365
mbed_tw_hoehoe 3:d6f80e11a7f4 366
FranKP2138 4:722dfc6fe1de 367 /** @brief Discovered descriptor of characteristic callback handle
FranKP2138 4:722dfc6fe1de 368 *
FranKP2138 4:722dfc6fe1de 369 * @param[in] *params params->characteristic DiscoveredCharacteristic
FranKP2138 4:722dfc6fe1de 370 * params->descriptor descriptor.getUUID() : The uuid of descriptor atrribute
FranKP2138 4:722dfc6fe1de 371 * descriptor.getConnectionHandle()
FranKP2138 4:722dfc6fe1de 372 * descriptor.getAttributeHandle() : Arrtibute handle
FranKP2138 4:722dfc6fe1de 373 */
FranKP2138 4:722dfc6fe1de 374 static void discoveredCharsDescriptorCallBack(const CharacteristicDescriptorDiscovery::DiscoveryCallbackParams_t *params) {
FranKP2138 4:722dfc6fe1de 375 //Serial.println("\r\n----discovered descriptor");
FranKP2138 4:722dfc6fe1de 376 //Serial.print("Desriptor UUID : ");
FranKP2138 4:722dfc6fe1de 377 //Serial.println(params->descriptor.getUUID().getShortUUID(), HEX);
FranKP2138 4:722dfc6fe1de 378 if(params->descriptor.getUUID().getShortUUID() == 0x2902) {
FranKP2138 4:722dfc6fe1de 379 // Save characteristic info
FranKP2138 4:722dfc6fe1de 380 descriptor_is_found = 1;
FranKP2138 4:722dfc6fe1de 381 desc_of_chars_hrm = params->descriptor;
FranKP2138 4:722dfc6fe1de 382 }
FranKP2138 4:722dfc6fe1de 383 //Serial.print("connectionHandle : ");
FranKP2138 4:722dfc6fe1de 384 //Serial.println(params->descriptor.getConnectionHandle(), HEX);
FranKP2138 4:722dfc6fe1de 385 //Serial.print("descriptor Handle : ");
FranKP2138 4:722dfc6fe1de 386 //Serial.println(params->descriptor.getAttributeHandle(), HEX);
FranKP2138 4:722dfc6fe1de 387 }
FranKP2138 4:722dfc6fe1de 388
FranKP2138 4:722dfc6fe1de 389 /** @brief Discovered descriptor of characteristic termination callback handle
FranKP2138 4:722dfc6fe1de 390 *
FranKP2138 4:722dfc6fe1de 391 * @param[in] *params params->characteristic DiscoveredCharacteristic
FranKP2138 4:722dfc6fe1de 392 * params->status Status of the discovery operation
FranKP2138 4:722dfc6fe1de 393 */
FranKP2138 4:722dfc6fe1de 394 static void discoveredDescTerminationCallBack(const CharacteristicDescriptorDiscovery::TerminationCallbackParams_t *params) {
FranKP2138 4:722dfc6fe1de 395 // Serial.println("\r\n----discovery descriptor Termination");
FranKP2138 4:722dfc6fe1de 396 if(descriptor_is_found) {
FranKP2138 4:722dfc6fe1de 397 // Serial.println("Open HRM notify");
FranKP2138 4:722dfc6fe1de 398 uint16_t value = 0x0001;
FranKP2138 4:722dfc6fe1de 399 ble.gattClient().write(GattClient::GATT_OP_WRITE_REQ, chars_hrm.getConnectionHandle(), desc_of_chars_hrm.getAttributeHandle(), 2, (uint8_t *)&value);
FranKP2138 4:722dfc6fe1de 400 }
mbed_tw_hoehoe 0:83b5c6efd8d7 401 }
mbed_tw_hoehoe 0:83b5c6efd8d7 402
FranKP2138 4:722dfc6fe1de 403 /** @brief write callback handle
FranKP2138 4:722dfc6fe1de 404 *
FranKP2138 4:722dfc6fe1de 405 * @param[in] *params params->connHandle : The handle of the connection that triggered the event
FranKP2138 4:722dfc6fe1de 406 * params->handle : Attribute Handle to which the write operation applies
FranKP2138 4:722dfc6fe1de 407 * params->writeOp : OP_INVALID = 0x00, // Invalid operation.
FranKP2138 4:722dfc6fe1de 408 * OP_WRITE_REQ = 0x01, // Write request.
FranKP2138 4:722dfc6fe1de 409 * OP_WRITE_CMD = 0x02, // Write command.
FranKP2138 4:722dfc6fe1de 410 * OP_SIGN_WRITE_CMD = 0x03, // Signed write command.
FranKP2138 4:722dfc6fe1de 411 * OP_PREP_WRITE_REQ = 0x04, // Prepare write request.
FranKP2138 4:722dfc6fe1de 412 * OP_EXEC_WRITE_REQ_CANCEL = 0x05, // Execute write request: cancel all prepared writes.
FranKP2138 4:722dfc6fe1de 413 * OP_EXEC_WRITE_REQ_NOW = 0x06, // Execute write request: immediately execute all prepared writes.
FranKP2138 4:722dfc6fe1de 414 * params->offset : Offset for the write operation
FranKP2138 4:722dfc6fe1de 415 * params->len : Length (in bytes) of the data to write
FranKP2138 4:722dfc6fe1de 416 * params->data : Pointer to the data to write
FranKP2138 4:722dfc6fe1de 417 */
FranKP2138 4:722dfc6fe1de 418 // Attention
FranKP2138 4:722dfc6fe1de 419 void onDataWriteCallBack(const GattWriteCallbackParams *params) {
FranKP2138 4:722dfc6fe1de 420 //Serial.println("GattClient write call back ");
FranKP2138 4:722dfc6fe1de 421 }
FranKP2138 4:722dfc6fe1de 422
FranKP2138 4:722dfc6fe1de 423 /** @brief read callback handle
FranKP2138 4:722dfc6fe1de 424 *
FranKP2138 4:722dfc6fe1de 425 * @param[in] *params params->connHandle : The handle of the connection that triggered the event
FranKP2138 4:722dfc6fe1de 426 * params->handle : Attribute Handle to which the write operation applies
FranKP2138 4:722dfc6fe1de 427 * params->offset : Offset for the write operation
FranKP2138 4:722dfc6fe1de 428 * params->len : Length (in bytes) of the data to write
FranKP2138 4:722dfc6fe1de 429 * params->data : Pointer to the data to write
FranKP2138 4:722dfc6fe1de 430 */
FranKP2138 4:722dfc6fe1de 431
FranKP2138 4:722dfc6fe1de 432 // Attention
FranKP2138 4:722dfc6fe1de 433 void onDataReadCallBack(const GattReadCallbackParams *params) {
FranKP2138 4:722dfc6fe1de 434 // delete comment
FranKP2138 4:722dfc6fe1de 435 /* Serial.println("GattClient read call back ");
FranKP2138 4:722dfc6fe1de 436 Serial.print("The handle : ");
FranKP2138 4:722dfc6fe1de 437 Serial.println(params->handle, HEX);
FranKP2138 4:722dfc6fe1de 438 Serial.print("The offset : ");
FranKP2138 4:722dfc6fe1de 439 Serial.println(params->offset, DEC);
FranKP2138 4:722dfc6fe1de 440 Serial.print("The len : ");
FranKP2138 4:722dfc6fe1de 441 Serial.println(params->len, DEC);
FranKP2138 5:68a31613f28a 442 Serial.print("The data : ");*/
FranKP2138 5:68a31613f28a 443
FranKP2138 5:68a31613f28a 444 pc.printf("triggerRead.....\r\n");
FranKP2138 5:68a31613f28a 445 pc.printf("len: %d\r\n", params->len);
FranKP2138 5:68a31613f28a 446 const uint8_t *data = params->data;
FranKP2138 5:68a31613f28a 447 pc.printf("data ");
FranKP2138 5:68a31613f28a 448
FranKP2138 4:722dfc6fe1de 449 for(uint8_t index=0; index<params->len; index++) {
FranKP2138 5:68a31613f28a 450 //Serial.print( params->data[index], HEX);
FranKP2138 5:68a31613f28a 451 pc.printf("%f ", (float)data[index]);
FranKP2138 4:722dfc6fe1de 452 }
FranKP2138 5:68a31613f28a 453 pc.printf("\r\n");
FranKP2138 5:68a31613f28a 454 //Serial.println("");
FranKP2138 4:722dfc6fe1de 455 }
FranKP2138 4:722dfc6fe1de 456
FranKP2138 4:722dfc6fe1de 457 /** @brief hvx callback handle
FranKP2138 4:722dfc6fe1de 458 *
FranKP2138 4:722dfc6fe1de 459 * @param[in] *params params->connHandle : The handle of the connection that triggered the event
FranKP2138 4:722dfc6fe1de 460 * params->handle : Attribute Handle to which the write operation applies
FranKP2138 4:722dfc6fe1de 461 * params->type : BLE_HVX_NOTIFICATION = 0x01
FranKP2138 4:722dfc6fe1de 462 * BLE_HVX_INDICATION = 0x02
FranKP2138 4:722dfc6fe1de 463 * params->len : Length (in bytes) of the data to write
FranKP2138 4:722dfc6fe1de 464 * params->data : Pointer to the data to write
FranKP2138 4:722dfc6fe1de 465 */
FranKP2138 4:722dfc6fe1de 466 // Attention
FranKP2138 4:722dfc6fe1de 467 void hvxCallBack(const GattHVXCallbackParams *params) {
FranKP2138 4:722dfc6fe1de 468 // delete Cooment
FranKP2138 4:722dfc6fe1de 469 /* Serial.println("GattClient notify call back ");
FranKP2138 4:722dfc6fe1de 470 Serial.print("The len : ");
FranKP2138 5:68a31613f28a 471 Serial.println(params->len, DEC);*/
FranKP2138 4:722dfc6fe1de 472 for(unsigned char index=0; index<params->len; index++) {
FranKP2138 5:68a31613f28a 473 //Serial.print(params->data[index], HEX);
FranKP2138 5:68a31613f28a 474 pc.printf("%f ", (float)params->data[index]);
FranKP2138 4:722dfc6fe1de 475 }
FranKP2138 5:68a31613f28a 476 // Serial.println("");
mbed_tw_hoehoe 0:83b5c6efd8d7 477 }
mbed_tw_hoehoe 0:83b5c6efd8d7 478
FranKP2138 5:68a31613f28a 479 // Option
FranKP2138 5:68a31613f28a 480 /*void triggerRead(const GattReadCallbackParams *response) {
mbed_tw_hoehoe 3:d6f80e11a7f4 481 pc.printf("triggerRead.....\r\n");
mbed_tw_hoehoe 3:d6f80e11a7f4 482
mbed_tw_hoehoe 3:d6f80e11a7f4 483 pc.printf("len: %d\r\n", response->len);
mbed_tw_hoehoe 3:d6f80e11a7f4 484 const uint8_t *data = response->data;
mbed_tw_hoehoe 3:d6f80e11a7f4 485 pc.printf("data ");
mbed_tw_hoehoe 0:83b5c6efd8d7 486 for(int i=0; i < response->len; i++){
mbed_tw_hoehoe 3:d6f80e11a7f4 487 pc.printf("%f ", (float)data[i]);
mbed_tw_hoehoe 0:83b5c6efd8d7 488 }
mbed_tw_hoehoe 1:2f1203d70643 489 pc.printf("\r\n");
FranKP2138 4:722dfc6fe1de 490 // Comment property
FranKP2138 4:722dfc6fe1de 491 //accelChar.read();
FranKP2138 5:68a31613f28a 492 }*/
mbed_tw_hoehoe 0:83b5c6efd8d7 493
FranKP2138 4:722dfc6fe1de 494 // is set before
FranKP2138 4:722dfc6fe1de 495 /*void disconnectionCallback(const Gap::DisconnectionCallbackParams_t *params){
mbed_tw_hoehoe 1:2f1203d70643 496 pc.printf("disconnected\r\n");
mbed_tw_hoehoe 3:d6f80e11a7f4 497
mbed_tw_hoehoe 3:d6f80e11a7f4 498 for(uint8_t i=0; i<3; i++){
mbed_tw_hoehoe 3:d6f80e11a7f4 499 if(gs_peripheral[i].handle == params->handle){
mbed_tw_hoehoe 3:d6f80e11a7f4 500 gs_peripheral[i].connected = false;
mbed_tw_hoehoe 3:d6f80e11a7f4 501 gs_peripheral[i].handle = 0xFFFF;
mbed_tw_hoehoe 3:d6f80e11a7f4 502 }
mbed_tw_hoehoe 3:d6f80e11a7f4 503 }
mbed_tw_hoehoe 2:4b53d13d9851 504 wait(8.0);
mbed_tw_hoehoe 2:4b53d13d9851 505 ble.gap().startScan(scanCallback);
FranKP2138 4:722dfc6fe1de 506 }*/
mbed_tw_hoehoe 2:4b53d13d9851 507
mbed_tw_hoehoe 0:83b5c6efd8d7 508 int main(void) {
mbed_tw_hoehoe 1:2f1203d70643 509 pc.baud(9600);
mbed_tw_hoehoe 0:83b5c6efd8d7 510 wait(8.0);
mbed_tw_hoehoe 1:2f1203d70643 511 pc.printf("start\r\n");
FranKP2138 5:68a31613f28a 512 pc.printf("Avvio start\r\n");
FranKP2138 5:68a31613f28a 513
mbed_tw_hoehoe 0:83b5c6efd8d7 514
mbed_tw_hoehoe 0:83b5c6efd8d7 515 ble.init();
mbed_tw_hoehoe 3:d6f80e11a7f4 516
FranKP2138 4:722dfc6fe1de 517 ble.onConnection(connectionCallBack);
FranKP2138 4:722dfc6fe1de 518 ble.onDisconnection(disconnectionCallBack);
FranKP2138 4:722dfc6fe1de 519
FranKP2138 4:722dfc6fe1de 520 // New edit FP
FranKP2138 4:722dfc6fe1de 521 ble.gattClient().onServiceDiscoveryTermination(discoveryTerminationCallBack);
FranKP2138 4:722dfc6fe1de 522 ble.gattClient().onHVX(hvxCallBack);
FranKP2138 4:722dfc6fe1de 523 ble.gattClient().onDataWrite(onDataWriteCallBack);
FranKP2138 4:722dfc6fe1de 524 ble.gattClient().onDataRead(onDataReadCallBack);
FranKP2138 4:722dfc6fe1de 525 // scan interval : in milliseconds, valid values lie between 2.5ms and 10.24s
FranKP2138 4:722dfc6fe1de 526 // scan window :in milliseconds, valid values lie between 2.5ms and 10.24s
FranKP2138 4:722dfc6fe1de 527 // timeout : in seconds, between 0x0001 and 0xFFFF, 0x0000 disables timeout
FranKP2138 4:722dfc6fe1de 528 // activeScanning : true or false
FranKP2138 4:722dfc6fe1de 529 // end
FranKP2138 4:722dfc6fe1de 530
FranKP2138 4:722dfc6fe1de 531
FranKP2138 4:722dfc6fe1de 532 // Original
FranKP2138 4:722dfc6fe1de 533 //ble.gattClient().onServiceDiscoveryTermination(discoveryTerminationCallback);
FranKP2138 4:722dfc6fe1de 534 //ble.gattClient().onDataRead(triggerRead);
mbed_tw_hoehoe 0:83b5c6efd8d7 535 //ble.gattClient().onDataWrite(triggerToggledWrite);
mbed_tw_hoehoe 0:83b5c6efd8d7 536
mbed_tw_hoehoe 0:83b5c6efd8d7 537 ble.gap().setScanParams(500, 400);
mbed_tw_hoehoe 0:83b5c6efd8d7 538 ble.gap().startScan(scanCallback);
FranKP2138 4:722dfc6fe1de 539
FranKP2138 4:722dfc6fe1de 540 // Or
FranKP2138 4:722dfc6fe1de 541 /*
FranKP2138 4:722dfc6fe1de 542 ble.setScanParams(1000, 200, 0, false);
FranKP2138 4:722dfc6fe1de 543 // start scanning
FranKP2138 4:722dfc6fe1de 544 ble.startScan(scanCallBack);
FranKP2138 4:722dfc6fe1de 545 */
mbed_tw_hoehoe 0:83b5c6efd8d7 546
mbed_tw_hoehoe 0:83b5c6efd8d7 547 while (true) {
FranKP2138 5:68a31613f28a 548 pc.printf("while true\r\n");
mbed_tw_hoehoe 3:d6f80e11a7f4 549 ble.waitForEvent();
mbed_tw_hoehoe 0:83b5c6efd8d7 550 }
FranKP2138 4:722dfc6fe1de 551 }
FranKP2138 4:722dfc6fe1de 552
FranKP2138 4:722dfc6fe1de 553 // Altenativa
FranKP2138 5:68a31613f28a 554 /*void loop() {
FranKP2138 4:722dfc6fe1de 555 // put your main code here, to run repeatedly:
FranKP2138 4:722dfc6fe1de 556 ble.waitForEvent();
FranKP2138 5:68a31613f28a 557 }*/