/* * SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ #include "esp_log.h" #include "nvs_flash.h" /* power management */ #include "esp_pm.h" /* BLE */ #include "nimble/nimble_port.h" #include "nimble/nimble_port_freertos.h" #include "host/ble_hs.h" #include "host/util/util.h" #include "console/console.h" #include "services/gap/ble_svc_gap.h" #include "bleprph.h" #if CONFIG_EXAMPLE_USE_CI_ADDRESS #ifdef CONFIG_IDF_TARGET_ESP32 #define TEST_CI_ADDRESS_CHIP_OFFSET (0) #elif CONFIG_IDF_TARGET_ESP32C2 #define TEST_CI_ADDRESS_CHIP_OFFSET (1) #elif CONFIG_IDF_TARGET_ESP32C3 #define TEST_CI_ADDRESS_CHIP_OFFSET (2) #elif CONFIG_IDF_TARGET_ESP32C6 #define TEST_CI_ADDRESS_CHIP_OFFSET (3) #elif CONFIG_IDF_TARGET_ESP32C5 #define TEST_CI_ADDRESS_CHIP_OFFSET (4) #elif CONFIG_IDF_TARGET_ESP32H2 #define TEST_CI_ADDRESS_CHIP_OFFSET (5) #elif CONFIG_IDF_TARGET_ESP32P4 #define TEST_CI_ADDRESS_CHIP_OFFSET (6) #elif CONFIG_IDF_TARGET_ESP32S3 #define TEST_CI_ADDRESS_CHIP_OFFSET (7) #elif CONFIG_IDF_TARGET_ESP32C61 #define TEST_CI_ADDRESS_CHIP_OFFSET (8) #endif #endif #if CONFIG_EXAMPLE_EXTENDED_ADV static uint8_t ext_adv_pattern_1[] = { 0x02, 0x01, 0x06, 0x03, 0x03, 0xab, 0xcd, 0x03, 0x03, 0x18, 0x11, 0x11, 0X09, 'n', 'i', 'm', 'b', 'l', 'e', '-', 'b', 'l', 'e', 'p', 'r', 'p', 'h', '-', 'e', }; #endif static const char *tag = "NimBLE_BLE_PRPH"; static int bleprph_gap_event(struct ble_gap_event *event, void *arg); #if CONFIG_EXAMPLE_RANDOM_ADDR || CONFIG_EXAMPLE_USE_CI_ADDRESS static uint8_t own_addr_type = BLE_OWN_ADDR_RANDOM; #else static uint8_t own_addr_type; #endif void ble_store_config_init(void); #if MYNEWT_VAL(BLE_HCI_VS) static struct ble_gap_event_listener vs_event_listener; #endif #if MYNEWT_VAL(BLE_POWER_CONTROL) static struct ble_gap_event_listener power_control_event_listener; #endif /** * Logs information about a connection to the console. */ static void bleprph_print_conn_desc(struct ble_gap_conn_desc *desc) { MODLOG_DFLT(INFO, "handle=%d our_ota_addr_type=%d our_ota_addr=", desc->conn_handle, desc->our_ota_addr.type); print_addr(desc->our_ota_addr.val); MODLOG_DFLT(INFO, " our_id_addr_type=%d our_id_addr=", desc->our_id_addr.type); print_addr(desc->our_id_addr.val); MODLOG_DFLT(INFO, " peer_ota_addr_type=%d peer_ota_addr=", desc->peer_ota_addr.type); print_addr(desc->peer_ota_addr.val); MODLOG_DFLT(INFO, " peer_id_addr_type=%d peer_id_addr=", desc->peer_id_addr.type); print_addr(desc->peer_id_addr.val); MODLOG_DFLT(INFO, " conn_itvl=%d conn_latency=%d supervision_timeout=%d " "encrypted=%d authenticated=%d bonded=%d\n", desc->conn_itvl, desc->conn_latency, desc->supervision_timeout, desc->sec_state.encrypted, desc->sec_state.authenticated, desc->sec_state.bonded); } #if CONFIG_EXAMPLE_EXTENDED_ADV /** * Enables advertising with the following parameters: * o General discoverable mode. * o Undirected connectable mode. */ static void ext_bleprph_advertise(void) { struct ble_gap_ext_adv_params params; struct os_mbuf *data; uint8_t instance = 0; int rc; /* First check if any instance is already active */ if(ble_gap_ext_adv_active(instance)) { return; } /* use defaults for non-set params */ memset (¶ms, 0, sizeof(params)); /* enable connectable advertising */ params.connectable = 1; /* advertise using random addr */ params.own_addr_type = own_addr_type; params.primary_phy = BLE_HCI_LE_PHY_1M; params.secondary_phy = BLE_HCI_LE_PHY_2M; params.tx_power = 127; params.sid = 1; params.itvl_min = BLE_GAP_ADV_FAST_INTERVAL1_MIN; params.itvl_max = BLE_GAP_ADV_FAST_INTERVAL1_MIN; /* configure instance 0 */ rc = ble_gap_ext_adv_configure(instance, ¶ms, NULL, bleprph_gap_event, NULL); assert (rc == 0); /* in this case only scan response is allowed */ /* get mbuf for scan rsp data */ data = os_msys_get_pkthdr(sizeof(ext_adv_pattern_1), 0); assert(data); /* fill mbuf with scan rsp data */ rc = os_mbuf_append(data, ext_adv_pattern_1, sizeof(ext_adv_pattern_1)); assert(rc == 0); rc = ble_gap_ext_adv_set_data(instance, data); assert (rc == 0); /* start advertising */ rc = ble_gap_ext_adv_start(instance, 0, 0); assert (rc == 0); #if CONFIG_EXAMPLE_SLEEP_WAKEUP rc = ble_hs_send_vs_event_mask(ESP_BLE_VENDOR_SLEEP_WAKEUP_EVT_MASK); rc = ble_gap_event_listener_register(&vs_event_listener, bleprph_gap_event,NULL); #endif } #else /** * Enables advertising with the following parameters: * o General discoverable mode. * o Undirected connectable mode. */ static void bleprph_advertise(void) { struct ble_gap_adv_params adv_params; struct ble_hs_adv_fields fields; int rc; /** * Set the advertisement data included in our advertisements: * o Flags (indicates advertisement type and other general info). * o Advertising tx power. * o Device name. * o 16-bit service UUIDs (alert notifications). */ memset(&fields, 0, sizeof fields); /* Advertise two flags: * o Discoverability in forthcoming advertisement (general) * o BLE-only (BR/EDR unsupported). */ fields.flags = BLE_HS_ADV_F_DISC_GEN | BLE_HS_ADV_F_BREDR_UNSUP; /* Indicate that the TX power level field should be included; have the * stack fill this value automatically. This is done by assigning the * special value BLE_HS_ADV_TX_PWR_LVL_AUTO. */ fields.tx_pwr_lvl_is_present = 1; fields.tx_pwr_lvl = BLE_HS_ADV_TX_PWR_LVL_AUTO; const char *name; name = ble_svc_gap_device_name(); fields.name = (uint8_t *)name; fields.name_len = strlen(name); fields.name_is_complete = 1; fields.uuids16 = (ble_uuid16_t[]) { BLE_UUID16_INIT(GATT_SVR_SVC_ALERT_UUID) }; fields.num_uuids16 = 1; fields.uuids16_is_complete = 1; rc = ble_gap_adv_set_fields(&fields); if (rc != 0) { MODLOG_DFLT(ERROR, "error setting advertisement data; rc=%d\n", rc); return; } /* Begin advertising. */ memset(&adv_params, 0, sizeof adv_params); adv_params.conn_mode = BLE_GAP_CONN_MODE_UND; adv_params.disc_mode = BLE_GAP_DISC_MODE_GEN; rc = ble_gap_adv_start(own_addr_type, NULL, BLE_HS_FOREVER, &adv_params, bleprph_gap_event, NULL); if (rc != 0) { MODLOG_DFLT(ERROR, "error enabling advertisement; rc=%d\n", rc); return; } } #endif #if MYNEWT_VAL(BLE_POWER_CONTROL) static void bleprph_power_control(uint16_t conn_handle) { int rc; rc = ble_gap_read_remote_transmit_power_level(conn_handle, 0x01 ); // Attempting on LE 1M phy assert (rc == 0); rc = ble_gap_set_transmit_power_reporting_enable(conn_handle, 0x1, 0x1); assert (rc == 0); } #endif #if MYNEWT_VAL(BLE_POWER_CONTROL) static int bleprph_gap_power_event(struct ble_gap_event *event, void *arg) { switch(event->type) { case BLE_GAP_EVENT_TRANSMIT_POWER: MODLOG_DFLT(INFO, "Transmit power event : status=%d conn_handle=%d reason=%d " "phy=%d power_level=%x power_level_flag=%d delta=%d", event->transmit_power.status, event->transmit_power.conn_handle, event->transmit_power.reason, event->transmit_power.phy, event->transmit_power.transmit_power_level, event->transmit_power.transmit_power_level_flag, event->transmit_power.delta); return 0; case BLE_GAP_EVENT_PATHLOSS_THRESHOLD: MODLOG_DFLT(INFO, "Pathloss threshold event : conn_handle=%d current path loss=%d " "zone_entered =%d", event->pathloss_threshold.conn_handle, event->pathloss_threshold.current_path_loss, event->pathloss_threshold.zone_entered); return 0; default: return 0; } } #endif /** * The nimble host executes this callback when a GAP event occurs. The * application associates a GAP event callback with each connection that forms. * bleprph uses the same callback for all connections. * * @param event The type of event being signalled. * @param ctxt Various information pertaining to the event. * @param arg Application-specified argument; unused by * bleprph. * * @return 0 if the application successfully handled the * event; nonzero on failure. The semantics * of the return code is specific to the * particular GAP event being signalled. */ static int bleprph_gap_event(struct ble_gap_event *event, void *arg) { struct ble_gap_conn_desc desc; int rc; switch (event->type) { case BLE_GAP_EVENT_CONNECT: /* A new connection was established or a connection attempt failed. */ MODLOG_DFLT(INFO, "connection %s; status=%d ", event->connect.status == 0 ? "established" : "failed", event->connect.status); if (event->connect.status == 0) { rc = ble_gap_conn_find(event->connect.conn_handle, &desc); assert(rc == 0); bleprph_print_conn_desc(&desc); } MODLOG_DFLT(INFO, "\n"); if (event->connect.status != 0) { /* Connection failed; resume advertising. */ #if CONFIG_EXAMPLE_EXTENDED_ADV ext_bleprph_advertise(); #else bleprph_advertise(); #endif } #if MYNEWT_VAL(BLE_POWER_CONTROL) bleprph_power_control(event->connect.conn_handle); ble_gap_event_listener_register(&power_control_event_listener, bleprph_gap_power_event, NULL); #endif return 0; case BLE_GAP_EVENT_DISCONNECT: MODLOG_DFLT(INFO, "disconnect; reason=%d ", event->disconnect.reason); bleprph_print_conn_desc(&event->disconnect.conn); MODLOG_DFLT(INFO, "\n"); /* Connection terminated; resume advertising. */ #if CONFIG_EXAMPLE_EXTENDED_ADV ext_bleprph_advertise(); #else bleprph_advertise(); #endif return 0; case BLE_GAP_EVENT_CONN_UPDATE: /* The central has updated the connection parameters. */ MODLOG_DFLT(INFO, "connection updated; status=%d ", event->conn_update.status); rc = ble_gap_conn_find(event->conn_update.conn_handle, &desc); assert(rc == 0); bleprph_print_conn_desc(&desc); MODLOG_DFLT(INFO, "\n"); return 0; case BLE_GAP_EVENT_ADV_COMPLETE: MODLOG_DFLT(INFO, "advertise complete; reason=%d", event->adv_complete.reason); #if CONFIG_EXAMPLE_EXTENDED_ADV ext_bleprph_advertise(); #else bleprph_advertise(); #endif return 0; case BLE_GAP_EVENT_ENC_CHANGE: /* Encryption has been enabled or disabled for this connection. */ MODLOG_DFLT(INFO, "encryption change event; status=%d ", event->enc_change.status); rc = ble_gap_conn_find(event->enc_change.conn_handle, &desc); assert(rc == 0); bleprph_print_conn_desc(&desc); MODLOG_DFLT(INFO, "\n"); return 0; case BLE_GAP_EVENT_NOTIFY_TX: MODLOG_DFLT(INFO, "notify_tx event; conn_handle=%d attr_handle=%d " "status=%d is_indication=%d", event->notify_tx.conn_handle, event->notify_tx.attr_handle, event->notify_tx.status, event->notify_tx.indication); return 0; case BLE_GAP_EVENT_SUBSCRIBE: MODLOG_DFLT(INFO, "subscribe event; conn_handle=%d attr_handle=%d " "reason=%d prevn=%d curn=%d previ=%d curi=%d\n", event->subscribe.conn_handle, event->subscribe.attr_handle, event->subscribe.reason, event->subscribe.prev_notify, event->subscribe.cur_notify, event->subscribe.prev_indicate, event->subscribe.cur_indicate); return 0; case BLE_GAP_EVENT_MTU: MODLOG_DFLT(INFO, "mtu update event; conn_handle=%d cid=%d mtu=%d\n", event->mtu.conn_handle, event->mtu.channel_id, event->mtu.value); return 0; case BLE_GAP_EVENT_REPEAT_PAIRING: /* We already have a bond with the peer, but it is attempting to * establish a new secure link. This app sacrifices security for * convenience: just throw away the old bond and accept the new link. */ /* Delete the old bond. */ rc = ble_gap_conn_find(event->repeat_pairing.conn_handle, &desc); assert(rc == 0); ble_store_util_delete_peer(&desc.peer_id_addr); /* Return BLE_GAP_REPEAT_PAIRING_RETRY to indicate that the host should * continue with the pairing operation. */ return BLE_GAP_REPEAT_PAIRING_RETRY; case BLE_GAP_EVENT_PASSKEY_ACTION: ESP_LOGI(tag, "PASSKEY_ACTION_EVENT started "); struct ble_sm_io pkey = {0}; int key = 0; if (event->passkey.params.action == BLE_SM_IOACT_DISP) { pkey.action = event->passkey.params.action; pkey.passkey = 123456; // This is the passkey to be entered on peer ESP_LOGI(tag, "Enter passkey %" PRIu32 "on the peer side", pkey.passkey); rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey); ESP_LOGI(tag, "ble_sm_inject_io result: %d", rc); } else if (event->passkey.params.action == BLE_SM_IOACT_NUMCMP) { ESP_LOGI(tag, "Passkey on device's display: %" PRIu32 , event->passkey.params.numcmp); ESP_LOGI(tag, "Accept or reject the passkey through console in this format -> key Y or key N"); pkey.action = event->passkey.params.action; if (scli_receive_key(&key)) { pkey.numcmp_accept = key; } else { pkey.numcmp_accept = 0; ESP_LOGE(tag, "Timeout! Rejecting the key"); } rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey); ESP_LOGI(tag, "ble_sm_inject_io result: %d", rc); } else if (event->passkey.params.action == BLE_SM_IOACT_OOB) { static uint8_t tem_oob[16] = {0}; pkey.action = event->passkey.params.action; for (int i = 0; i < 16; i++) { pkey.oob[i] = tem_oob[i]; } rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey); ESP_LOGI(tag, "ble_sm_inject_io result: %d", rc); } else if (event->passkey.params.action == BLE_SM_IOACT_INPUT) { ESP_LOGI(tag, "Enter the passkey through console in this format-> key 123456"); pkey.action = event->passkey.params.action; if (scli_receive_key(&key)) { pkey.passkey = key; } else { pkey.passkey = 0; ESP_LOGE(tag, "Timeout! Passing 0 as the key"); } rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey); ESP_LOGI(tag, "ble_sm_inject_io result: %d", rc); } return 0; #if CONFIG_EXAMPLE_SLEEP_WAKEUP case BLE_GAP_EVENT_VS_HCI: const struct ble_hci_ev_vs *ev = event->vs_hci.ev; switch(ev->id) { case BLE_HCI_VS_SUBEV_LE_SLEEP_WAKE_UP: MODLOG_DFLT(INFO, "Got Sleep wake up "); break; default: break; } #endif } return 0; } static void bleprph_on_reset(int reason) { MODLOG_DFLT(ERROR, "Resetting state; reason=%d\n", reason); } #if CONFIG_EXAMPLE_RANDOM_ADDR static void ble_app_set_addr(void) { ble_addr_t addr; int rc; /* generate new non-resolvable private address */ rc = ble_hs_id_gen_rnd(0, &addr); assert(rc == 0); /* set generated address */ rc = ble_hs_id_set_rnd(addr.val); assert(rc == 0); } #endif static void bleprph_on_sync(void) { int rc; #if CONFIG_EXAMPLE_RANDOM_ADDR /* Generate a non-resolvable private address. */ ble_app_set_addr(); #endif #if CONFIG_EXAMPLE_USE_CI_ADDRESS if (strlen(CONFIG_EXAMPLE_CI_ADDRESS_OFFSET)) { uint8_t addr[6] = {0}; uint32_t *offset = (uint32_t *)&addr[1]; *offset = atoi(CONFIG_EXAMPLE_CI_ADDRESS_OFFSET); addr[5] = 0xC3; addr[0] = TEST_CI_ADDRESS_CHIP_OFFSET; rc = ble_hs_id_set_rnd(addr); assert(rc == 0); } #endif // CONFIG_EXAMPLE_USE_CI_ADDRESS /* Make sure we have proper identity address set (public preferred) */ #if CONFIG_EXAMPLE_RANDOM_ADDR || CONFIG_EXAMPLE_USE_CI_ADDRESS rc = ble_hs_util_ensure_addr(1); #else rc = ble_hs_util_ensure_addr(0); #endif assert(rc == 0); /* Figure out address to use while advertising (no privacy for now) */ rc = ble_hs_id_infer_auto(0, &own_addr_type); if (rc != 0) { MODLOG_DFLT(ERROR, "error determining address type; rc=%d\n", rc); return; } /* Printing ADDR */ uint8_t addr_val[6] = {0}; rc = ble_hs_id_copy_addr(own_addr_type, addr_val, NULL); MODLOG_DFLT(INFO, "Device Address: "); print_addr(addr_val); MODLOG_DFLT(INFO, "\n"); /* Begin advertising. */ #if CONFIG_EXAMPLE_EXTENDED_ADV ext_bleprph_advertise(); #else bleprph_advertise(); #endif } void bleprph_host_task(void *param) { ESP_LOGI(tag, "BLE Host Task Started"); /* This function will return only when nimble_port_stop() is executed */ nimble_port_run(); nimble_port_freertos_deinit(); } void app_main(void) { int rc; /* Initialize NVS — it is used to store PHY calibration data */ esp_err_t ret = nvs_flash_init(); if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) { ESP_ERROR_CHECK(nvs_flash_erase()); ret = nvs_flash_init(); } ESP_ERROR_CHECK(ret); #if CONFIG_PM_ENABLE // Configure dynamic frequency scaling: // maximum and minimum frequencies are set in sdkconfig, // automatic light sleep is enabled if tickless idle support is enabled. esp_pm_config_t pm_config = { .max_freq_mhz = CONFIG_EXAMPLE_MAX_CPU_FREQ_MHZ, .min_freq_mhz = CONFIG_EXAMPLE_MIN_CPU_FREQ_MHZ, #if CONFIG_FREERTOS_USE_TICKLESS_IDLE .light_sleep_enable = true #endif }; ESP_ERROR_CHECK( esp_pm_configure(&pm_config) ); #endif // CONFIG_PM_ENABLE ret = nimble_port_init(); if (ret != ESP_OK) { ESP_LOGE(tag, "Failed to init nimble %d ", ret); return; } /* Initialize the NimBLE host configuration. */ ble_hs_cfg.reset_cb = bleprph_on_reset; ble_hs_cfg.sync_cb = bleprph_on_sync; ble_hs_cfg.gatts_register_cb = gatt_svr_register_cb; ble_hs_cfg.store_status_cb = ble_store_util_status_rr; ble_hs_cfg.sm_io_cap = CONFIG_EXAMPLE_IO_TYPE; #ifdef CONFIG_EXAMPLE_BONDING ble_hs_cfg.sm_bonding = 1; /* Enable the appropriate bit masks to make sure the keys * that are needed are exchanged */ ble_hs_cfg.sm_our_key_dist |= BLE_SM_PAIR_KEY_DIST_ENC; ble_hs_cfg.sm_their_key_dist |= BLE_SM_PAIR_KEY_DIST_ENC; #endif #ifdef CONFIG_EXAMPLE_MITM ble_hs_cfg.sm_mitm = 1; #endif #ifdef CONFIG_EXAMPLE_USE_SC ble_hs_cfg.sm_sc = 1; #else ble_hs_cfg.sm_sc = 0; #endif #ifdef CONFIG_EXAMPLE_RESOLVE_PEER_ADDR /* Stores the IRK */ ble_hs_cfg.sm_our_key_dist |= BLE_SM_PAIR_KEY_DIST_ID; ble_hs_cfg.sm_their_key_dist |= BLE_SM_PAIR_KEY_DIST_ID; #endif #if MYNEWT_VAL(BLE_GATTS) rc = gatt_svr_init(); assert(rc == 0); #if CONFIG_BT_NIMBLE_GAP_SERVICE /* Set the default device name. */ rc = ble_svc_gap_device_name_set("nimble-bleprph"); assert(rc == 0); #endif #endif /* XXX Need to have template for store */ ble_store_config_init(); nimble_port_freertos_init(bleprph_host_task); /* Initialize command line interface to accept input from user */ rc = scli_init(); if (rc != ESP_OK) { ESP_LOGE(tag, "scli_init() failed"); } }