C# 使用.Net内核在Raspberry Pi上使用蓝牙LE

我想在.NETCore中构建一个GATT客户端。它将部署到运行Raspbian Lite的RPi3上，控制多个BLE设备。目前是否在.Net核心框架（2.2或3预览版）中支持蓝牙LE

我知道在RPi上使用Windows 10 IoT上的UWP库有另一种选择，但我更喜欢运行Raspbian Lite。目前这种堆栈还有其他选择吗？

Background BlueZ是Linux上的蓝牙协议栈。BlueZ开发人员鼓励使用他们的高级应用程序。（来源：或，幻灯片22。）D-Bus允许您控制各种系统服务，并且有许多平台的D-Bus绑定/包，包括.Net Core。因此，使用针对Linux的.Net（例如Raspbian Lite）编写GATT客户机或GATT服务器应该有点简单

解决方案 对于.Net Core，您可以使用它访问D-Bus。DBus附带了一个工具，用于为D总线服务生成C#接口。我使用bluetoothctl（BlueZ交互式命令行工具）扫描并连接到一个BLE外围设备，然后使用dotnet dbus codegen——总线系统——服务组织.BlueZ生成C#接口

示例代码

dotnet dbus codegen

生成的代码摘录：

[DBusInterface("org.bluez.Adapter1")]
interface IAdapter1 : IDBusObject
{
    Task StartDiscoveryAsync();
    Task SetDiscoveryFilterAsync(IDictionary<string, object> Properties);
    Task StopDiscoveryAsync();
    Task RemoveDeviceAsync(ObjectPath Device);
    Task<string[]> GetDiscoveryFiltersAsync();
    Task<T> GetAsync<T>(string prop);
    Task<Adapter1Properties> GetAllAsync();
    Task SetAsync(string prop, object val);
    Task<IDisposable> WatchPropertiesAsync(Action<PropertyChanges> handler);
}

[DBusInterface("org.bluez.Device1")]
interface IDevice1 : IDBusObject
{
    Task DisconnectAsync();
    Task ConnectAsync();
    Task ConnectProfileAsync(string UUID);
    Task DisconnectProfileAsync(string UUID);
    Task PairAsync();
    Task CancelPairingAsync();
    Task<T> GetAsync<T>(string prop);
    Task<Device1Properties> GetAllAsync();
    Task SetAsync(string prop, object val);
    Task<IDisposable> WatchPropertiesAsync(Action<PropertyChanges> handler);
}

[DBusInterface("org.bluez.GattService1")]
interface IGattService1 : IDBusObject
{
    Task<T> GetAsync<T>(string prop);
    Task<GattService1Properties> GetAllAsync();
    Task SetAsync(string prop, object val);
    Task<IDisposable> WatchPropertiesAsync(Action<PropertyChanges> handler);
}

[DBusInterface("org.bluez.GattCharacteristic1")]
interface IGattCharacteristic1 : IDBusObject
{
    Task<byte[]> ReadValueAsync(IDictionary<string, object> Options);
    Task WriteValueAsync(byte[] Value, IDictionary<string, object> Options);
    Task<(CloseSafeHandle fd, ushort mtu)> AcquireWriteAsync(IDictionary<string, object> Options);
    Task<(CloseSafeHandle fd, ushort mtu)> AcquireNotifyAsync(IDictionary<string, object> Options);
    Task StartNotifyAsync();
    Task StopNotifyAsync();
    Task<T> GetAsync<T>(string prop);
    Task<GattCharacteristic1Properties> GetAllAsync();
    Task SetAsync(string prop, object val);
    Task<IDisposable> WatchPropertiesAsync(Action<PropertyChanges> handler);
}

[DBusInterface（“org.bluez.Adapter1”）]
接口IAdapter1:IDBusObject
{
任务开始查找同步（）；
任务集DiscoveryFilterAsync（IDictionary属性）；
任务停止发现同步（）；
任务移除设备同步（ObjectPath设备）；
任务GetDiscoveryFilterAsync（）；
任务GetAsync（字符串属性）；
任务，一个针对BlueZ的.Net核心库的快速尝试。它在我的Raspberry Pi（after）上工作，可能很有用。但是，如果您在使用该包时遇到问题，我建议您尝试直接访问。作为如何使用D-Bus API扫描、连接、配对等的一个很好的示例。
它看起来像广告，但支持Windows 10 IoT（.NET核心）。软件包中有控制台演示。不幸的是，我们没有在raspbian上测试它，因为它使用了一些与Windows相关的功能。感谢@MikePetrichenko的回复。我刚刚尝试了Bluetooth Framework，但没有成功。首先它需要libunwind.so.8，我可以安装它，但后来在典型的Windows libra上出现异常，失败了ry:system.dllnotfoundexception:无法加载dll'advapi32.dll这可能是提示库解决此问题：感谢您的尝试。我不是100%确定，但似乎可以修改库以使iut在您的平台上工作。您能给我发电子邮件吗mike@btframework.com与您的任务描述，以便我可以尝试删除advapi依赖项并向您发送测试版本？如果对您合适的话，我将在未来几周内完成。我也有同样的要求。有没有想法在Raspbian上用dotnet core安装gatt服务器？太好了！很高兴在我的第一个谷歌上找到这个，您在18小时前发布了一个答案！：-我认为不需要这样做使用第三方库来实现连接到可编程设备这样的基本功能。也就是说，我一定会尝试一下！如果它有效，我会接受它作为解决方案。@RaymondBrink我想可以说，.NET Core的构建并不是为了在Linux上成为桌面或设备平台（与Windows.NET Core或.NET Framework不同）它可能会随着System.Maui（又名Xamarin Forms）的出现而改变，但他们已经宣布他们的Linux支持是社区驱动的。即使在Xamarin中，基本包也不包括BLE。我如何创建GATT服务器并在Raspberry Pi上使用D-Bus进行宣传？@ParsaKarami你找到方法了吗？我目前正在做类似的工作，需要创建GATT服务器和adver用覆盆子皮4蘸着吃
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// The code generated by `dotnet dbus codegen`.
using bluez.DBus;
// See https://developers.redhat.com/blog/2017/09/18/connecting-net-core-d-bus/ or https://github.com/tmds/Tmds.DBus
using Tmds.DBus;

// Use the `bluetoothctl` command-line tool or the Bluetooth Manager GUI to scan for devices and possibly pair.
// Then you can use this program to connect and print "Device Information" GATT service values.
class Program
{
  static string defaultAdapterName = "hci0";
  static TimeSpan timeout = TimeSpan.FromSeconds(15);

  static async Task Main(string[] args)
  {
    if (args.Length < 1)
    {
      Console.WriteLine("Usage: BlueZExample <deviceAddress> [adapterName]");
      Console.WriteLine("Example: BlueZExample AA:BB:CC:11:22:33 hci1");
      return;
    }

    var deviceAddress = args[0];
    var adapterName = args.Length > 1 ? args[1] : defaultAdapterName;

    // Get the Bluetooth adapter.
    var adapterObjectPath = $"/org/bluez/{adapterName}";
    var adapter = Connection.System.CreateProxy<IAdapter1>(BluezConstants.DBusService, adapterObjectPath);
    if (adapter == null)
    {
      Console.WriteLine($"Bluetooth adapter '{adapterName}' not found.");
    }

    // Find the Bluetooth peripheral.
    var device = await adapter.GetDeviceAsync(deviceAddress);
    if (device == null)
    {
      Console.WriteLine($"Bluetooth peripheral with address '{deviceAddress}' not found. Use `bluetoothctl` or Bluetooth Manager to scan and possibly pair first.");
      return;
    }

    Console.WriteLine("Connecting...");
    await device.ConnectAsync();
    await WaitForPropertyValueAsync<bool>("Connected", device.GetConnectedAsync, value: true, timeout);
    Console.WriteLine("Connected.");

    Console.WriteLine("Waiting for services to resolve...");
    await WaitForPropertyValueAsync<bool>("ServicesResolved", device.GetServicesResolvedAsync, value: true, timeout);

    var servicesUUID = await device.GetUUIDsAsync();
    Console.WriteLine($"Device offers {servicesUUID.Length} service(s).");

    var deviceInfoServiceFound = servicesUUID.Any(uuid => String.Equals(uuid, GattConstants.DeviceInformationServiceUUID, StringComparison.OrdinalIgnoreCase));
    if (!deviceInfoServiceFound)
    {
      Console.WriteLine("Device doesn't have the Device Information Service. Try pairing first?");
      return;
    }

    // Console.WriteLine("Retrieving Device Information service...");
    var service = await device.GetServiceAsync(GattConstants.DeviceInformationServiceUUID);
    var modelNameCharacteristic = await service.GetCharacteristicAsync(GattConstants.ModelNameCharacteristicUUID);
    var manufacturerCharacteristic = await service.GetCharacteristicAsync(GattConstants.ManufacturerNameCharacteristicUUID);

    int characteristicsFound = 0;
    if (modelNameCharacteristic != null)
    {
        characteristicsFound++;
        Console.WriteLine("Reading model name characteristic...");
        var modelNameBytes = await modelNameCharacteristic.ReadValueAsync(timeout);
        Console.WriteLine($"Model name: {Encoding.UTF8.GetString(modelNameBytes)}");
    }

    if (manufacturerCharacteristic != null)
    {
        characteristicsFound++;
        Console.WriteLine("Reading manufacturer characteristic...");
        var manufacturerBytes = await manufacturerCharacteristic.ReadValueAsync(timeout);
        Console.WriteLine($"Manufacturer: {Encoding.UTF8.GetString(manufacturerBytes)}");
    }

    if (characteristicsFound == 0)
    {
        Console.WriteLine("Model name and manufacturer characteristics not found.");
    }
  }

  static async Task WaitForPropertyValueAsync<T>(string propertyName, Func<Task<T>> action, T value, TimeSpan timeout)
  {
    // Ideally we'd wait for D-Bus PropertyChanged events to fire, but for now we'll poll.
    // Also ideally we'd be able to read property values for any D-Bus object, but for now we take a function.
    var watch = Stopwatch.StartNew();
    while (watch.Elapsed <= timeout)
    {
      await Task.Delay(50);

      if ((await action()).Equals(value))
      {
        return;
      }
    }

    throw new TimeoutException($"Timed out waiting for {propertyName} to equal {value}.");
  }
}

// Extensions that make it easier to get a D-Bus object or read a characteristic value.
static class Extensions
{
  public static Task<IReadOnlyList<IDevice1>> GetDevicesAsync(this IAdapter1 adapter)
  {
    return GetProxiesAsync<IDevice1>(adapter, BluezConstants.Device1Interface);
  }

  public static async Task<IDevice1> GetDeviceAsync(this IAdapter1 adapter, string deviceAddress)
  {
    var devices = await GetProxiesAsync<IDevice1>(adapter, BluezConstants.Device1Interface);

    var matches = new List<IDevice1>();
    foreach (var device in devices)
    {
      if (String.Equals(await device.GetAddressAsync(), deviceAddress, StringComparison.OrdinalIgnoreCase))
      {
          matches.Add(device);
      }
    }

    // BlueZ can get in a weird state, probably due to random public BLE addresses.
    if (matches.Count > 1)
    {
        throw new Exception($"{matches.Count} devices found with the address {deviceAddress}!");
    }

    return matches.FirstOrDefault();
  }

  public static async Task<IGattService1> GetServiceAsync(this IDevice1 device, string serviceUUID)
  {
    var services = await GetProxiesAsync<IGattService1>(device, BluezConstants.GattServiceInterface);

    foreach (var service in services)
    {
      if (String.Equals(await service.GetUUIDAsync(), serviceUUID, StringComparison.OrdinalIgnoreCase))
      {
        return service;
      }
    }

    return null;
  }

  public static async Task<IGattCharacteristic1> GetCharacteristicAsync(this IGattService1 service, string characteristicUUID)
  {
    var characteristics = await GetProxiesAsync<IGattCharacteristic1>(service, BluezConstants.GattCharacteristicInterface);

    foreach (var characteristic in characteristics)
    {
      if (String.Equals(await characteristic.GetUUIDAsync(), characteristicUUID, StringComparison.OrdinalIgnoreCase))
      {
        return characteristic;
      }
    }

    return null;
  }

  public static async Task<byte[]> ReadValueAsync(this IGattCharacteristic1 characteristic, TimeSpan timeout)
  {
    var options = new Dictionary<string, object>();
    var readTask = characteristic.ReadValueAsync(options);
    var timeoutTask = Task.Delay(timeout);

    await Task.WhenAny(new Task[] { readTask, timeoutTask });
    if (!readTask.IsCompleted)
    {
      throw new TimeoutException("Timed out waiting to read characteristic value.");
    }

    return await readTask;
  }

  private static async Task<IReadOnlyList<T>> GetProxiesAsync<T>(IDBusObject rootObject, string interfaceName)
  {
    // Console.WriteLine("GetProxiesAsync called.");
    var objectManager = Connection.System.CreateProxy<IObjectManager>(BluezConstants.DBusService, "/");
    var objects = await objectManager.GetManagedObjectsAsync();

    var matchingObjects = objects
      .Where(obj => obj.Value.Keys.Contains(interfaceName))
      .Select(obj => obj.Key)
      .Where(objectPath => objectPath.ToString().StartsWith($"{rootObject.ObjectPath}/"));

    var proxies = matchingObjects
      .Select(objectPath => Connection.System.CreateProxy<T>(BluezConstants.DBusService, objectPath))
      .ToList();

    // Console.WriteLine($"GetProxiesAsync returning {proxies.Count} proxies of type {typeof(T)}.");
    return proxies;
  }
}

static class GattConstants
{
  // "Device Information" GATT service
  // https://www.bluetooth.org/docman/handlers/downloaddoc.ashx?doc_id=244369
  public const string DeviceInformationServiceUUID = "0000180a-0000-1000-8000-00805f9b34fb";
  public const string ModelNameCharacteristicUUID = "00002a24-0000-1000-8000-00805f9b34fb";
  public const string ManufacturerNameCharacteristicUUID = "00002a29-0000-1000-8000-00805f9b34fb";
}

static class BluezConstants
{
  public const string DBusService = "org.bluez";
  public const string Adapter1Interface = "org.bluez.Adapter1";
  public const string Device1Interface = "org.bluez.Device1";
  public const string GattServiceInterface = "org.bluez.GattService1";
  public const string GattCharacteristicInterface = "org.bluez.GattCharacteristic1";
}