UWP藍牙低功耗應用盡早斷開連接

Question

因此，我正在為Windows筆記本電腦設計一個應用程序，以連接到定制設計的壓力傳感器。 應用程序與設備配對，然后每10毫秒從設備接收一次通知。 然后由於某種原因通信停止。 我知道這是我的應用程序而不是設備的問題，因為當我連接到手機時，我沒有此問題。

這是我創建devicewatcher並發現設備的主頁：

using System;
using System.Collections.ObjectModel;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Core;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;
using Windows.Devices.Bluetooth;
using Windows.Devices.Enumeration;

// The Blank Page item template is documented at https://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409

namespace BLEInterfaceTest
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainPage : Page
    {
        private DeviceWatcher deviceWatcher;
        private ObservableCollection<DeviceInformation> deviceList = new ObservableCollection<DeviceInformation>();

    public MainPage()
    {
        this.InitializeComponent();
    }

    protected override void OnNavigatedTo(NavigationEventArgs e)
    {
        this.DataContext = deviceList;
        deviceListView.ItemsSource = deviceList;
        deviceWatcher = DeviceInformation.CreateWatcher(
            "System.ItemNameDisplay:~~\"Button\"",
            new string[] {
                "System.Devices.Aep.DeviceAddress",
                "System.Devices.Aep.IsConnected" },
            DeviceInformationKind.AssociationEndpoint);
        deviceWatcher.Added += DeviceWatcher_Added;
        deviceWatcher.Removed += DeviceWatcher_Removed;
        deviceWatcher.Start();
        base.OnNavigatedTo(e);
        SystemNavigationManager.GetForCurrentView().AppViewBackButtonVisibility =
            AppViewBackButtonVisibility.Collapsed;
    }

    protected override void OnNavigatedFrom(NavigationEventArgs e)
    {
        deviceWatcher.Stop();
        base.OnNavigatedFrom(e);
    }

    private async void DeviceWatcher_Removed(DeviceWatcher sender, DeviceInformationUpdate args)
    {
        var toRemove = (from a in deviceList where a.Id == args.Id select a).FirstOrDefault();

        if (toRemove != null)
        {
            await this.Dispatcher.RunAsync(
                Windows.UI.Core.CoreDispatcherPriority.Normal,
                () => { deviceList.Remove(toRemove); });
        }
    }

    private async void DeviceWatcher_Added(DeviceWatcher sender, DeviceInformation args)
    {
        await this.Dispatcher.RunAsync(
            Windows.UI.Core.CoreDispatcherPriority.Normal,
            () => { deviceList.Add(args); });
    }

    private void deviceListView_ItemClick(object sender, ItemClickEventArgs e)
    {
        this.Frame.Navigate(typeof(DevicePage), e.ClickedItem);
    }
  }
}'

下一個代碼是壓力傳感器連接到的頁面以及從設備讀取數據的頁面。

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Core;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;
using Windows.UI.Popups;
using Windows.Devices.Bluetooth.GenericAttributeProfile;
using Windows.Devices.Bluetooth;
using Windows.Devices.Enumeration;
using Windows.Storage.Pickers;
using Windows.Storage;
using Windows.Storage.Streams;
using System.Threading.Tasks;
using Windows.ApplicationModel.Background;


// The Blank Page item template is documented at https://go.microsoft.com/fwlink/?LinkId=234238

namespace BLEInterfaceTest
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class DevicePage : Page
    {
        private DeviceInformation device { get; set; }
        private PressureSensor pSensor { get; set; }
        public static DateTime startTime { get; set; }
        public ObservableCollection<DataPoint> PressureData = new ObservableCollection<DataPoint>();
        public static ObservableCollection<DataPoint> inbetween;
        private static TextBox txtP;
        private BluetoothLEDevice leDevice;
        private DispatcherTimer timer = new DispatcherTimer();
        private int packetNum = 0;

        public DevicePage()
        {
            this.InitializeComponent();
            SystemNavigationManager.GetForCurrentView().BackRequested += DevicePage_BackRequested;
            txtP = txtValue1;
            inbetween = PressureData;
        }

        public static void ChangeText(string text)
        {
            txtP.Text = text;
        }

        private async void InitializePressureSensor(GattDeviceService service)
        {
            pSensor = new PressureSensor(service, SensorUUIDs.PressureSensorUuid);
            await pSensor.EnableNotifications();
            btnStart.IsEnabled = true;
        }

        private async void StartRecievingData()
        {
            try
            {
                leDevice = await BluetoothLEDevice.FromIdAsync(device.Id);
                string selector = "(System.DeviceInterface.Bluetooth.DeviceAddress:=\"" +
                    leDevice.BluetoothAddress.ToString("X") + "\")";
                var services = await leDevice.GetGattServicesAsync(BluetoothCacheMode.Uncached);

                foreach (var service in services.Services)
                {
                    if (service.Uuid.ToString() == SensorUUIDs.ButtonSensorServiceUuid)
                    {
                        InitializePressureSensor(service);
                    }
                }

                timer.Interval = new TimeSpan(0, 0, 0, 0, 1);
                timer.Tick += Timer_Tick1;
                startTime = DateTime.Now;
                timer.Start();
            }

            catch (Exception ex)
            {
                var messageDialog = new MessageDialog("An error has occured Please try again. \n" + ex.Message, "Error!");
            }
        }

        public async void UpdateAllData()
        {
            while (pSensor != null && pSensor.MorePacketsAvailable)
            {
                int[] values = await pSensor.GetPressure();

                int packetNumber = values[0];

                if (packetNumber > packetNum)
                {
                    packetNum = packetNumber;

                    txtValue1.Text = Convert.ToString(values[1]);
                    txtValue2.Text = Convert.ToString(values[5]);

                    for (int i = 1; i < 5; i++)
                    {
                        PressureData.Add(new DataPoint(DateTime.Now - startTime, packetNumber, ((i-1)*2.5 + 10*packetNumber), values[i], values[i + 4]));
                    }
                }
            }
        }

        private void Timer_Tick1(object sender, object e)
        {

            UpdateAllData();
        }

        private async void PairToDevice()
        {
            if (device.Pairing.CanPair)
            {
                var customPairing = device.Pairing.Custom;

                customPairing.PairingRequested += CustomPairing_PairingRequested;

                var result = await customPairing.PairAsync(DevicePairingKinds.ConfirmOnly);

                customPairing.PairingRequested -= CustomPairing_PairingRequested;

                if ((result.Status == DevicePairingResultStatus.Paired) || (result.Status == DevicePairingResultStatus.AlreadyPaired))
                {
                    /*while (device.Pairing.IsPaired == false)
                    {
                        device = await DeviceInformation.CreateFromIdAsync(device.Id);
                    }*/

                    StartRecievingData();
                }


            }

            else if (device.Pairing.IsPaired)
            {
                StartRecievingData();
            }
        }

        private void CustomPairing_PairingRequested(DeviceInformationCustomPairing sender, DevicePairingRequestedEventArgs args)
        {
            args.Accept();
        }

        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            btnSave.Content = "Save";
            btnStop.IsEnabled = false;
            btnStart.IsEnabled = false;
            this.DataContext = PressureData;
            device = (DeviceInformation)e.Parameter;
            PairToDevice();
            //StartRecievingData();

            base.OnNavigatedTo(e);

            Frame rootFrame = Window.Current.Content as Frame;

            if (rootFrame.CanGoBack)
            {
                SystemNavigationManager.GetForCurrentView().AppViewBackButtonVisibility =
                    AppViewBackButtonVisibility.Visible;
            }
        }

        private void DevicePage_BackRequested(object sender, BackRequestedEventArgs eventArgs)
        {
            Frame rootFrame = Window.Current.Content as Frame;

            if (rootFrame == null)
            {
                return;
            }

            // Navigate back if possible, and if the event has already been handled
            if (rootFrame.CanGoBack && eventArgs.Handled ==false)
            {
                eventArgs.Handled = true;
                rootFrame.GoBack();
            }
        }

        private async void btnSave_Click(object sender, RoutedEventArgs e)
        {
            timer.Stop();
            var picker = new FileSavePicker();
            picker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary;
            picker.FileTypeChoices.Add("CSV", new List<string>() { ".csv" });

            StorageFile file = await picker.PickSaveFileAsync();

            if (file != null)
            {
                var stream = await file.OpenAsync(FileAccessMode.ReadWrite);

                using (IOutputStream outputStream = stream.GetOutputStreamAt(0))
                {
                    using (var writer = new DataWriter(outputStream))
                    {
                        foreach (DataPoint p in PressureData)
                        {
                            string text = p.TimeStamp.ToString() + "," + p.PacketNumber.ToString() + "," + p.InternalTimestamp.ToString() + "," + p.PressureValue1.ToString() + "," + p.PressureValue2.ToString() +  "\n";
                            writer.WriteString(text);
                        }

                        await writer.StoreAsync();
                        await writer.FlushAsync();
                    }
                }

                stream.Dispose();
            }
        }

        private async void btnStart_Click(object sender, RoutedEventArgs e)
        {
            if (pSensor != null)
            {
                btnStop.IsEnabled = true;
                btnStart.IsEnabled = false;

                startTime = DateTime.Now;

                if (pSensor != null)
                {
                    await pSensor.BeginCollecting();
                }
            }
        }

        private async void btnStop_Click(object sender, RoutedEventArgs e)
        {
            btnStart.IsEnabled = true;
            btnStop.IsEnabled = false;

            if (pSensor != null)
            {
                await pSensor.StopCollecting();
            }
        }
    }
}

在這里定義用於處理設備連接的SensorBase和PressureSensor類：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Windows.Devices.Bluetooth;
using Windows.Devices.Bluetooth.GenericAttributeProfile;
using Windows.Storage.Streams;
using Windows.Devices.Enumeration;

namespace BLEInterfaceTest
{
    public static class SensorUUIDs
    {
        private static readonly string _packetUuid =           "0000a043-0000-1000-8000-00805f9b34fb";
        private static readonly string _buttonSensorServiceUuid = "0000a042-0000-1000-8000-00805f9b34fb";
        private static readonly string _sensorStateUuid =         "0000a044-0000-1000-8000-00805f9b34fb";

        public static string PressureSensorUuid
        {
            get { return _packetUuid; }
        }

        public static string ButtonSensorServiceUuid
        {
            get { return _buttonSensorServiceUuid; }
        }

        public static string SensorStateUuid
        {
            get { return _sensorStateUuid; }
        }
    }

    public class SensorBase : IDisposable
    {
        protected GattDeviceService deviceService;
        protected string sensorDataUuid;
        protected Queue<byte[]> fifoBuffer;
        protected bool isNotificationSupported = false;
        public bool newData = false;
        private GattCharacteristic dataCharacteristic;

        public SensorBase(GattDeviceService dataService, string sensorDataUuid)
        {
            this.deviceService = dataService;
            this.sensorDataUuid = sensorDataUuid;
            fifoBuffer = new Queue<byte[]>(20);
        }

        public bool MorePacketsAvailable
        {
            get
            {
                if (fifoBuffer.Count > 0)
                {
                    return true;
                }

                else
                {
                    return false;
                }
            }
        }

        public virtual async Task EnableNotifications()
        {
            GattCharacteristicsResult result = await deviceService.GetCharacteristicsAsync();

            foreach (var test in result.Characteristics)
            {
                string t = test.Uuid.ToString();
            }


            isNotificationSupported = true;
            dataCharacteristic = (await deviceService.GetCharacteristicsForUuidAsync(
                new Guid(sensorDataUuid))).Characteristics[0];
            dataCharacteristic.ValueChanged += dataCharacteristic_ValueChanged;
            GattCommunicationStatus status = await dataCharacteristic.WriteClientCharacteristicConfigurationDescriptorAsync(
                GattClientCharacteristicConfigurationDescriptorValue.Notify);

            var currentDescriptorValue = await dataCharacteristic.ReadClientCharacteristicConfigurationDescriptorAsync();

            if (currentDescriptorValue.Status != GattCommunicationStatus.Success
                || currentDescriptorValue.ClientCharacteristicConfigurationDescriptor != GattClientCharacteristicConfigurationDescriptorValue.Notify)
            {
                GattCommunicationStatus status2 = await dataCharacteristic.WriteClientCharacteristicConfigurationDescriptorAsync(
                GattClientCharacteristicConfigurationDescriptorValue.Notify);
            }
        }

        public virtual async Task DisableNotifications()
        {
            newData = false;
            isNotificationSupported = false;
            dataCharacteristic = (await deviceService.GetCharacteristicsForUuidAsync(
                new Guid(sensorDataUuid))).Characteristics[0];
            dataCharacteristic.ValueChanged -= dataCharacteristic_ValueChanged;
            GattCommunicationStatus status = await dataCharacteristic.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.None);
        }

        protected async Task<byte[]> ReadValue()
        {
            if (!isNotificationSupported)
            {
                if (dataCharacteristic == null)
                {
                    dataCharacteristic = (await deviceService.GetCharacteristicsForUuidAsync(
                        new Guid(sensorDataUuid))).Characteristics[0];
                }

                GattReadResult readResult = await dataCharacteristic.ReadValueAsync();
                byte[] data = new byte[readResult.Value.Length];
                DataReader.FromBuffer(readResult.Value).ReadBytes(data);

                fifoBuffer.Enqueue(data);
            }

            return fifoBuffer.Dequeue();
        }

        protected async Task WriteByteArray(string characteristicUuid, byte[] value)
        {
            GattCharacteristic writeCharacteristic = (await deviceService.GetCharacteristicsForUuidAsync(
                        new Guid(characteristicUuid))).Characteristics[0];

            var writer = new DataWriter();
            writer.WriteBytes(value);
            var res = await writeCharacteristic.WriteValueAsync(writer.DetachBuffer(), GattWriteOption.WriteWithoutResponse);
        }

        private void dataCharacteristic_ValueChanged(GattCharacteristic sender, GattValueChangedEventArgs args)
        {
            byte[] data = new byte[args.CharacteristicValue.Length];
            DataReader.FromBuffer(args.CharacteristicValue).ReadBytes(data);
            fifoBuffer.Enqueue(data);
            newData = true;
        }

        public async void Dispose()
        {
            await DisableNotifications();
        }
    }

    public class PressureSensor: SensorBase
    {
        public PressureSensor(GattDeviceService dataService, string sensorDataUuid)
            : base(dataService, sensorDataUuid)
        {

        }

        public async Task BeginCollecting()
        {
            await WriteByteArray(SensorUUIDs.SensorStateUuid, new byte[] { 0x01 });
        }

        public async Task<int[]> GetPressure()
        {
            byte[] data = await ReadValue();

            if (data != null)
            {
                int[] values = new int[9];

                values[0] = (int)BitConverter.ToInt32(data, 0);

                for (int i = 1; i < values.Length; i++)
                {
                    values[i] = (int)BitConverter.ToInt16(data, 2 * i + 2);
                }

                return values;
            }

            else
            {
                return new int[] { 0 };
            }
        }

        public async Task StopCollecting()
        {
            await WriteByteArray(SensorUUIDs.SensorStateUuid, new byte[] { 0x00 });
        }
    }
}

這是我用來組織從壓力傳感器接收的數據的DataPoint類：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.ComponentModel;
using System.Runtime.CompilerServices;

namespace BLEInterfaceTest
{
    public class DataPoint : INotifyPropertyChanged
    {
        private TimeSpan _timestamp;
        private int _packetNumber;
        private double _internalTimestamp;
        private int _pressure1;
        private int _pressure2;

        public event PropertyChangedEventHandler PropertyChanged;

        public TimeSpan TimeStamp
        {
            get { return _timestamp; }
            set
            {
                _timestamp = value;
                this.NotifyPropertyChanged();
            }
        }

        public int PacketNumber
        {
            get { return _packetNumber; }
            set
            {
                _packetNumber = value;
                this.NotifyPropertyChanged();
            }
        }
        public double InternalTimestamp
        {
            get { return _internalTimestamp; }
            set
            {
                _internalTimestamp = value;
                this.NotifyPropertyChanged();
            }
        }

        public int PressureValue1
        {
            get { return _pressure1; }
            set
            {
                _pressure1 = value;
                this.NotifyPropertyChanged();
            }
        }

        public int PressureValue2
        {
            get { return _pressure2; }
            set
            {
                _pressure2 = value;
                this.NotifyPropertyChanged();
            }
        }

        public DataPoint(TimeSpan time,int packetNumber, double internalTimestamp, int pressure1, int pressure2)
        {
            _timestamp = time;
            _packetNumber = packetNumber;
            _internalTimestamp = internalTimestamp;
            _pressure1 = pressure1;
            _pressure2 = pressure2;
        }

        private void NotifyPropertyChanged([CallerMemberName] string propertyName = "")
        {
            if (!string.IsNullOrEmpty(propertyName))
            {
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }
    }
}

我對此進行了廣泛的研究，而我所能找到的只是如何斷開連接的幫助。 我有相反的問題。 我發現一頁顯示該問題可能是由於設備未正確存儲綁定狀態引起的，但是我已經檢查了這一點，並且確實對設備進行了初始化以保存綁定狀態。

有趣的是，如果我在嘗試從設備讀取信息之前未將設備與計算機配對，那么我就沒有問題了。 連接永遠不會隨機停止。 但是，當我這樣做時，計算機不會接收到傳感器設備發送的每個數據包。 它將接收一兩個數據包，然后跳過五個或六個數據包。 如果我配對設備，則我將收到每個數據包，但連接將隨機斷開。

我想我的問題有兩個。 設備配對后如何停止斷開連接？ 或者，是否有一種方法可以讓應用程序在未配對時接收每個數據包？

UPDATE

我意識到我應該在傳感器外圍設備上包含更多信息，以防該代碼中出現錯誤。 在繼續設計嵌入式版本之前，我目前正在設計此傳感器的快速原型。 為此，我將RedBearLabs的BLE Nano 1用作用戶友好的原型。 我正在使用在線MBED編譯器對該設備進行編程。 我已經包括了nRF51822和BLE_API庫來處理藍牙低能耗通信。

更新2因此，在對引起問題的原因進行了更多研究之后，我發現當連接間隔和第2代垃圾回收同時發生時，就會發生斷開連接。 在UWP中，垃圾收集器可以暫停第2代收集的UI線程。 （請參閱此處 ）

我的想法是，如果線程在連接間隔開始時暫停，那么中心將無法啟動與外圍設備的連接，因此外圍設備認為客戶端不再偵聽（請參閱有關BLE連接的更多信息） 。

我通過找出隨機中斷后恢復連接的確切條件來發現這一點。 我從整個連接過程開始，並將其簡化為：

public async Task ReconnectDevice()
{
   GattCommunicationStatus status = await dataCharacteristic.WriteClientCharacteristicConfigurationDescriptorAsync(
      GattClientCharacteristicConfigurationDescriptorValue.Notify);

   await WriteByteArray(SensorUUIDs.SensorStateUuid, new byte[] { 0x01 });
}

因為未處理我的BluetoothLEDevice，GattService和GattCharacteristic對象，所以我要做的就是重新訂閱通知，並將1寫入設備，以便它再次開始收集數據。

自發現這一點以來，我已大大減少了我的應用程序中的內存分配，並且gen2收集的時間平均減少了5毫秒。 同樣，連接斷開之前的時間已增加到大約4-5秒。

UWP具有用於在BackgroundTask中接收通知的GattCharacteristicNotificationTrigger，但是我在將UWP中的后台任務並入方面從未取得過成功。

我想我接下來將嘗試將windows.devices集成到WPF應用程序中，在該應用程序中，我認為我會有更多的機會使其運行。

Answer 1

因此，經過一段時間嘗試不同的想法，我終於偶然發現了解決我的問題的方法。 我必須進行2個更改：

1. 使用未配對的連接，而不是配對的連接。 這樣解決了連接突然掉線的問題。

2. 將連接間隔增加到40 ms。 由於某些原因，我收到了所有數據，不再遇到任何問題。 與Windows設備通信時，任何低於40毫秒的時間都會導致信息丟失（我必須在運行於傳感器上的C代碼上進行此更改。）

進行此更改后，我已經使用了大約2個月的設備，並且完全沒有問題。

Answer 2

在我看來，這些問題與BluetoothCacheMode枚舉有關。 這表明某些藍牙API方法是應該對系統中緩存的值進行操作還是從藍牙設備中檢索這些值。 使用BluetoothCacheMode.Uncached屬性允許服務在需要時更新屬性。 如果設備已配對，則不需要BluetoothCacheMode（我認為BluetoothCacheMode.Cached是默認設置）。 在您的代碼行中：

var services = await leDevice.GetGattServicesAsync(BluetoothCacheMode.Uncached);

如果配對，可能會導致連接丟失。

GetGattServicesAsync（），GetCharacteristicsAsync（）和ReadValueAsync（）必須具有屬性BluetoothCacheMode.Uncache（未配對），默認配對或BluetoothCacheMode.Cached（未配對）。 請參閱https://msdn.microsoft.com/en-us/library/windows/apps/dn263758.aspx 。