GeezerVisonThe World Wide Web, restored to 800 pixels of glory. |
| Home|About|Gaming cabinet|Archives|How it works|Starter sites |
GeezerVison is showing github.com — BLEKey/main.c at master · linklayer/BLEKey Expand file tree/ Copy pathmain.cMore file actions executable file ·809 lines (659 loc) · 28.7 KB / Copy pathmain.cFile metadata and controlsexecutable file ·809 lines (659 loc) · 28.7 KB 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 /* Copyright (c) 2012 Nordic Semiconductor. All Rights Reserved. * * The information contained herein is property of Nordic Semiconductor ASA. * Terms and conditions of usage are described in detail in NORDIC * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT. * * Licensees are granted free, non-transferable use of the information. NO * WARRANTY of ANY KIND is provided. This heading must NOT be removed from * the file. * */ // Board/nrf6310/ble/ble_app_wiegand/main.c /** @example Board/nrf6310/ble/ble_app_wiegand/main.c * * @brief Heart Rate Service Sample Application main file. * * This file contains the source code for a sample application using the Heart Rate service * (and also Battery and Device Information services). This application uses the * @ref srvlib_conn_params module. */ #include <stdint.h> #include <string.h> #include <stdlib.h> #include "nordic_common.h" #include "nrf.h" #include "app_error.h" #include "nrf_gpio.h" #include "nrf51_bitfields.h" #include "ble.h" #include "ble_hci.h" #include "ble_srv_common.h" #include "ble_advdata.h" #include "ble_bas.h" #include "ble_wiegand.h" #include "ble_dis.h" #include "ble_dfu.h" #include "dfu_app_handler.h" #include "ble_conn_params.h" #include "boards.h" #include "softdevice_handler.h" #include "app_timer.h" #include "ble_error_log.h" #include "device_manager.h" #include "ble_debug_assert_handler.h" #include "pstorage.h" #include "app_trace.h" #include "wiegand.h" #define IS_SRVC_CHANGED_CHARACT_PRESENT 0 /**< Include or not the service_changed characteristic. if not enabled, the server's database cannot be changed for the lifetime of the device*/ #define WAKEUP_BUTTON_PIN BUTTON_0 /**< Button used to wake up the application. */ #define BOND_DELETE_ALL_BUTTON_ID BUTTON_1 /**< Button used for deleting all bonded centrals during startup. */ #define ADVERTISING_LED_PIN_NO 20 /**< Is on when device is advertising. */ #define DEVICE_NAME "BLEKey" /**< Name of device. Will be included in the advertising data. */ #define MANUFACTURER_NAME "MB_EE" /**< Manufacturer. Will be passed to Device Information Service. */ #define APP_ADV_INTERVAL 0x0C80 /**< The advertising interval (in units of 0.625 ms). */ #define APP_ADV_TIMEOUT_IN_SECONDS 0 /**< The advertising timeout in units of seconds. */ #define APP_TIMER_PRESCALER 0 /**< Value of the RTC1 PRESCALER register. */ #define APP_TIMER_MAX_TIMERS 4 /**< Maximum number of simultaneously created timers. */ #define APP_TIMER_OP_QUEUE_SIZE 4 /**< Size of timer operation queues. */ #define BATTERY_LEVEL_MEAS_INTERVAL APP_TIMER_TICKS(5000, APP_TIMER_PRESCALER) /**< Battery level measurement interval (ticks). */ #define MIN_CONN_INTERVAL MSEC_TO_UNITS(500, UNIT_1_25_MS) /**< Minimum acceptable connection interval (0.5 seconds). */ #define MAX_CONN_INTERVAL MSEC_TO_UNITS(1000, UNIT_1_25_MS) /**< Maximum acceptable connection interval (1 second). */ #define SLAVE_LATENCY 0 /**< Slave latency. */ #define CONN_SUP_TIMEOUT MSEC_TO_UNITS(4000, UNIT_10_MS) /**< Connection supervisory timeout (4 seconds). */ #define FIRST_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(5000, APP_TIMER_PRESCALER) /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (5 seconds). */ #define NEXT_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(30000, APP_TIMER_PRESCALER)/**< Time between each call to sd_ble_gap_conn_param_update after the first call (30 seconds). */ #define MAX_CONN_PARAMS_UPDATE_COUNT 3 /**< Number of attempts before giving up the connection parameter negotiation. */ #define SEC_PARAM_TIMEOUT 30 /**< Timeout for Pairing Request or Security Request (in seconds). */ #define SEC_PARAM_BOND 1 /**< Perform bonding. */ #define SEC_PARAM_MITM 1 /**< Changed from default! */ #define SEC_PARAM_IO_CAPABILITIES BLE_GAP_IO_CAPS_DISPLAY_ONLY #define SEC_PARAM_OOB 0 /**< Out Of Band data not available. */ #define SEC_PARAM_MIN_KEY_SIZE 7 /**< Minimum encryption key size. */ #define SEC_PARAM_MAX_KEY_SIZE 16 /**< Maximum encryption key size. */ #define DEAD_BEEF 0xDEADBEEF /**< Value used as error code on stack dump, can be used to identify stack location on stack unwind. */ #define VBAT_MAX_IN_MV 3000 static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID; /**< Handle of the current connection. */ static ble_gap_adv_params_t m_adv_params; /**< Parameters to be passed to the stack when starting advertising. */ static ble_bas_t m_bas; /**< Structure used to identify the battery service. */ static ble_wiegand_t m_wiegand; /**< Structure used to identify the heart rate service. */ static app_timer_id_t m_battery_timer_id; /**< Battery timer. */ //static app_timer_id_t m_heart_rate_timer_id; /**< Heart rate measurement timer. */ //static app_timer_id_t m_sensor_contact_timer_id; /**< Sensor contact detected timer. */ static dm_application_instance_t m_app_handle; /**< Application identifier allocated by device manager */ static bool m_memory_access_in_progress = false; /**< Flag to keep track of ongoing operations on persistent memory. */ #ifdef BLE_DFU_APP_SUPPORT static ble_dfu_t m_dfus; /**< Structure used to identify the DFU service. */ #endif // BLE_DFU_APP_SUPPORT static ble_gap_whitelist_t whitelist; static ble_gap_addr_t* whitelist_addrs[BLE_GAP_WHITELIST_ADDR_MAX_COUNT]; static ble_gap_irk_t* whitelist_irks[BLE_GAP_WHITELIST_IRK_MAX_COUNT]; static ble_gap_addr_t addr_1; #if 1 /**@brief Function for error handling, which is called when an error has occurred. * * @warning This handler is an example only and does not fit a final product. You need to analyze * how your product is supposed to react in case of error. * * @param[in] error_code Error code supplied to the handler. * @param[in] line_num Line number where the handler is called. * @param[in] p_file_name Pointer to the file name. */ void app_error_handler(uint32_t error_code, uint32_t line_num, const uint8_t * p_file_name) { // This call can be used for debug purposes during application development. // @note CAUTION: Activating this code will write the stack to flash on an error. // This function should NOT be used in a final product. // It is intended STRICTLY for development/debugging purposes. // The flash write will happen EVEN if the radio is active, thus interrupting // any communication. // Use with care. Uncomment the line below to use. // ble_debug_assert_handler(error_code, line_num, p_file_name); printf("%ld\n", error_code); // On assert, the system can only recover with a reset. //NVIC_SystemReset(); } #else #include "app_util_platform.h" //uint32_t m_error_code; //uint32_t m_line_num; //const uint8_t *m_p_file_name; void app_error_handler(uint32_t error_code, uint32_t line_num, const uint8_t * p_file_name) { // disable INTs CRITICAL_REGION_ENTER(); /* Light a LED on error or warning. */ // m_p_file_name = p_file_name; // m_error_code = error_code; // m_line_num = line_num; /* To be able to see function parameters in a debugger. */ uint32_t temp = 1; while(temp); CRITICAL_REGION_EXIT(); } #endif /**@brief Callback function for asserts in the SoftDevice. * * @details This function will be called in case of an assert in the SoftDevice. * * @warning This handler is an example only and does not fit a final product. You need to analyze * how your product is supposed to react in case of Assert. * @warning On assert from the SoftDevice, the system can only recover on reset. * * @param[in] line_num Line number of the failing ASSERT call. * @param[in] file_name File name of the failing ASSERT call. */ void assert_nrf_callback(uint16_t line_num, const uint8_t * p_file_name) { app_error_handler(DEAD_BEEF, line_num, p_file_name); } //ADC initialization static void adc_init(void) { // Configure ADC NRF_ADC->CONFIG = (ADC_CONFIG_RES_8bit << ADC_CONFIG_RES_Pos) | (ADC_CONFIG_INPSEL_SupplyOneThirdPrescaling << ADC_CONFIG_INPSEL_Pos) | (ADC_CONFIG_REFSEL_VBG << ADC_CONFIG_REFSEL_Pos) | (ADC_CONFIG_PSEL_Disabled << ADC_CONFIG_PSEL_Pos) | (ADC_CONFIG_EXTREFSEL_None << ADC_CONFIG_EXTREFSEL_Pos); NRF_ADC->EVENTS_END = 0; NRF_ADC->ENABLE = ADC_ENABLE_ENABLE_Enabled; } /**@brief Function for performing battery measurement and updating the Battery Level characteristic * in Battery Service. */ static void battery_level_update(void) { uint32_t err_code; uint8_t battery_level; NRF_ADC->EVENTS_END = 0; // Stop any running conversions. NRF_ADC->TASKS_START = 1; while (!NRF_ADC->EVENTS_END) { } uint16_t vbg_in_mv = 1200; uint8_t adc_max = 255; uint16_t vbat_current_in_mv = (NRF_ADC->RESULT * 3 * vbg_in_mv) / adc_max; NRF_ADC->EVENTS_END = 0; NRF_ADC->TASKS_STOP = 1; battery_level = ((vbat_current_in_mv * 100) / VBAT_MAX_IN_MV); err_code = ble_bas_battery_level_update(&m_bas, battery_level); if ((err_code != NRF_SUCCESS) && (err_code != NRF_ERROR_INVALID_STATE) && (err_code != BLE_ERROR_NO_TX_BUFFERS) && (err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING) ) { APP_ERROR_HANDLER(err_code); } } /**@brief Function for handling the Battery measurement timer timeout. * * @details This function will be called each time the battery level measurement timer expires. * * @param[in] p_context Pointer used for passing some arbitrary information (context) from the * app_start_timer() call to the timeout handler. */ static void battery_level_meas_timeout_handler(void * p_context) { UNUSED_PARAMETER(p_context); battery_level_update(); } /**@brief Function for the LEDs initialization. * * @details Initializes all LEDs used by this application. */ static void leds_init(void) { nrf_gpio_cfg_output(ADVERTISING_LED_PIN_NO); } /**@brief Function for the Timer initialization. * * @details Initializes the timer module. This creates and starts application timers. */ static void timers_init(void) { uint32_t err_code; // Initialize timer module. APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_MAX_TIMERS, APP_TIMER_OP_QUEUE_SIZE, false); // Create timers. err_code = app_timer_create(&m_battery_timer_id, APP_TIMER_MODE_REPEATED, battery_level_meas_timeout_handler); APP_ERROR_CHECK(err_code); } /**@brief Function for the GAP initialization. * * @details This function sets up all the necessary GAP (Generic Access Profile) parameters of the * device including the device name, appearance, and the preferred connection parameters. */ static void gap_params_init(void) { uint32_t err_code; ble_gap_conn_params_t gap_conn_params; ble_gap_conn_sec_mode_t sec_mode; BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode); err_code = sd_ble_gap_device_name_set(&sec_mode, (const uint8_t *)DEVICE_NAME, strlen(DEVICE_NAME)); APP_ERROR_CHECK(err_code); err_code = sd_ble_gap_appearance_set(BLE_APPEARANCE_HEART_RATE_SENSOR_HEART_RATE_BELT); APP_ERROR_CHECK(err_code); memset(&gap_conn_params, 0, sizeof(gap_conn_params)); gap_conn_params.min_conn_interval = MIN_CONN_INTERVAL; gap_conn_params.max_conn_interval = MAX_CONN_INTERVAL; gap_conn_params.slave_latency = SLAVE_LATENCY; gap_conn_params.conn_sup_timeout = CONN_SUP_TIMEOUT; err_code = sd_ble_gap_ppcp_set(&gap_conn_params); APP_ERROR_CHECK(err_code); } /**@brief Function for initializing the Advertising functionality. * * @details Encodes the required advertising data and passes it to the stack. * Also builds a structure to be passed to the stack when starting advertising. */ static void advertising_init(void) { uint32_t err_code; ble_advdata_t advdata; uint8_t flags = BLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED; ble_uuid_t adv_uuids[] = { {BLE_UUID_BATTERY_SERVICE, BLE_UUID_TYPE_BLE}, {BLE_UUID_DEVICE_INFORMATION_SERVICE, BLE_UUID_TYPE_BLE} }; // Build and set advertising data. memset(&advdata, 0, sizeof(advdata)); advdata.name_type = BLE_ADVDATA_FULL_NAME; advdata.include_appearance = true; advdata.flags.size = sizeof(flags); advdata.flags.p_data = &flags; advdata.uuids_complete.uuid_cnt = sizeof(adv_uuids) / sizeof(adv_uuids[0]); advdata.uuids_complete.p_uuids = adv_uuids; err_code = ble_advdata_set(&advdata, NULL); APP_ERROR_CHECK(err_code); memset(&whitelist, 0, sizeof(ble_gap_whitelist_t)); /* example of adding a whitelist */ /* addr_1.addr[0] = 0xAA; addr_1.addr[1] = 0xBB; addr_1.addr[1] = 0xCC; addr_1.addr[1] = 0xDD; addr_1.addr[4] = 0xEE; addr_1.addr[5] = 0xFF; addr_1.addr_type = 0; */ whitelist_addrs[0] = &addr_1; whitelist.pp_addrs = whitelist_addrs; whitelist.addr_count = 1; whitelist.pp_irks = whitelist_irks; whitelist.irk_count = 0; // Initialize advertising parameters (used when starting advertising). memset(&m_adv_params, 0, sizeof(m_adv_params)); m_adv_params.type = BLE_GAP_ADV_TYPE_ADV_IND; m_adv_params.p_peer_addr = NULL; // Undirected advertisement. /* change to BLE BLE_GAP_ADV_FP_FILTER_BOTH to enable whitelist */ m_adv_params.fp = BLE_GAP_ADV_FP_ANY; m_adv_params.interval = APP_ADV_INTERVAL; m_adv_params.timeout = APP_ADV_TIMEOUT_IN_SECONDS; m_adv_params.p_whitelist = &whitelist; } #ifdef BLE_DFU_APP_SUPPORT static void advertising_stop(void) { uint32_t err_code; err_code = sd_ble_gap_adv_stop(); APP_ERROR_CHECK(err_code); nrf_gpio_pin_clear(ADVERTISING_LED_PIN_NO); } /** @snippet [DFU BLE Reset prepare] */ static void reset_prepare(void) { uint32_t err_code; if (m_conn_handle != BLE_CONN_HANDLE_INVALID) { // Disconnect from peer. err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); APP_ERROR_CHECK(err_code); } else { // If not connected, then the device will be advertising. Hence stop the advertising. advertising_stop(); } nrf_gpio_pin_clear(ADVERTISING_LED_PIN_NO); err_code = ble_conn_params_stop(); APP_ERROR_CHECK(err_code); } /** @snippet [DFU BLE Reset prepare] */ #endif // BLE_DFU_APP_SUPPORT /**@brief Function for initializing services that will be used by the application. * * @details Initialize the Heart Rate, Battery and Device Information services. */ static void services_init(void) { uint32_t err_code; ble_wiegand_init_t wiegand_init; ble_bas_init_t bas_init; ble_dis_init_t dis_init; uint8_t body_sensor_location; // Initialize Heart Rate Service. body_sensor_location = 0xDE; memset(&wiegand_init, 0, sizeof(wiegand_init)); wiegand_init.evt_handler = NULL; wiegand_init.is_sensor_contact_supported = true; wiegand_init.p_body_sensor_location = &body_sensor_location; // Here the sec level for the Heart Rate Service can be changed/increased. BLE_GAP_CONN_SEC_MODE_SET_OPEN(&wiegand_init.wiegand_last_cards_attr_md.read_perm); BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&wiegand_init.wiegand_last_cards_attr_md.write_perm); BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&wiegand_init.wiegand_replay_attr_md.read_perm); BLE_GAP_CONN_SEC_MODE_SET_OPEN(&wiegand_init.wiegand_replay_attr_md.write_perm); BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&wiegand_init.wiegand_replay_attr_md.read_perm); BLE_GAP_CONN_SEC_MODE_SET_OPEN(&wiegand_init.wiegand_replay_attr_md.write_perm); BLE_GAP_CONN_SEC_MODE_SET_OPEN(&wiegand_init.wiegand_replay_attr_md.read_perm); BLE_GAP_CONN_SEC_MODE_SET_OPEN(&wiegand_init.wiegand_replay_attr_md.write_perm); err_code = ble_wiegand_init(&m_wiegand, &wiegand_init); APP_ERROR_CHECK(err_code); // Initialize Battery Service. memset(&bas_init, 0, sizeof(bas_init)); // Here the sec level for the Battery Service can be changed/increased. BLE_GAP_CONN_SEC_MODE_SET_OPEN(&bas_init.battery_level_char_attr_md.cccd_write_perm); BLE_GAP_CONN_SEC_MODE_SET_OPEN(&bas_init.battery_level_char_attr_md.read_perm); BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&bas_init.battery_level_char_attr_md.write_perm); BLE_GAP_CONN_SEC_MODE_SET_OPEN(&bas_init.battery_level_report_read_perm); bas_init.evt_handler = NULL; bas_init.support_notification = true; bas_init.p_report_ref = NULL; bas_init.initial_batt_level = 100; err_code = ble_bas_init(&m_bas, &bas_init); APP_ERROR_CHECK(err_code); // Initialize Device Information Service. memset(&dis_init, 0, sizeof(dis_init)); ble_srv_ascii_to_utf8(&dis_init.manufact_name_str, (char *)MANUFACTURER_NAME); BLE_GAP_CONN_SEC_MODE_SET_OPEN(&dis_init.dis_attr_md.read_perm); BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&dis_init.dis_attr_md.write_perm); err_code = ble_dis_init(&dis_init); APP_ERROR_CHECK(err_code); #ifdef BLE_DFU_APP_SUPPORT /** @snippet [DFU BLE Service initialization] */ ble_dfu_init_t dfus_init; // Initialize the Device Firmware Update Service. memset(&dfus_init, 0, sizeof(dfus_init)); dfus_init.evt_handler = dfu_app_on_dfu_evt; dfus_init.error_handler = NULL; //service_error_handler - Not used as only the switch from app to DFU mode is required and not full dfu service. err_code = ble_dfu_init(&m_dfus, &dfus_init); APP_ERROR_CHECK(err_code); dfu_app_reset_prepare_set(reset_prepare); /** @snippet [DFU BLE Service initialization] */ #endif // BLE_DFU_APP_SUPPORT } /**@brief Function for starting application timers. */ static void application_timers_start(void) { uint32_t err_code; // Start application timers. err_code = app_timer_start(m_battery_timer_id, BATTERY_LEVEL_MEAS_INTERVAL, NULL); APP_ERROR_CHECK(err_code); } /**@brief Function for starting advertising. */ static void advertising_start(void) { uint32_t err_code; uint32_t count; // Verify if there is any flash access pending, if yes delay starting advertising until // it's complete. err_code = pstorage_access_status_get(&count); APP_ERROR_CHECK(err_code); if (count != 0) { m_memory_access_in_progress = true; return; } err_code = sd_ble_gap_adv_start(&m_adv_params); APP_ERROR_CHECK(err_code); nrf_gpio_pin_set(ADVERTISING_LED_PIN_NO); } /**@brief Function for handling the Connection Parameters Module. * * @details This function will be called for all events in the Connection Parameters Module which * are passed to the application. * @note All this function does is to disconnect. This could have been done by simply * setting the disconnect_on_fail config parameter, but instead we use the event * handler mechanism to demonstrate its use. * * @param[in] p_evt Event received from the Connection Parameters Module. */ static void on_conn_params_evt(ble_conn_params_evt_t * p_evt) { uint32_t err_code; if(p_evt->evt_type == BLE_CONN_PARAMS_EVT_FAILED) { err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_CONN_INTERVAL_UNACCEPTABLE); APP_ERROR_CHECK(err_code); } } /**@brief Function for handling a Connection Parameters error. * * @param[in] nrf_error Error code containing information about what went wrong. */ static void conn_params_error_handler(uint32_t nrf_error) { APP_ERROR_HANDLER(nrf_error); } /**@brief Function for initializing the Connection Parameters module. */ static void conn_params_init(void) { uint32_t err_code; ble_conn_params_init_t cp_init; memset(&cp_init, 0, sizeof(cp_init)); cp_init.p_conn_params = NULL; cp_init.first_conn_params_update_delay = FIRST_CONN_PARAMS_UPDATE_DELAY; cp_init.next_conn_params_update_delay = NEXT_CONN_PARAMS_UPDATE_DELAY; cp_init.max_conn_params_update_count = MAX_CONN_PARAMS_UPDATE_COUNT; cp_init.disconnect_on_fail = false; cp_init.evt_handler = on_conn_params_evt; cp_init.error_handler = conn_params_error_handler; err_code = ble_conn_params_init(&cp_init); APP_ERROR_CHECK(err_code); } /**@brief Function for handling the Application's BLE Stack events. * * @param[in] p_ble_evt Bluetooth stack event. */ static void on_ble_evt(ble_evt_t * p_ble_evt) { uint32_t err_code; switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: nrf_gpio_pin_clear(ADVERTISING_LED_PIN_NO); m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle; break; case BLE_GAP_EVT_DISCONNECTED: advertising_start(); break; case BLE_GAP_EVT_TIMEOUT: if (p_ble_evt->evt.gap_evt.params.timeout.src == BLE_GAP_TIMEOUT_SRC_ADVERTISEMENT) { nrf_gpio_pin_clear(ADVERTISING_LED_PIN_NO); // Go to system-off mode (this function will not return; wakeup will cause a reset). err_code = sd_power_system_off(); APP_ERROR_CHECK(err_code); } break; default: // No implementation needed. break; } } /**@brief Function for handling the Application's system events. * * @param[in] sys_evt system event. */ static void on_sys_evt(uint32_t sys_evt) { switch(sys_evt) { case NRF_EVT_FLASH_OPERATION_SUCCESS: case NRF_EVT_FLASH_OPERATION_ERROR: if (m_memory_access_in_progress) { m_memory_access_in_progress = false; advertising_start(); } break; default: // No implementation needed. break; } } /**@brief Function for dispatching a BLE stack event to all modules with a BLE stack event handler. * * @details This function is called from the BLE Stack event interrupt handler after a BLE stack * event has been received. * * @param[in] p_ble_evt Bluetooth stack event. */ static void ble_evt_dispatch(ble_evt_t * p_ble_evt) { dm_ble_evt_handler(p_ble_evt); ble_wiegand_on_ble_evt(&m_wiegand, p_ble_evt); ble_bas_on_ble_evt(&m_bas, p_ble_evt); ble_conn_params_on_ble_evt(p_ble_evt); #ifdef BLE_DFU_APP_SUPPORT /** @snippet [Propagating BLE Stack events to DFU Service] */ ble_dfu_on_ble_evt(&m_dfus, p_ble_evt); /** @snippet [Propagating BLE Stack events to DFU Service] */ #endif // BLE_DFU_APP_SUPPORT on_ble_evt(p_ble_evt); } /**@brief Function for dispatching a system event to interested modules. * * @details This function is called from the System event interrupt handler after a system * event has been received. * * @param[in] sys_evt System stack event. */ static void sys_evt_dispatch(uint32_t sys_evt) { pstorage_sys_event_handler(sys_evt); on_sys_evt(sys_evt); } /**@brief Function for initializing the BLE stack. * * @details Initializes the SoftDevice and the BLE event interrupt. */ static void ble_stack_init(void) { uint32_t err_code; // https://devzone.nordicsemi.com/question/953/what-low-frequency-clock-sources-can-i-use/ // Initialize the SoftDevice handler module (internal RC oscillator) //SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_RC_250_PPM_250MS_CALIBRATION, // false); // Initialize the SoftDevice handler module (external XTAL) SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_250_PPM, false); #ifdef S110 // Enable BLE stack ble_enable_params_t ble_enable_params; memset(&ble_enable_params, 0, sizeof(ble_enable_params)); ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT; err_code = sd_ble_enable(&ble_enable_params); APP_ERROR_CHECK(err_code); #endif // Register with the SoftDevice handler module for BLE events. err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch); APP_ERROR_CHECK(err_code); // Register with the SoftDevice handler module for BLE events. err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch); APP_ERROR_CHECK(err_code); } /**@brief Function for handling the Device Manager events. * * @param[in] p_evt Data associated to the device manager event. */ static uint32_t device_manager_evt_handler(dm_handle_t const * p_handle, dm_event_t const * p_event, api_result_t event_result) { APP_ERROR_CHECK(event_result); return NRF_SUCCESS; } /**@brief Function for the Device Manager initialization. */ static void device_manager_init(void) { uint32_t err_code; dm_init_param_t init_data; dm_application_param_t register_param; // Initialize persistent storage module. err_code = pstorage_init(); APP_ERROR_CHECK(err_code); err_code = dm_init(&init_data); APP_ERROR_CHECK(err_code); memset(®ister_param.sec_param, 0, sizeof(ble_gap_sec_params_t)); register_param.sec_param.timeout = SEC_PARAM_TIMEOUT; register_param.sec_param.bond = SEC_PARAM_BOND; register_param.sec_param.mitm = SEC_PARAM_MITM; register_param.sec_param.io_caps = SEC_PARAM_IO_CAPABILITIES; register_param.sec_param.oob = SEC_PARAM_OOB; register_param.sec_param.min_key_size = SEC_PARAM_MIN_KEY_SIZE; register_param.sec_param.max_key_size = SEC_PARAM_MAX_KEY_SIZE; register_param.evt_handler = device_manager_evt_handler; register_param.service_type = DM_PROTOCOL_CNTXT_GATT_SRVR_ID; err_code = dm_register(&m_app_handle, ®ister_param); APP_ERROR_CHECK(err_code); } /**@brief Function for the Power manager. */ static void power_manage(void) { uint32_t err_code = sd_app_evt_wait(); APP_ERROR_CHECK(err_code); } /**@brief Function for application main entry. */ Wiegand_ctx wiegand_ctx; int main(void) { // initialze wiegand context data struct // Initialize. leds_init(); timers_init(); ble_stack_init(); wiegand_init(&wiegand_ctx); device_manager_init(); gap_params_init(); advertising_init(); services_init(); conn_params_init(); // Start execution. application_timers_start(); advertising_start(); adc_init(); printf("init done!\n"); // Enter main loop. for (;;) { wiegand_task(); // number of cards over the maximum that we can transmit uint16_t num_skip = 0; if (wiegand_ctx.card_count > BLE_MAX_CARDS) { num_skip = wiegand_ctx.card_count - BLE_MAX_CARDS; } // number of bytes to transmit over BLE uint16_t tx_len = wiegand_ctx.card_count * sizeof(Card); if (tx_len > BLE_MAX_TX_LEN) { tx_len = BLE_MAX_TX_LEN; } // load cards for transmission ble_wiegand_last_cards_set(&m_wiegand, (uint8_t *)&(wiegand_ctx.card_store[num_skip]), tx_len); power_manage(); } } |
| You are visitor 01402520 — GeezerVison does not store the pages you look up. Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required. |