| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| #include <assert.h> |
| #include <string.h> |
| #include "os/mynewt.h" |
| #include "bsp/bsp.h" |
| #include "console/console.h" |
| |
| /* BLE */ |
| #include "nimble/ble.h" |
| #include "controller/ble_ll.h" |
| #include "host/ble_hs.h" |
| |
| /* RAM HCI transport. */ |
| #include "transport/ram/ble_hci_ram.h" |
| |
| /* Mandatory services. */ |
| #include "services/gap/ble_svc_gap.h" |
| #include "services/gatt/ble_svc_gatt.h" |
| |
| /* Application-specified header. */ |
| #include "bsncent.h" |
| |
| #define BSNCENT_PRINT_RATE (OS_TICKS_PER_SEC * 10) |
| |
| static uint32_t num_notify_pkts_rx; |
| static uint32_t num_notify_bytes_rx; |
| |
| /* Prints statistics every 10 seconds. */ |
| static struct os_callout bsncent_print_timer; |
| |
| /* c66f3301-33b3-4687-850a-d52b0d5d1e3c */ |
| static const ble_uuid128_t bsncent_svc_gendata_uuid = |
| BLE_UUID128_INIT(0x3c, 0x1e, 0x5d, 0x0d, 0x2b, 0xd5, 0x0a, 0x85, |
| 0x87, 0x46, 0xb3, 0x33, 0x01, 0x33, 0x6f, 0xc6); |
| |
| /* c66f3301-33b3-4687-850a-d52b0d5d1e3d */ |
| static const ble_uuid128_t bsncent_chr_gendata_uuid = |
| BLE_UUID128_INIT(0x3d, 0x1e, 0x5d, 0x0d, 0x2b, 0xd5, 0x0a, 0x85, |
| 0x87, 0x46, 0xb3, 0x33, 0x01, 0x33, 0x6f, 0xc6); |
| |
| static const uint8_t bsncent_cent_public_addr[6] = { |
| 0x0a, 0x0b, 0x09, 0x09, 0x09, 0x00, |
| }; |
| |
| static const ble_addr_t bsncent_peer_addrs[] = { |
| { BLE_ADDR_PUBLIC, { 0x0a, 0x0b, 0x09, 0x09, 0x09, 0x01 } }, |
| { BLE_ADDR_PUBLIC, { 0x0a, 0x0b, 0x09, 0x09, 0x09, 0x02 } }, |
| { BLE_ADDR_PUBLIC, { 0x0a, 0x0b, 0x09, 0x09, 0x09, 0x03 } }, |
| { BLE_ADDR_PUBLIC, { 0x0a, 0x0b, 0x09, 0x09, 0x09, 0x04 } }, |
| { BLE_ADDR_PUBLIC, { 0x0a, 0x0b, 0x09, 0x09, 0x09, 0x05 } }, |
| }; |
| static const int bsncent_num_peer_addrs = |
| sizeof bsncent_peer_addrs / sizeof bsncent_peer_addrs[0]; |
| |
| static int bsncent_gap_event(struct ble_gap_event *event, void *arg); |
| |
| static const struct ble_gap_conn_params ble_gap_conn_params_bsn = { |
| .scan_itvl = 0x0010, |
| .scan_window = 0x0010, |
| .itvl_min = 13, |
| .itvl_max = 13, |
| .latency = BLE_GAP_INITIAL_CONN_LATENCY, |
| .supervision_timeout = BLE_GAP_INITIAL_SUPERVISION_TIMEOUT, |
| .min_ce_len = BLE_GAP_INITIAL_CONN_MIN_CE_LEN, |
| .max_ce_len = BLE_GAP_INITIAL_CONN_MAX_CE_LEN, |
| }; |
| |
| /** |
| * Application callback. Called when the attempt to subscribe to notifications |
| * for the ANS Unread Alert Status characteristic has completed. |
| */ |
| static int |
| bsncent_on_subscribe(uint16_t conn_handle, |
| const struct ble_gatt_error *error, |
| struct ble_gatt_attr *attr, |
| void *arg) |
| { |
| MODLOG_DFLT(INFO, "Subscribe complete; status=%d conn_handle=%d " |
| "attr_handle=%d\n", |
| error->status, conn_handle, attr->handle); |
| |
| return 0; |
| } |
| |
| /** |
| * Performs three concurrent GATT operations against the specified peer: |
| * 1. Reads the ANS Supported New Alert Category characteristic. |
| * 2. Writes the ANS Alert Notification Control Point characteristic. |
| * 3. Subscribes to notifications for the ANS Unread Alert Status |
| * characteristic. |
| * |
| * If the peer does not support a required service, characteristic, or |
| * descriptor, then the peer lied when it claimed support for the alert |
| * notification service! When this happens, or if a GATT procedure fails, |
| * this function immediately terminates the connection. |
| */ |
| static void |
| bsncent_subscribe(const struct peer *peer) |
| { |
| const struct peer_dsc *dsc; |
| uint8_t value[2]; |
| int rc; |
| |
| /* Subscribe to notifications for the gendata characteristic. |
| * A central enables notifications by writing two bytes (1, 0) to the |
| * characteristic's client-characteristic-configuration-descriptor (CCCD). |
| */ |
| dsc = peer_dsc_find_uuid( |
| peer, |
| &bsncent_svc_gendata_uuid.u, |
| &bsncent_chr_gendata_uuid.u, |
| BLE_UUID16_DECLARE(BLE_GATT_DSC_CLT_CFG_UUID16)); |
| if (dsc == NULL) { |
| MODLOG_DFLT(ERROR, "Error: Peer lacks a CCCD for the generic data " |
| "characteristic\n"); |
| goto err; |
| } |
| |
| value[0] = 1; |
| value[1] = 0; |
| rc = ble_gattc_write_flat(peer->conn_handle, dsc->dsc.handle, |
| value, sizeof value, bsncent_on_subscribe, NULL); |
| if (rc != 0) { |
| MODLOG_DFLT(ERROR, "Error: Failed to subscribe to characteristic; " |
| "rc=%d\n", rc); |
| goto err; |
| } |
| |
| return; |
| |
| err: |
| /* Terminate the connection. */ |
| ble_gap_terminate(peer->conn_handle, BLE_ERR_REM_USER_CONN_TERM); |
| } |
| |
| /** |
| * Called when service discovery of the specified peer has completed. |
| */ |
| static void |
| bsncent_on_disc_complete(const struct peer *peer, int status, void *arg) |
| { |
| |
| if (status != 0) { |
| /* Service discovery failed. Terminate the connection. */ |
| MODLOG_DFLT(ERROR, "Error: Service discovery failed; status=%d " |
| "conn_handle=%d\n", status, peer->conn_handle); |
| ble_gap_terminate(peer->conn_handle, BLE_ERR_REM_USER_CONN_TERM); |
| return; |
| } |
| |
| /* Service discovery has completed successfully. Now we have a complete |
| * list of services, characteristics, and descriptors that the peer |
| * supports. |
| */ |
| MODLOG_DFLT(ERROR, "Service discovery complete; status=%d " |
| "conn_handle=%d\n", status, peer->conn_handle); |
| |
| /* Now subscribe to the gendata characterustic. */ |
| bsncent_subscribe(peer); |
| } |
| |
| |
| static int |
| bsncent_on_mtu_exchanged(uint16_t conn_handle, |
| const struct ble_gatt_error *error, |
| uint16_t mtu, void *arg) |
| { |
| int rc; |
| |
| if (error->status != 0) { |
| MODLOG_DFLT(ERROR, "MTU exchange failed; rc=%d\n", error->status); |
| ble_gap_terminate(conn_handle, BLE_ERR_REM_USER_CONN_TERM); |
| return 0; |
| } |
| |
| /* Perform service discovery. */ |
| rc = peer_disc_all(conn_handle, bsncent_on_disc_complete, NULL); |
| if (rc != 0) { |
| MODLOG_DFLT(ERROR, "Failed to discover services; rc=%d\n", rc); |
| ble_gap_terminate(conn_handle, BLE_ERR_REM_USER_CONN_TERM); |
| return 0; |
| } |
| |
| return 0; |
| } |
| |
| static void |
| bsncent_connect(void) |
| { |
| int rc; |
| |
| rc = ble_gap_connect(BLE_OWN_ADDR_PUBLIC, NULL, BLE_HS_FOREVER, |
| &ble_gap_conn_params_bsn, bsncent_gap_event, NULL); |
| if (rc != 0) { |
| MODLOG_DFLT(ERROR, "Error connecting; rc=%d\n", rc); |
| if (!((rc == BLE_HS_EALREADY) || (rc == BLE_HS_EBUSY))) { |
| /* Only assert if we are not already trying */ |
| assert(0); |
| } |
| } |
| } |
| |
| static void |
| bsncent_fill_wl(void) |
| { |
| int rc; |
| |
| rc = ble_gap_wl_set(bsncent_peer_addrs, bsncent_num_peer_addrs); |
| if (rc != 0) { |
| MODLOG_DFLT(ERROR, "Error setting white list; rc=%d\n", rc); |
| assert(0); |
| } |
| } |
| |
| static void |
| bsncent_print_timer_reset(void) |
| { |
| int rc; |
| |
| rc = os_callout_reset(&bsncent_print_timer, BSNCENT_PRINT_RATE); |
| assert(rc == 0); |
| } |
| |
| /** |
| * Prints statistics every 10 seconds. |
| */ |
| static void |
| bsncent_print_timer_exp(struct os_event *ev) |
| { |
| static uint32_t prev_bytes; |
| static uint32_t prev_pkts; |
| uint32_t diff_bytes; |
| uint32_t diff_pkts; |
| |
| console_printf("--\n"); |
| console_printf("%8d connections\n", peer_count()); |
| console_printf("%8lu packets received\n", |
| (unsigned long)num_notify_pkts_rx); |
| console_printf("%8lu bytes received\n", |
| (unsigned long)num_notify_bytes_rx); |
| |
| if (prev_pkts != 0) { |
| diff_pkts = num_notify_pkts_rx - prev_pkts; |
| diff_bytes = num_notify_bytes_rx - prev_bytes; |
| |
| console_printf("%8lu packets per second\n", |
| (unsigned long)(diff_pkts / |
| (BSNCENT_PRINT_RATE / |
| OS_TICKS_PER_SEC))); |
| console_printf("%8lu bytes per second\n", |
| (unsigned long)(diff_bytes / |
| (BSNCENT_PRINT_RATE / |
| OS_TICKS_PER_SEC))); |
| } |
| |
| prev_pkts = num_notify_pkts_rx; |
| prev_bytes = num_notify_bytes_rx; |
| |
| bsncent_print_timer_reset(); |
| } |
| |
| /** |
| * The nimble host executes this callback when a GAP event occurs. The |
| * application associates a GAP event callback with each connection that is |
| * established. bsncent uses the same callback for all connections. |
| * |
| * @param event The event being signalled. |
| * @param arg Application-specified argument; unused by |
| * bsncent. |
| * |
| * @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 |
| bsncent_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. */ |
| if (event->connect.status == 0) { |
| /* Connection successfully established. */ |
| MODLOG_DFLT(INFO, "Connection established "); |
| |
| rc = ble_gap_conn_find(event->connect.conn_handle, &desc); |
| assert(rc == 0); |
| print_conn_desc(&desc); |
| MODLOG_DFLT(INFO, "\n"); |
| |
| /* Remember peer. */ |
| rc = peer_add(event->connect.conn_handle); |
| if (rc != 0) { |
| MODLOG_DFLT(ERROR, "Failed to add peer; rc=%d\n", rc); |
| assert(0); |
| } |
| |
| /* Try to connect to next peer if any remain unconnected. */ |
| if (peer_count() < bsncent_num_peer_addrs) { |
| bsncent_connect(); |
| } |
| |
| /* Negotiate ATT MTU. */ |
| rc = ble_gattc_exchange_mtu(event->connect.conn_handle, |
| bsncent_on_mtu_exchanged, NULL); |
| if (rc != 0) { |
| MODLOG_DFLT(ERROR, "Failed to exchange MTU; rc=%d\n", rc); |
| return 0; |
| } |
| } else { |
| /* Connection attempt failed; resume connecting. */ |
| MODLOG_DFLT(ERROR, "Error: Connection failed; status=%d\n", |
| event->connect.status); |
| bsncent_connect(); |
| } |
| |
| return 0; |
| |
| case BLE_GAP_EVENT_DISCONNECT: |
| /* Connection terminated. */ |
| MODLOG_DFLT(INFO, "disconnect; reason=%d ", event->disconnect.reason); |
| print_conn_desc(&event->disconnect.conn); |
| MODLOG_DFLT(INFO, "\n"); |
| |
| /* Forget about peer. */ |
| peer_delete(event->disconnect.conn.conn_handle); |
| |
| /* Resume scanning. */ |
| bsncent_connect(); |
| 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); |
| print_conn_desc(&desc); |
| return 0; |
| |
| case BLE_GAP_EVENT_NOTIFY_RX: |
| /* Peer sent us a notification or indication. */ |
| MODLOG_DFLT(DEBUG, "received %s; conn_handle=%d attr_handle=%d " |
| "attr_len=%d\n", |
| event->notify_rx.indication ? |
| "indication" : |
| "notification", |
| event->notify_rx.conn_handle, |
| event->notify_rx.attr_handle, |
| OS_MBUF_PKTLEN(event->notify_rx.om)); |
| |
| num_notify_pkts_rx++; |
| num_notify_bytes_rx += OS_MBUF_PKTLEN(event->notify_rx.om); |
| |
| /* Attribute data is contained in event->notify_rx.attr_data. */ |
| 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; |
| |
| default: |
| return 0; |
| } |
| } |
| |
| static void |
| bsncent_on_reset(int reason) |
| { |
| MODLOG_DFLT(ERROR, "Resetting state; reason=%d\n", reason); |
| } |
| |
| static void |
| bsncent_on_sync(void) |
| { |
| /* Start printing statistics. */ |
| bsncent_print_timer_reset(); |
| |
| /* Add the five known peripherals to the white list. */ |
| bsncent_fill_wl(); |
| |
| /* Attempt to connect to the first peripheral. */ |
| bsncent_connect(); |
| } |
| |
| /** |
| * main |
| * |
| * All application logic and NimBLE host work is performed in default task. |
| * |
| * @return int NOTE: this function should never return! |
| */ |
| int |
| main(void) |
| { |
| int rc; |
| |
| /* Set initial BLE device address. */ |
| memcpy(g_dev_addr, bsncent_cent_public_addr, 6); |
| |
| /* Initialize OS */ |
| sysinit(); |
| |
| /* Configure the host. */ |
| ble_hs_cfg.reset_cb = bsncent_on_reset; |
| ble_hs_cfg.sync_cb = bsncent_on_sync; |
| |
| os_callout_init(&bsncent_print_timer, os_eventq_dflt_get(), |
| bsncent_print_timer_exp, NULL); |
| |
| /* XXX: I think some of these need to be based on # of connections */ |
| /* Initialize data structures to track connected peers. */ |
| rc = peer_init(MYNEWT_VAL(BLE_MAX_CONNECTIONS), 64, 96, 64); |
| assert(rc == 0); |
| |
| /* Set the default device name. */ |
| rc = ble_svc_gap_device_name_set(MYNEWT_VAL(BSNCENT_BLE_NAME)); |
| assert(rc == 0); |
| |
| /* os start should never return. If it does, this should be an error */ |
| while (1) { |
| os_eventq_run(os_eventq_dflt_get()); |
| } |
| |
| return 0; |
| } |
