1: #include "bluenrg_sdk_api.h"

   2:  

   3: #define DEBUG_REPORT_EN

   4: #include "error.h"

   5:  

   6:  

   7: uint8_t bnrgExpansionBoard = BNRG_EXPANION_BOARD_BLUENRG; 

   8:  

   9: #define SERVER_ROLE

  10: #if defined SERVER_ROLE

  11: BLE_RoleTypeDef BLE_Role = SERVER;

  12: #elif defined CLIENT_ROLE

  13: BLE_RoleTypeDef BLE_Role = CLIENT;

  14: #else

  15: #error "Please define SERVER_ROLE OR CLIENT_ROLE in bluenrg_sdk_api.c"

  16: #endif

  17:  

  18: volatile int connected = FALSE;

  19: //extern volatile int connected; //sensor_service.c

  20: volatile uint16_t connection_handle = 0;

  21: //extern volatile uint16_t connection_handle;//sensor_service.c

  22: volatile uint8_t set_connectable = TRUE; 

  23: //extern volatile uint8_t set_connectable; //sensor_service.c

  24: volatile uint8_t notification_enabled = FALSE; 

  25:  

  26: 

  31: __weak  tBleStatus ble_device_user_add_service(void)

  32: {

  33:     

  36:     tBleStatus ret=BLE_STATUS_SUCCESS;

  37:     

  38:  

  39:     

  40:     if(ret != BLE_STATUS_SUCCESS) {

  41:         PRINTF("Error while adding service.\r\n");

  42:         return BLE_STATUS_ERROR ;

  43:     }

  44:  

  45:     PRINTF("Service added successfully.\r\n");

  46:     return BLE_STATUS_SUCCESS;

  47:  

  48: }

  49:  

  50:  

  51: 

  56: tBleStatus ble_device_init(void)

  57: {

  58: #define BDADDR_SIZE 6

  59:     const char *name = "BlueNRG";

  60:     uint8_t SERVER_BDADDR[] = {0xaa, 0x00, 0x00, 0xE1, 0x80, 0x02};

  61:     uint8_t CLIENT_BDADDR[] = {0xbb, 0x00, 0x00, 0xE1, 0x80, 0x02};

  62:     uint16_t service_handle, dev_name_char_handle, appearance_char_handle;

  63:     uint8_t  hwVersion;

  64:     uint16_t fwVersion;

  65:  

  66:  

  67:     uint8_t bdaddr[BDADDR_SIZE];

  68:  

  69:     tBleStatus ret;

  70:  

  71:     

  72:     BNRG_SPI_Init();

  73:  

  74:     

  75:     HCI_Init();

  76:  

  77:     

  78:     BlueNRG_RST();

  79:  

  80:     

  81:     getBlueNRGVersion(&hwVersion, &fwVersion);

  82:  

  83:     

  89:     BlueNRG_RST();

  90:  

  91:     PRINTF("HWver %d, FWver %d", hwVersion, fwVersion);

  92:  

  93: #if 0

  94:     if (hwVersion > 0x30) { 

  95:         bnrgExpansionBoard = BNRG_EXPANION_BOARD_BlueNRG_MS;

  96:         

 101:         SERVER_BDADDR[5] = 0x02;

 102:     }

 103:  

 104:     

 105:     Osal_MemCpy(bdaddr, SERVER_BDADDR, sizeof(SERVER_BDADDR));

 106: #else

 107:     if (hwVersion > 0x30) { 

 108:         bnrgExpansionBoard = BNRG_EXPANION_BOARD_BlueNRG_MS;

 109:      }

 110:     if(BLE_Role == CLIENT) {

 111:         Osal_MemCpy(bdaddr, CLIENT_BDADDR, sizeof(CLIENT_BDADDR));

 112:     } else {

 113:         Osal_MemCpy(bdaddr, SERVER_BDADDR, sizeof(SERVER_BDADDR));

 114:     }

 115: #endif

 116:     ret = aci_hal_write_config_data(CONFIG_DATA_PUBADDR_OFFSET,

 117:                                     CONFIG_DATA_PUBADDR_LEN,

 118:                                     bdaddr);

 119:     if(ret) {

 120:         PRINTF("Setting BD_ADDR failed.\r\n");

 121:         return BLE_SET_BD_ADDR_FAILED;

 122:     }

 123:  

 124:     

 125:     ret = aci_gatt_init();

 126:     if(ret) {

 127:         PRINTF("GATT_Init failed.\r\n");

 128:         return BLE_GATT_INIT_FAILED;

 129:     }

 130:  

 131:     if(BLE_Role == SERVER) {

 132:         

 133:         if (bnrgExpansionBoard == BNRG_EXPANION_BOARD_BlueNRG_MS) {

 134:             ret = aci_gap_init_IDB05A1(GAP_PERIPHERAL_ROLE_IDB05A1, 0, 0x07, &service_handle, &dev_name_char_handle, &appearance_char_handle);

 135:         } else {

 136:             ret = aci_gap_init_IDB04A1(GAP_PERIPHERAL_ROLE_IDB04A1, &service_handle, &dev_name_char_handle, &appearance_char_handle);

 137:         }

 138:     } else {

 139:         

 140:         if (bnrgExpansionBoard == BNRG_EXPANION_BOARD_BlueNRG_MS) {

 141:             ret = aci_gap_init_IDB05A1(GAP_CENTRAL_ROLE_IDB05A1, 0, 0x07, &service_handle, &dev_name_char_handle, &appearance_char_handle);

 142:         } else {

 143:             ret = aci_gap_init_IDB04A1(GAP_CENTRAL_ROLE_IDB04A1, &service_handle, &dev_name_char_handle, &appearance_char_handle);

 144:         }

 145:     }

 146:     if(ret != BLE_STATUS_SUCCESS) {

 147:         PRINTF("GAP_Init failed.\r\n");

 148:         return BLE_GAP_INIT_FAILED;

 149:     }

 150:  

 151:     ret = aci_gatt_update_char_value(service_handle, dev_name_char_handle, 0,

 152:                                      strlen(name), (uint8_t *)name);

 153:     if(ret!= BLE_STATUS_SUCCESS) {

 154:         PRINTF("aci_gatt_update_char_value failed.\r\n");

 155:         return BLE_GATT_UPDATE_CHAR_FAILED;

 156:     }

 157:  

 158:     ret = aci_gap_set_auth_requirement(MITM_PROTECTION_REQUIRED,

 159:                                        OOB_AUTH_DATA_ABSENT,

 160:                                        NULL,

 161:                                        7,

 162:                                        16,

 163:                                        USE_FIXED_PIN_FOR_PAIRING,

 164:                                        123456,

 165:                                        BONDING);

 166:  

 167:     if (ret != BLE_STATUS_SUCCESS) {

 168:         PRINTF("BLE Stack Initialized failed.\r\n");

 169:         return BLE_STACK_INIT_FAILED;

 170:     } else {

 171:         PRINTF("BLE Stack Initialized Successfully.\r\n");

 172:     }

 173:  

 174:     if(BLE_Role == SERVER) {

 175:         

 176:         PRINTF("SERVER: BLE Stack Initialized\r\n");

 177:         ret = ble_device_user_add_service();

 178:         if(ret != BLE_STATUS_SUCCESS) {

 179:             PRINTF("Service added failed.\r\n");

 180:             return BLE_ADD_SERVICE_FAILED;

 181:         } else {

 182:             PRINTF("Service added successfully.\r\n");

 183:         }

 184:     } else {

 185:         

 186:         PRINTF("CLIENT: BLE Stack Initialized\r\n");

 187:     }

 188:     set_connectable = TRUE; //确保其值为TRUE,以便广播

 189:  

 190:     return BLE_STATUS_SUCCESS;

 191: }

 192:  

 193: 

 198: tBleStatus ble_device_set_tx_power(uint8_t level)

 199: {

 200:     

 201:     tBleStatus ret;

 202:     

 203:     ret = aci_hal_set_tx_power_level(1,level);

 204:  

 205:     return ret;

 206: }

 207:  

 208:  

 209: 

 214: tBleStatus ble_device_start_advertising(void)

 215: {

 216:  

 217:  

 218:     tBleStatus ret;

 219:  

 220:     const char local_name[] = {AD_TYPE_COMPLETE_LOCAL_NAME,'B','l','u','e','N','R','G'};

 221:  

 222:     

 223:     hci_le_set_scan_resp_data(0,NULL);

 224:     PRINTF("General Discoverable Mode.\r\n");

 225:  

 226:     ret = aci_gap_set_discoverable(ADV_IND, 0, 0, PUBLIC_ADDR, NO_WHITE_LIST_USE,

 227:                                    sizeof(local_name), local_name, 0, NULL, 0, 0);

 228:     if (ret != BLE_STATUS_SUCCESS) {

 229:         PRINTF("Error while setting discoverable mode (%d)\r\n", ret);

 230:     }

 231:  

 232:     return ret;

 233: }

 234:  

 235:  

 236: 

 241: tBleStatus ble_device_stop_advertising(void)

 242: {

 243:     tBleStatus ret;

 244:     ret = aci_gap_set_non_discoverable();

 245:  

 246:     return ret;

 247: }

 248:  

 249:  

 250: 

 251: 

 252: 

 255: #define SCAN_P (0x4000)

 256: #define SCAN_L (0x4000)

 257:  

 258: 

 261: #define SUPERV_TIMEOUT (60)

 262:  

 263: 

 266: #define CONN_P(x) ((int)((x)/1.25f))

 267:  

 268: 

 271: #define CONN_L(x) ((int)((x)/0.625f))

 272:  

 273: //#define CONN_P1     (CONN_P(10))

 274: //#define CONN_P2     (CONN_P(10))

 275: #define CONN_P1     (CONN_P(50))

 276: #define CONN_P2     (CONN_P(50))

 277:  

 278: #define CONN_L1     (CONN_L(1250))

 279: #define CONN_L2     (CONN_L(1250))

 280:  

 281: 

 282: //tBleStatus ble_host_connect(tBDAddr bdaddr)

 283: tBleStatus ble_host_connect(void)

 284: {

 285:  

 286:     tBleStatus ret;

 287:     if(set_connectable == TRUE) {

 288:         PRINTF("Client Create Connection\n");

 289:         tBDAddr bdaddr = {0xaa, 0x00, 0x00, 0xE1, 0x80, 0x02};

 290:  

 291:         //BSP_LED_On(LED2); //To indicate the start of the connection and discovery phase

 292:  

 293:         

 297:         ret = aci_gap_create_connection(SCAN_P, SCAN_L, PUBLIC_ADDR, bdaddr, PUBLIC_ADDR, CONN_P1, CONN_P2, 0,

 298:                                         SUPERV_TIMEOUT, CONN_L1 , CONN_L2);

 299:  

 300:         if (ret != 0) {

 301:             PRINTF("Error while starting connection.\n");

 302:             Clock_Wait(100);

 303:         }

 304:  

 305:     }

 306:     

 307:     //ble_host_discover_char();

 308:     return ret;

 309: }

 310:  

 311:  

 312:  

 313:  

 314:  

 315:  

 316:  

 317:  

 318:  

 319: void ble_on_connect_cb( uint8_t addr[6], uint16_t handle )

 320: {

 321:     connected = TRUE;

 322:     connection_handle = handle;

 323:  

 324:     PRINTF("Connected to device:");

 325:     for(int i = 5; i > 0; i--) {

 326:         PRINTF("X-", addr[i]);

 327:     }

 328:     PRINTF("X\r\n", addr[0]);

 329:  

 330:     PRINTF("Connection handle: %d\r\n", connection_handle);

 331:  

 332:     

 333:  

 334:     

 335: }

 336:  

 337: void ble_on_disconnect_cb(uint8_t reason)

 338: {

 339:  

 340:     connected = FALSE;

 341:     PRINTF("Disconnected\r\n");

 342:     

 343:     set_connectable = TRUE;

 344:     notification_enabled = FALSE;

 345:  

 346:     

 347:     

 348:     

 349:  

 350:     

 351:     //ble_device_start_advertising();//because set_connectable = TRUE; ble_process while auto advertising

 352: }

 353:  

 354: 

 359: tBleStatus ble_device_user_disconnect(void)

 360: {

 361:     

 363:     tBleStatus ret;

 364:  

 365:     connected = FALSE;

 366:     PRINTF("Disconnected\r\n");

 367:     

 368:     set_connectable = FALSE;

 369:     notification_enabled = FALSE;

 370:  

 371:     ret = aci_gap_terminate(connection_handle, HCI_OE_USER_ENDED_CONNECTION);

 372:     connection_handle = 0;

 373:     

 374:  

 375:     return ret;

 376: }

 377:  

 378: tBleStatus ble_device_user_connect(void)

 379: {

 380:     

 381:     set_connectable = TRUE;

 382:     return BLE_STATUS_SUCCESS;

 383: }

 384:  

 385: 

 390: tBleStatus ble_device_is_connected(void)

 391: {

 392:     

 393:     return connected;

 394: }

 395:  

 396:  

 397:  

 398:  

 399: 

 407: void ble_on_attribute_modified_cb(uint16_t handle, uint8_t data_length, uint8_t *att_data)

 408: {

 409:  

 410:     

 411:  

 412:     

 413: }

 414:  

 415: 

 420: tBleStatus ble_device_user_send(uint16_t servHandle,

 421:                                 uint16_t charHandle,

 422:                                 uint8_t charValOffset,

 423:                                 uint8_t charValueLen,

 424:                                 const uint8_t *charValue)

 425: {

 426:     tBleStatus ret;

 427:     ret=aci_gatt_update_char_value(servHandle, charHandle, charValOffset, charValueLen, charValue);

 428:     if (ret != BLE_STATUS_SUCCESS) {

 429:         PRINTF("Error while updating server %o handle  characteristic %o handle.\r\n",servHandle,charHandle) ;

 430:         return BLE_STATUS_ERROR ;

 431:     }

 432:     return BLE_STATUS_SUCCESS;

 433: }

 434:  

 435:  

 436:  

 437:  

 438: void ble_on_gatt_notification_cb(uint16_t attr_handle, uint8_t attr_len, uint8_t *attr_value)

 439: {

 440:  

 441:     

 442:  

 443:     

 444: }

 445:  

 446: void ble_on_gatt_dis_read_char_by_uuid_resp_cb(evt_gatt_disc_read_char_by_uuid_resp *resp)

 447: {

 448:  

 449:     

 450:  

 451:     

 452: }

 453:  

 454: void ble_on_gatt_procedure_complete_cb( evt_gatt_procedure_complete *pr)

 455: {

 456:  

 457:     

 458:  

 459:     

 460: }

 461:  

 462: void ble_on_gatt_read_permit_cb(uint16_t handle)

 463: {

 464:  

 465:     

 466:  

 467:     

 468:  

 469:     //EXIT:

 470:     if(connection_handle != 0)

 471:         aci_gatt_allow_read(connection_handle);

 472: }

 473:  

 474:  

 475:  

 476: 

 483: void HCI_Event_CB(void *pckt)

 484: {

 485:     hci_uart_pckt *hci_pckt = pckt;

 486:     

 487:     hci_event_pckt *event_pckt = (hci_event_pckt*)hci_pckt->data;

 488:  

 489:     if(hci_pckt->type != HCI_EVENT_PKT)

 490:         return;

 491:  

 492:     switch(event_pckt->evt) {

 493:  

 494:     case EVT_DISCONN_COMPLETE: { 

 495:         

 497:         DEBUG_REPORT("HCI_Event EVT_DISCONN_COMPLETE.\r\n");

 498:         

 499:         //GAP_DisconnectionComplete_CB();

 500:         ble_on_disconnect_cb(event_pckt->data[3]);

 501:     }

 502:     break;

 503:  

 504:     case EVT_LE_META_EVENT: {

 505:         

 506:         evt_le_meta_event *evt = (void *)event_pckt->data;

 507:         DEBUG_REPORT("HCI_Event EVT_LE_META_EVENT.\r\n");

 508:         

 509:         switch(evt->subevent) {

 510:         case EVT_LE_CONN_COMPLETE: {

 511:             

 512:             

 513:             evt_le_connection_complete *cc = (void *)evt->data;

 514:             

 526:             

 528:             DEBUG_REPORT("HCI_Event EVT_LE_CONN_COMPLETE.\r\n");

 529:             //GAP_ConnectionComplete_CB(cc->peer_bdaddr, cc->handle);

 530:             ble_on_connect_cb(cc->peer_bdaddr, cc->handle);

 531:         }

 532:         break;

 533:         case EVT_LE_ADVERTISING_REPORT: {

 534:             

 536:             DEBUG_REPORT("HCI_Event EVT_LE_ADVERTISING_REPORT.\r\n");

 537:             //le_advertising_info *pr = (void *)(evt->data+1); 

 538:             //ble_host_device_found(adv_data);

 539:         }

 540:         break;

 541:         }

 542:     }

 543:     break;

 544:  

 545:     case EVT_VENDOR: {

 546:         

 547:         evt_blue_aci *blue_evt = (void*)event_pckt->data;

 548:         DEBUG_REPORT("HCI_Event EVT_VENDOR.\r\n");

 549:         switch(blue_evt->ecode) {

 550:         case EVT_BLUE_GATT_ATTRIBUTE_MODIFIED: { 

 551:             

 552:             

 554:             DEBUG_REPORT("HCI_Event EVT_BLUE_GATT_ATTRIBUTE_MODIFIED.\r\n");

 555:             if (bnrgExpansionBoard == BNRG_EXPANION_BOARD_BlueNRG_MS) {

 556:                 evt_gatt_attr_modified_IDB05A1 *evt = (evt_gatt_attr_modified_IDB05A1*)blue_evt->data;

 557:                 ble_on_attribute_modified_cb(evt->attr_handle, evt->data_length, evt->att_data);

 558:             } else {

 559:                 evt_gatt_attr_modified_IDB04A1 *evt = (evt_gatt_attr_modified_IDB04A1*)blue_evt->data;

 560:                 ble_on_attribute_modified_cb(evt->attr_handle, evt->data_length, evt->att_data);

 561:             }

 562:             

 568:             

 570:             //ble_on_attribute_modified_cb(evt->attr_handle, evt->data_length, evt->att_data);//move into if

 571:         }

 572:         break;

 573:  

 574:         case EVT_BLUE_GATT_NOTIFICATION: { 

 575:             

 576:             evt_gatt_attr_notification *evt = (evt_gatt_attr_notification*)blue_evt->data;

 577:             

 583:             

 585:             DEBUG_REPORT("HCI_Event EVT_BLUE_GATT_NOTIFICATION.\r\n");

 586:             ble_on_gatt_notification_cb(evt->attr_handle, evt->event_data_length - 2, evt->attr_value);

 587:         }

 588:         break;

 589:  

 590:         case EVT_BLUE_GATT_DISC_READ_CHAR_BY_UUID_RESP:

 591:             if(BLE_Role == CLIENT) {

 592:                 DEBUG_REPORT("EVT_BLUE_GATT_DISC_READ_CHAR_BY_UUID_RESP.\r\n");

 593:  

 594:                 evt_gatt_disc_read_char_by_uuid_resp *resp = (void*)blue_evt->data;

 595:                 ble_on_gatt_dis_read_char_by_uuid_resp_cb( (evt_gatt_disc_read_char_by_uuid_resp *)resp);

 596:             }

 597:             break;

 598:  

 599:         case EVT_BLUE_GATT_PROCEDURE_COMPLETE:

 600:             if(BLE_Role == CLIENT) {

 601:                 DEBUG_REPORT("EVT_BLUE_GATT_PROCEDURE_COMPLETE.\r\n");

 602:                 

 603:                 evt_gatt_procedure_complete *pr = (void*)blue_evt->data;

 604:                 ble_on_gatt_procedure_complete_cb( (evt_gatt_procedure_complete *)pr);

 605:  

 606:             }

 607:             break;

 608:  

 609:         case EVT_BLUE_GATT_READ_PERMIT_REQ: {

 610:             evt_gatt_read_permit_req *pr = (void*)blue_evt->data;

 611:             

 613:             DEBUG_REPORT("HCI_Event EVT_BLUE_GATT_READ_PERMIT_REQ.\r\n");

 614:             ble_on_gatt_read_permit_cb(pr->attr_handle);

 615:         }

 616:         break;

 617:         }

 618:     }

 619:     break;

 620:     }

 621: }

 622:  

 623: void ble_user_process(void)

 624: {

 625:  

 626:  

 627: }

 628:  

 629: void ble_process(void)

 630: {

 631:     

 634:     HCI_Process();

 635:     if(set_connectable) {

 636:         if(BLE_Role == CLIENT) {

 637:             ble_host_connect();

 638:         } else {

 639:             ble_device_start_advertising();

 640:         }

 641:         set_connectable = FALSE;

 642:     }

 643:     ble_user_process();

 644: }

 645:  

   1: int main(void)

   2: {

   3:     其他的初始化

   4:     

   5:     ble_device_init();

   6:     ble_device_set_tx_power(4);

   7:  

   8:     while(1) {

   9:         ble_process();

  10:         其他的用户程序

  11:     }

  12:  

  13: }

  14:  

  15:  

  16: void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)

  17: {

  18:   HCI_Isr();

  19: }