2020-10-02 15:16:48 -04:00
|
|
|
#include "components/datetime/DateTimeController.h"
|
|
|
|
#include <systemtask/SystemTask.h>
|
|
|
|
#include "components/ble/NotificationManager.h"
|
2020-04-25 07:09:47 -04:00
|
|
|
#include <hal/nrf_rtc.h>
|
2020-04-19 15:26:09 -04:00
|
|
|
#include "NimbleController.h"
|
2020-07-20 16:28:21 -04:00
|
|
|
#include "MusicService.h"
|
2020-04-19 15:26:09 -04:00
|
|
|
#include <services/gatt/ble_svc_gatt.h>
|
|
|
|
#include <services/gap/ble_svc_gap.h>
|
|
|
|
#include <host/util/util.h>
|
|
|
|
#include <host/ble_hs_id.h>
|
|
|
|
#include <host/ble_hs.h>
|
|
|
|
#include <host/ble_gap.h>
|
2020-04-25 07:09:47 -04:00
|
|
|
|
2020-04-19 15:26:09 -04:00
|
|
|
using namespace Pinetime::Controllers;
|
|
|
|
|
2020-04-25 07:09:47 -04:00
|
|
|
NimbleController::NimbleController(Pinetime::System::SystemTask& systemTask,
|
2020-04-27 14:13:27 -04:00
|
|
|
Pinetime::Controllers::Ble& bleController,
|
2020-04-25 07:09:47 -04:00
|
|
|
DateTime& dateTimeController,
|
2020-05-11 12:50:37 -04:00
|
|
|
Pinetime::Controllers::NotificationManager& notificationManager,
|
2020-09-27 14:02:47 -04:00
|
|
|
Controllers::Battery& batteryController,
|
2020-05-11 12:50:37 -04:00
|
|
|
Pinetime::Drivers::SpiNorFlash& spiNorFlash) :
|
2020-04-25 07:09:47 -04:00
|
|
|
systemTask{systemTask},
|
2020-04-27 14:13:27 -04:00
|
|
|
bleController{bleController},
|
2020-04-25 07:09:47 -04:00
|
|
|
dateTimeController{dateTimeController},
|
|
|
|
notificationManager{notificationManager},
|
2020-05-11 12:50:37 -04:00
|
|
|
spiNorFlash{spiNorFlash},
|
|
|
|
dfuService{systemTask, bleController, spiNorFlash},
|
2020-04-25 07:09:47 -04:00
|
|
|
currentTimeClient{dateTimeController},
|
2020-04-28 13:39:26 -04:00
|
|
|
anService{systemTask, notificationManager},
|
2020-06-01 14:40:11 -04:00
|
|
|
alertNotificationClient{systemTask, notificationManager},
|
2020-07-20 16:28:21 -04:00
|
|
|
currentTimeService{dateTimeController},
|
2020-09-27 14:02:47 -04:00
|
|
|
musicService{systemTask},
|
2020-09-27 14:59:06 -04:00
|
|
|
batteryInformationService{batteryController},
|
2020-10-29 11:06:01 -04:00
|
|
|
immediateAlertService{systemTask, notificationManager},
|
|
|
|
serviceDiscovery({¤tTimeClient, &alertNotificationClient}) {
|
2020-04-22 14:19:36 -04:00
|
|
|
}
|
|
|
|
|
2020-04-19 15:26:09 -04:00
|
|
|
int GAPEventCallback(struct ble_gap_event *event, void *arg) {
|
|
|
|
auto nimbleController = static_cast<NimbleController*>(arg);
|
|
|
|
return nimbleController->OnGAPEvent(event);
|
|
|
|
}
|
|
|
|
|
|
|
|
void NimbleController::Init() {
|
|
|
|
while (!ble_hs_synced()) {}
|
|
|
|
|
|
|
|
ble_svc_gap_init();
|
|
|
|
ble_svc_gatt_init();
|
|
|
|
|
2020-04-23 14:34:38 -04:00
|
|
|
deviceInformationService.Init();
|
2020-04-23 14:57:53 -04:00
|
|
|
currentTimeClient.Init();
|
2020-05-04 16:43:51 -04:00
|
|
|
currentTimeService.Init();
|
2020-07-11 16:37:28 -04:00
|
|
|
musicService.Init();
|
2020-04-28 13:39:26 -04:00
|
|
|
anService.Init();
|
2020-04-27 14:16:03 -04:00
|
|
|
dfuService.Init();
|
2020-09-27 14:02:47 -04:00
|
|
|
batteryInformationService.Init();
|
2020-09-27 14:59:06 -04:00
|
|
|
immediateAlertService.Init();
|
2020-04-19 15:26:09 -04:00
|
|
|
int res;
|
|
|
|
res = ble_hs_util_ensure_addr(0);
|
2020-05-02 11:42:26 -04:00
|
|
|
ASSERT(res == 0);
|
2020-04-19 15:26:09 -04:00
|
|
|
res = ble_hs_id_infer_auto(0, &addrType);
|
2020-05-02 11:42:26 -04:00
|
|
|
ASSERT(res == 0);
|
2020-04-19 15:26:09 -04:00
|
|
|
res = ble_svc_gap_device_name_set(deviceName);
|
2020-05-02 11:42:26 -04:00
|
|
|
ASSERT(res == 0);
|
2020-06-08 15:51:34 -04:00
|
|
|
Pinetime::Controllers::Ble::BleAddress address;
|
|
|
|
res = ble_hs_id_copy_addr(addrType, address.data(), nullptr);
|
|
|
|
ASSERT(res == 0);
|
|
|
|
bleController.AddressType((addrType == 0) ? Ble::AddressTypes::Public : Ble::AddressTypes::Random);
|
|
|
|
bleController.Address(std::move(address));
|
|
|
|
|
2020-05-02 11:42:26 -04:00
|
|
|
res = ble_gatts_start();
|
|
|
|
ASSERT(res == 0);
|
2020-04-19 15:26:09 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void NimbleController::StartAdvertising() {
|
2020-10-28 13:23:09 -04:00
|
|
|
if(bleController.IsConnected() || ble_gap_conn_active() || ble_gap_adv_active()) return;
|
2020-06-01 14:40:11 -04:00
|
|
|
|
2020-09-20 05:09:50 -04:00
|
|
|
ble_svc_gap_device_name_set(deviceName);
|
2020-04-19 15:26:09 -04:00
|
|
|
|
|
|
|
/* set adv parameters */
|
|
|
|
struct ble_gap_adv_params adv_params;
|
|
|
|
struct ble_hs_adv_fields fields;
|
|
|
|
/* advertising payload is split into advertising data and advertising
|
|
|
|
response, because all data cannot fit into single packet; name of device
|
|
|
|
is sent as response to scan request */
|
|
|
|
struct ble_hs_adv_fields rsp_fields;
|
|
|
|
|
|
|
|
/* fill all fields and parameters with zeros */
|
|
|
|
memset(&adv_params, 0, sizeof(adv_params));
|
|
|
|
memset(&fields, 0, sizeof(fields));
|
|
|
|
memset(&rsp_fields, 0, sizeof(rsp_fields));
|
|
|
|
|
|
|
|
adv_params.conn_mode = BLE_GAP_CONN_MODE_UND;
|
|
|
|
adv_params.disc_mode = BLE_GAP_DISC_MODE_GEN;
|
|
|
|
|
|
|
|
fields.flags = BLE_HS_ADV_F_DISC_GEN |
|
|
|
|
BLE_HS_ADV_F_BREDR_UNSUP;
|
|
|
|
// fields.uuids128 = BLE_UUID128(BLE_UUID128_DECLARE(
|
|
|
|
// 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
|
|
|
|
// 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff));
|
2020-04-27 14:16:03 -04:00
|
|
|
fields.uuids128 = &dfuServiceUuid;
|
|
|
|
fields.num_uuids128 = 1;
|
|
|
|
fields.uuids128_is_complete = 1;
|
2020-04-19 15:26:09 -04:00
|
|
|
fields.tx_pwr_lvl = BLE_HS_ADV_TX_PWR_LVL_AUTO;
|
|
|
|
|
2020-09-20 05:09:50 -04:00
|
|
|
rsp_fields.name = (uint8_t *)deviceName;
|
|
|
|
rsp_fields.name_len = strlen(deviceName);
|
2020-04-19 15:26:09 -04:00
|
|
|
rsp_fields.name_is_complete = 1;
|
|
|
|
|
2020-08-17 10:31:00 -04:00
|
|
|
ble_gap_adv_set_fields(&fields);
|
2020-05-07 13:53:51 -04:00
|
|
|
// ASSERT(res == 0); // TODO this one sometimes fails with error 22 (notsync)
|
2020-04-19 15:26:09 -04:00
|
|
|
|
2020-08-17 10:31:00 -04:00
|
|
|
ble_gap_adv_rsp_set_fields(&rsp_fields);
|
2020-05-07 13:53:51 -04:00
|
|
|
// ASSERT(res == 0);
|
2020-04-19 15:26:09 -04:00
|
|
|
|
2020-08-17 10:31:00 -04:00
|
|
|
ble_gap_adv_start(addrType, NULL, 180000,
|
2020-04-19 15:26:09 -04:00
|
|
|
&adv_params, GAPEventCallback, this);
|
2020-05-24 10:51:50 -04:00
|
|
|
// ASSERT(res == 0);// TODO I've disabled these ASSERT as they sometime asserts and reset the mcu.
|
2020-05-16 10:13:22 -04:00
|
|
|
// For now, the advertising is restarted as soon as it ends. There may be a race condition
|
|
|
|
// that prevent the advertising from restarting reliably.
|
|
|
|
// I remove the assert to prevent this uncesseray crash, but in the long term, the management of
|
|
|
|
// the advertising should be improve (better error handling, and advertise for 3 minutes after
|
|
|
|
// the application has been woken up, for example.
|
2020-04-19 15:26:09 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
int NimbleController::OnGAPEvent(ble_gap_event *event) {
|
|
|
|
switch (event->type) {
|
|
|
|
case BLE_GAP_EVENT_ADV_COMPLETE:
|
|
|
|
NRF_LOG_INFO("Advertising event : BLE_GAP_EVENT_ADV_COMPLETE");
|
2020-05-02 11:42:26 -04:00
|
|
|
NRF_LOG_INFO("advertise complete; reason=%dn status=%d", event->adv_complete.reason, event->connect.status);
|
2020-04-19 15:26:09 -04:00
|
|
|
break;
|
|
|
|
case BLE_GAP_EVENT_CONNECT: {
|
|
|
|
NRF_LOG_INFO("Advertising event : BLE_GAP_EVENT_CONNECT");
|
|
|
|
|
|
|
|
/* A new connection was established or a connection attempt failed. */
|
|
|
|
NRF_LOG_INFO("connection %s; status=%d ", event->connect.status == 0 ? "established" : "failed",
|
|
|
|
event->connect.status);
|
|
|
|
|
|
|
|
if (event->connect.status != 0) {
|
|
|
|
/* Connection failed; resume advertising. */
|
|
|
|
StartAdvertising();
|
2020-04-27 14:13:27 -04:00
|
|
|
bleController.Disconnect();
|
2020-04-22 14:19:36 -04:00
|
|
|
} else {
|
2020-04-27 14:13:27 -04:00
|
|
|
bleController.Connect();
|
2020-05-01 15:58:31 -04:00
|
|
|
systemTask.PushMessage(Pinetime::System::SystemTask::Messages::BleConnected);
|
2020-04-22 14:19:36 -04:00
|
|
|
connectionHandle = event->connect.conn_handle;
|
2020-05-01 15:58:31 -04:00
|
|
|
// Service discovery is deffered via systemtask
|
2020-04-19 15:26:09 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case BLE_GAP_EVENT_DISCONNECT:
|
|
|
|
NRF_LOG_INFO("Advertising event : BLE_GAP_EVENT_DISCONNECT");
|
2020-05-02 11:42:26 -04:00
|
|
|
NRF_LOG_INFO("disconnect; reason=%d", event->disconnect.reason);
|
2020-04-19 15:26:09 -04:00
|
|
|
|
|
|
|
/* Connection terminated; resume advertising. */
|
2020-10-28 13:23:09 -04:00
|
|
|
currentTimeClient.Reset();
|
|
|
|
alertNotificationClient.Reset();
|
2020-05-01 15:58:31 -04:00
|
|
|
connectionHandle = BLE_HS_CONN_HANDLE_NONE;
|
2020-04-27 14:13:27 -04:00
|
|
|
bleController.Disconnect();
|
2020-04-19 15:26:09 -04:00
|
|
|
StartAdvertising();
|
|
|
|
break;
|
|
|
|
case BLE_GAP_EVENT_CONN_UPDATE:
|
|
|
|
NRF_LOG_INFO("Advertising event : BLE_GAP_EVENT_CONN_UPDATE");
|
|
|
|
/* The central has updated the connection parameters. */
|
|
|
|
NRF_LOG_INFO("connection updated; status=%d ", event->conn_update.status);
|
|
|
|
break;
|
|
|
|
case BLE_GAP_EVENT_ENC_CHANGE:
|
|
|
|
/* Encryption has been enabled or disabled for this connection. */
|
|
|
|
NRF_LOG_INFO("encryption change event; status=%d ", event->enc_change.status);
|
|
|
|
return 0;
|
|
|
|
case BLE_GAP_EVENT_SUBSCRIBE:
|
|
|
|
NRF_LOG_INFO("subscribe event; conn_handle=%d attr_handle=%d "
|
|
|
|
"reason=%d prevn=%d curn=%d previ=%d curi=???\n",
|
|
|
|
event->subscribe.conn_handle,
|
|
|
|
event->subscribe.attr_handle,
|
|
|
|
event->subscribe.reason,
|
|
|
|
event->subscribe.prev_notify,
|
|
|
|
event->subscribe.cur_notify,
|
|
|
|
event->subscribe.prev_indicate);
|
|
|
|
return 0;
|
|
|
|
case BLE_GAP_EVENT_MTU:
|
|
|
|
NRF_LOG_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. */
|
|
|
|
struct ble_gap_conn_desc desc;
|
|
|
|
ble_gap_conn_find(event->repeat_pairing.conn_handle, &desc);
|
|
|
|
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;
|
2020-04-25 07:09:47 -04:00
|
|
|
|
|
|
|
case BLE_GAP_EVENT_NOTIFY_RX: {
|
|
|
|
/* Peer sent us a notification or indication. */
|
|
|
|
size_t notifSize = OS_MBUF_PKTLEN(event->notify_rx.om);
|
|
|
|
|
|
|
|
NRF_LOG_INFO("received %s; conn_handle=%d attr_handle=%d "
|
|
|
|
"attr_len=%d",
|
|
|
|
event->notify_rx.indication ?
|
|
|
|
"indication" :
|
|
|
|
"notification",
|
|
|
|
event->notify_rx.conn_handle,
|
|
|
|
event->notify_rx.attr_handle,
|
|
|
|
notifSize);
|
|
|
|
|
|
|
|
alertNotificationClient.OnNotification(event);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/* Attribute data is contained in event->notify_rx.attr_data. */
|
|
|
|
|
2020-04-19 15:26:09 -04:00
|
|
|
default:
|
2020-05-01 09:36:48 -04:00
|
|
|
// NRF_LOG_INFO("Advertising event : %d", event->type);
|
2020-04-19 15:26:09 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-05-01 15:58:31 -04:00
|
|
|
void NimbleController::StartDiscovery() {
|
2020-10-29 11:06:01 -04:00
|
|
|
serviceDiscovery.StartDiscovery(connectionHandle);
|
2020-05-01 15:58:31 -04:00
|
|
|
}
|
|
|
|
|
2020-04-22 14:19:36 -04:00
|
|
|
|
2020-07-20 16:28:21 -04:00
|
|
|
uint16_t NimbleController::connHandle() {
|
|
|
|
return connectionHandle;
|
|
|
|
}
|
2020-04-22 14:19:36 -04:00
|
|
|
|