C# ble 4.0 低能耗 蓝牙交互

最新推荐文章于 2024-06-13 17:50:04 发布
最新推荐文章于 2024-06-13 17:50:04 发布
阅读量1.9w 收藏 105
点赞数 19
分类专栏： C#
原文链接：https://www.cnblogs.com/webtojs/p/9675956.html
版权 
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.Devices.Enumeration;
using Windows.Foundation;
using Windows.Networking;
using Windows.Networking.Proximity;
using Windows.Networking.Sockets;
using Windows.Security.Cryptography;
using Windows.Storage.Streams;

namespace BleSolution
{
    public class BleCore
    {
        private Boolean asyncLock = false;

        /// <summary>
        /// 搜索蓝牙设备对象
        /// </summary>
        private DeviceWatcher deviceWatcher;

        /// <summary>
        /// 当前连接的服务
        /// </summary>
        public GattDeviceService CurrentService { get; set; }

        /// <summary>
        /// 当前连接的蓝牙设备
        /// </summary>
        public BluetoothLEDevice CurrentDevice { get; set; }

        /// <summary>
        /// 写特征对象
        /// </summary>
        public GattCharacteristic CurrentWriteCharacteristic { get; set; }

        /// <summary>
        /// 通知特征对象
        /// </summary>
        public GattCharacteristic CurrentNotifyCharacteristic { get; set; }

        /// <summary>
        /// 特性通知类型通知启用
        /// </summary>
        private const GattClientCharacteristicConfigurationDescriptorValue CHARACTERISTIC_NOTIFICATION_TYPE = GattClientCharacteristicConfigurationDescriptorValue.Notify;

        /// <summary>
        /// 存储检测到的设备
        /// </summary>
        private List<BluetoothLEDevice> DeviceList = new List<BluetoothLEDevice>();

        /// <summary>
        /// 定义搜索蓝牙设备委托
        /// </summary>
        public delegate void DeviceWatcherChangedEvent(MsgType type, BluetoothLEDevice bluetoothLEDevice);

        /// <summary>
        /// 搜索蓝牙事件
        /// </summary>
        public event DeviceWatcherChangedEvent DeviceWatcherChanged;

        /// <summary>
        /// 获取服务委托
        /// </summary>
        public delegate void GattDeviceServiceAddedEvent(GattDeviceService gattDeviceService);

        /// <summary>
        /// 获取服务事件
        /// </summary>
        public event GattDeviceServiceAddedEvent GattDeviceServiceAdded;

        /// <summary>
        /// 获取特征委托
        /// </summary>
        public delegate void CharacteristicAddedEvent(GattCharacteristic gattCharacteristic);

        /// <summary>
        /// 获取特征事件
        /// </summary>
        public event CharacteristicAddedEvent CharacteristicAdded;

        /// <summary>
        /// 提示信息委托
        /// </summary>
        public delegate void MessAgeChangedEvent(MsgType type, string message, byte[] data = null);

        /// <summary>
        /// 提示信息事件
        /// </summary>
        public event MessAgeChangedEvent MessAgeChanged;

        /// <summary>
        /// 当前连接的蓝牙Mac
        /// </summary>
        private string CurrentDeviceMAC { get; set; }

        public BleCore()
        {

        }

        /// <summary>
        /// 搜索蓝牙设备
        /// </summary>
        public void StartBleDeviceWatcher()
        {
            string[] requestedProperties = { "System.Devices.Aep.DeviceAddress", "System.Devices.Aep.IsConnected", "System.Devices.Aep.Bluetooth.Le.IsConnectable" };
            string aqsAllBluetoothLEDevices = "(System.Devices.Aep.ProtocolId:=\"{bb7bb05e-5972-42b5-94fc-76eaa7084d49}\")";

            this.deviceWatcher =
                    DeviceInformation.CreateWatcher(
                        aqsAllBluetoothLEDevices,
                        requestedProperties,
                        DeviceInformationKind.AssociationEndpoint);

            // Register event handlers before starting the watcher.
            this.deviceWatcher.Added += this.DeviceWatcher_Added;
            this.deviceWatcher.Stopped += this.DeviceWatcher_Stopped;
            this.deviceWatcher.Start();
            string msg = "自动发现设备中..";

            this.MessAgeChanged(MsgType.NotifyTxt, msg);
        }

        /// <summary>
        /// 停止搜索蓝牙
        /// </summary>
        public void StopBleDeviceWatcher()
        {
            this.deviceWatcher.Stop();
        }

        /// <summary>
        /// 获取发现的蓝牙设备
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private void DeviceWatcher_Added(DeviceWatcher sender, DeviceInformation args)
        {
            this.MessAgeChanged(MsgType.NotifyTxt, "发现设备:" + args.Id);
            this.Matching(args.Id);
        }

        /// <summary>
        /// 停止搜索蓝牙设备
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private void DeviceWatcher_Stopped(DeviceWatcher sender, object args)
        {
            string msg = "自动发现设备停止";
            this.MessAgeChanged(MsgType.NotifyTxt, msg);
        }

        /// <summary>
        /// 匹配
        /// </summary>
        /// <param name="Device"></param>
        public void StartMatching(BluetoothLEDevice Device)
        {
            this.CurrentDevice = Device;
        }

        /// <summary>
        /// 获取蓝牙服务
        /// </summary>
        public async void FindService()
        {
            var GattServices = this.CurrentDevice.GattServices;
            foreach (GattDeviceService ser in GattServices)
            {
                this.GattDeviceServiceAdded(ser);
            }
        }

        /// <summary>
        /// 获取特性
        /// </summary>
        public async void FindCharacteristic(GattDeviceService gattDeviceService)
        {
            this.CurrentService = gattDeviceService;
            foreach (var c in gattDeviceService.GetAllCharacteristics())
            {
                this.CharacteristicAdded(c);
            }
        }

        /// <summary>
        /// 获取操作
        /// </summary>
        /// <returns></returns>
        public async Task SetOpteron(GattCharacteristic gattCharacteristic)
        {
            if (gattCharacteristic.CharacteristicProperties == GattCharacteristicProperties.Write)
            {
                this.CurrentWriteCharacteristic = gattCharacteristic;
            }
            if (gattCharacteristic.CharacteristicProperties == GattCharacteristicProperties.Notify)
            {
                this.CurrentNotifyCharacteristic = gattCharacteristic;
            }
            if ((uint)gattCharacteristic.CharacteristicProperties == 26)
            { }

            if (gattCharacteristic.CharacteristicProperties == (GattCharacteristicProperties.Notify | GattCharacteristicProperties.Read | GattCharacteristicProperties.Write))
            {
                this.CurrentWriteCharacteristic = gattCharacteristic;

                this.CurrentNotifyCharacteristic = gattCharacteristic;
                this.CurrentNotifyCharacteristic.ProtectionLevel = GattProtectionLevel.Plain;
                this.CurrentNotifyCharacteristic.ValueChanged += Characteristic_ValueChanged;
                await this.EnableNotifications(CurrentNotifyCharacteristic);
            }

            this.Connect();
        }

        /// <summary>
        /// 连接蓝牙
        /// </summary>
        /// <returns></returns>
        private async Task Connect()
        {
            byte[] _Bytes1 = BitConverter.GetBytes(this.CurrentDevice.BluetoothAddress);
            Array.Reverse(_Bytes1);
            this.CurrentDeviceMAC = BitConverter.ToString(_Bytes1, 2, 6).Replace('-', ':').ToLower();

            string msg = "正在连接设备<" + this.CurrentDeviceMAC + ">..";
            this.MessAgeChanged(MsgType.NotifyTxt, msg);
            this.CurrentDevice.ConnectionStatusChanged += this.CurrentDevice_ConnectionStatusChanged;
        }

        /// <summary>
        /// 搜索到的蓝牙设备
        /// </summary>
        /// <returns></returns>
        private async Task Matching(string Id)
        {
            try
            {
                BluetoothLEDevice.FromIdAsync(Id).Completed = async (asyncInfo, asyncStatus) =>
                {
                    if (asyncStatus == AsyncStatus.Completed)
                    {
                        BluetoothLEDevice bleDevice = asyncInfo.GetResults();
                        this.DeviceList.Add(bleDevice);
                        this.DeviceWatcherChanged(MsgType.BleDevice, bleDevice);
                    }
                };
            }
            catch (Exception e)
            {
                string msg = "没有发现设备" + e.ToString();
                this.MessAgeChanged(MsgType.NotifyTxt, msg);
                this.StartBleDeviceWatcher();
            }
        }

        /// <summary>
        /// 主动断开连接
        /// </summary>
        /// <returns></returns>
        public void Dispose()
        {

            CurrentDeviceMAC = null;
            CurrentService?.Dispose();
            CurrentDevice?.Dispose();
            CurrentDevice = null;
            CurrentService = null;
            CurrentWriteCharacteristic = null;
            CurrentNotifyCharacteristic = null;
            MessAgeChanged(MsgType.NotifyTxt, "主动断开连接");
        }

        private void CurrentDevice_ConnectionStatusChanged(BluetoothLEDevice sender, object args)
        {
            if (sender.ConnectionStatus == BluetoothConnectionStatus.Disconnected && CurrentDeviceMAC != null)
            {
                string msg = "设备已断开,自动重连";
                MessAgeChanged(MsgType.NotifyTxt, msg);
                if (!asyncLock)
                {
                    asyncLock = true;
                    this.CurrentDevice.Dispose();
                    this.CurrentDevice = null;
                    CurrentService = null;
                    CurrentWriteCharacteristic = null;
                    CurrentNotifyCharacteristic = null;
                    SelectDeviceFromIdAsync(CurrentDeviceMAC);
                }
            }
            else
            {
                string msg = "设备已连接";
                MessAgeChanged(MsgType.NotifyTxt, msg);
            }
        }

        /// <summary>
        /// 按MAC地址直接组装设备ID查找设备
        /// </summary>
        public async Task SelectDeviceFromIdAsync(string MAC)
        {
            CurrentDeviceMAC = MAC;
            CurrentDevice = null;
            BluetoothAdapter.GetDefaultAsync().Completed = async (asyncInfo, asyncStatus) =>
            {
                if (asyncStatus == AsyncStatus.Completed)
                {
                    BluetoothAdapter mBluetoothAdapter = asyncInfo.GetResults();
                    byte[] _Bytes1 = BitConverter.GetBytes(mBluetoothAdapter.BluetoothAddress);//ulong转换为byte数组
                    Array.Reverse(_Bytes1);
                    string macAddress = BitConverter.ToString(_Bytes1, 2, 6).Replace('-', ':').ToLower();
                    string Id = "BluetoothLE#BluetoothLE" + macAddress + "-" + MAC;
                    await Matching(Id);
                }
            };
        }

        /// <summary>
        /// 设置特征对象为接收通知对象
        /// </summary>
        /// <param name="characteristic"></param>
        /// <returns></returns>
        public async Task EnableNotifications(GattCharacteristic characteristic)
        {
            string msg = "收通知对象=" + CurrentDevice.ConnectionStatus;
            this.MessAgeChanged(MsgType.NotifyTxt, msg);

            characteristic.WriteClientCharacteristicConfigurationDescriptorAsync(CHARACTERISTIC_NOTIFICATION_TYPE).Completed = async (asyncInfo, asyncStatus) =>
            {
                if (asyncStatus == AsyncStatus.Completed)
                {
                    GattCommunicationStatus status = asyncInfo.GetResults();
                    if (status == GattCommunicationStatus.Unreachable)
                    {
                        msg = "设备不可用";
                        this.MessAgeChanged(MsgType.NotifyTxt, msg);
                        if (CurrentNotifyCharacteristic != null && !asyncLock)
                        {
                            await this.EnableNotifications(CurrentNotifyCharacteristic);
                        }
                    }
                    asyncLock = false;
                    msg = "设备连接状态" + status;
                    this.MessAgeChanged(MsgType.NotifyTxt, msg);
                }
            };
        }

        /// <summary>
        /// 接受到蓝牙数据
        /// </summary>
        private void Characteristic_ValueChanged(GattCharacteristic sender, GattValueChangedEventArgs args)
        {
            byte[] data;
            CryptographicBuffer.CopyToByteArray(args.CharacteristicValue, out data);
            string str = BitConverter.ToString(data);
            this.MessAgeChanged(MsgType.BleData, str, data);
        }

        /// <summary>
        /// 发送数据接口
        /// </summary>
        /// <returns></returns>
        public async Task Write(byte[] data)
        {
            if (CurrentWriteCharacteristic != null)
            {
                CurrentWriteCharacteristic.WriteValueAsync(CryptographicBuffer.CreateFromByteArray(data), GattWriteOption.WriteWithResponse);
                string str = "发送数据：" + BitConverter.ToString(data);
                this.MessAgeChanged(MsgType.BleData, str, data);
            }

        }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace BleSolution
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            CheckForIllegalCrossThreadCalls = false;
            this.bleCore.MessAgeChanged += BleCore_MessAgeChanged;
            this.bleCore.DeviceWatcherChanged += BleCore_DeviceWatcherChanged;
            this.bleCore.GattDeviceServiceAdded += BleCore_GattDeviceServiceAdded;
            this.bleCore.CharacteristicAdded += BleCore_CharacteristicAdded;
            this.Init();
        }

        // 异步线程
        public static void RunAsync(Action action)
        {
            ((Action)(delegate ()
            {
                action.Invoke();
            })).BeginInvoke(null, null);
        }

        BleCore bleCore = new BleCore();
        /// <summary>
        /// 存储检测到的设备
        /// </summary>
        List<Windows.Devices.Bluetooth.BluetoothLEDevice> DeviceList = new List<Windows.Devices.Bluetooth.BluetoothLEDevice>();

        /// <summary>
        /// 当前蓝牙服务列表
        /// </summary>
        List<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService> GattDeviceServices = new List<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService>();

        /// <summary>
        /// 当前蓝牙服务特征列表
        /// </summary>
        List<Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic> GattCharacteristics = new List<Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic>();

        private void btnSearch_Click(object sender, EventArgs e)
        {
            if (this.btnSearch.Text == "搜索")
            {
                this.listboxMessage.Items.Clear();
                this.listboxBleDevice.Items.Clear();
                this.bleCore.StartBleDeviceWatcher();
                this.btnSearch.Text = "停止";
            }
            else
            {
                this.bleCore.StopBleDeviceWatcher();
                this.btnSearch.Text = "搜索";
            }
        }

        private void btnConnect_Click(object sender, EventArgs e)
        {
            if (this.listboxBleDevice.SelectedItem != null)
            {
                string DeviceName = this.listboxBleDevice.SelectedItem.ToString();
                Windows.Devices.Bluetooth.BluetoothLEDevice bluetoothLEDevice = this.DeviceList.Where(u => u.Name == DeviceName).FirstOrDefault();
                if (bluetoothLEDevice != null)
                {
                    bleCore.StartMatching(bluetoothLEDevice);
                    this.btnServer.Enabled = true;
                }
                else
                {
                    MessageBox.Show("没有发现此蓝牙，请重新搜索.");
                    this.btnServer.Enabled = false;
                }
            }
            else
            {
                MessageBox.Show("请选择连接的蓝牙.");
                this.btnServer.Enabled = false;
            }
        }

        private void btnServer_Click(object sender, EventArgs e)
        {
            this.cmbServer.Items.Clear();
            this.bleCore.FindService();
        }

        private void btnFeatures_Click(object sender, EventArgs e)
        {
            this.cmbFeatures.Items.Clear();
            if (this.cmbServer.SelectedItem != null)
            {
                var item = this.GattDeviceServices.Where(u => u.Uuid == new Guid(this.cmbServer.SelectedItem.ToString())).FirstOrDefault();
                this.bleCore.FindCharacteristic(item);
            }
            else
            {
                MessageBox.Show("选择蓝牙服务.");
            }
        }

        private void btnOpteron_Click(object sender, EventArgs e)
        {
            if (this.cmbFeatures.SelectedItem != null)
            {
                var item = this.GattCharacteristics.Where(u => u.Uuid == new Guid(this.cmbFeatures.SelectedItem.ToString())).FirstOrDefault();
                this.bleCore.SetOpteron(item);
                if (item.CharacteristicProperties == (Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristicProperties.Notify | Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristicProperties.Read | Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristicProperties.Write))
                {
                    this.btnReader.Enabled = true;
                    this.btnSend.Enabled = true;
                }
            }
            else
            {
                MessageBox.Show("选择蓝牙服务.");
            }
        }

        private void btnReader_Click(object sender, EventArgs e)
        {

        }

        private void btnSend_Click(object sender, EventArgs e)
        {
            byte[] dataBytes = new byte[6];

            dataBytes[0] = 0x23;
            dataBytes[1] = 0x00;
            dataBytes[2] = 0x02;
            dataBytes[3] = 0x01;
            dataBytes[4] = (byte)(dataBytes[1] + dataBytes[2] + dataBytes[3]);
            dataBytes[5] = 0x2A;

            this.bleCore.Write(dataBytes);
        }

        /// <summary>
        /// 提示消息
        /// </summary>
        private void BleCore_MessAgeChanged(MsgType type, string message, byte[] data)
        {
            RunAsync(() =>
            {
                this.listboxMessage.Items.Add(message);
            });
        }

        /// <summary>
        /// 搜索蓝牙设备列表
        /// </summary>
        private void BleCore_DeviceWatcherChanged(MsgType type, Windows.Devices.Bluetooth.BluetoothLEDevice bluetoothLEDevice)
        {
            RunAsync(() =>
            {
                this.listboxBleDevice.Items.Add(bluetoothLEDevice.Name);
                this.DeviceList.Add(bluetoothLEDevice);
                this.btnConnect.Enabled = true;
            });
        }

        /// <summary>
        /// 获取蓝牙服务列表
        /// </summary>
        private void BleCore_GattDeviceServiceAdded(Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService gattDeviceService)
        {
            RunAsync(() =>
            {
                this.cmbServer.Items.Add(gattDeviceService.Uuid.ToString());
                this.GattDeviceServices.Add(gattDeviceService);
                this.btnFeatures.Enabled = true;
            });
        }

        /// <summary>
        /// 获取特征列表
        /// </summary>
        private void BleCore_CharacteristicAdded(Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic gattCharacteristic)
        {
            RunAsync(() =>
            {
                this.cmbFeatures.Items.Add(gattCharacteristic.Uuid);
                this.GattCharacteristics.Add(gattCharacteristic);
                this.btnOpteron.Enabled = true;
            });
        }

        private void Init()
        {
            this.btnConnect.Enabled = false;
            this.btnServer.Enabled = false;
            this.btnFeatures.Enabled = false;
            this.btnOpteron.Enabled = false;
            this.btnReader.Enabled = false;
            this.btnSend.Enabled = false;
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            this.bleCore.Dispose();
        }
    }
}

 

 

关于服务和特性：蓝牙的服务和特性包含了多种，对于开发来说无非就是通知、读、写，所以只需要过滤uuid的头就可以了

关于蓝牙服务：其实可以直接过滤uuid使用标准协议uuid的前缀：0000ffff0

关于蓝牙特征：也是可以直接过滤uuid使用标准协议uuid的前缀：0000ffff1

跳过选选择服务和特性，这两个uuid的权限比较足，给了通知、读、写的功能，对于开发来说已经足够了。

美中不足的：在搜索蓝牙设备非常花时间，大概10~20s左右才能搜索出来

关于，在universal windows  sdk 找不到引用：一直没发现是什么问题，很多博主都说重装windows SDK和windows form模块可以解决，但我重试了很多次还是无法解决。

我的解决办法是：直接浏览引用：可直接使用windows sdk 的组件内容。

C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETCore\v4.5\System.Runtime.WindowsRuntime.dll

C:\Program Files (x86)\Windows Kits\10\UnionMetadata\10.0.18362.0\Windows.winmd

非常感谢 鞪林 博主的的文章，在其上做了一些改动

https://www.cnblogs.com/webtojs/p/9675956.html

解决蓝牙搜索慢的问题：

搜索对象改用未：Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher deviceWatcher;

感谢https://blog.youkuaiyun.com/shengfakun1234/article/details/110928783  https://blog.youkuaiyun.com/shengfakun1234 解决搜索慢的问题

            this.deviceWatcher = new Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher();
            this.deviceWatcher.ScanningMode = Windows.Devices.Bluetooth.Advertisement.BluetoothLEScanningMode.Active;
            this.deviceWatcher.SignalStrengthFilter.InRangeThresholdInDBm = -80;
            this.deviceWatcher.SignalStrengthFilter.OutOfRangeThresholdInDBm = -90;
            this.deviceWatcher.SignalStrengthFilter.OutOfRangeTimeout = TimeSpan.FromMilliseconds(5000);
            this.deviceWatcher.SignalStrengthFilter.SamplingInterval = TimeSpan.FromMilliseconds(2000);

            this.deviceWatcher.Received += DeviceWatcher_Received;

        private void DeviceWatcher_Received(Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs args)
        {
            BluetoothLEDevice.FromBluetoothAddressAsync(args.BluetoothAddress).Completed = async (asyncInfo, asyncStatus) =>
            {
                if (asyncStatus == AsyncStatus.Completed)
                {
                    if (asyncInfo.GetResults() != null)
                    {
                        BluetoothLEDevice currentDevice = asyncInfo.GetResults();

                        Boolean contain = false;
                        foreach (BluetoothLEDevice device in DeviceList)//过滤重复的设备
                        {
                            if (device.DeviceId == currentDevice.DeviceId)
                            {
                                contain = true;
                            }
                        }
                        if (!contain)
                        {
                            this.DeviceList.Add(currentDevice);
                            this.DeviceWatcherChanged(currentDevice);
                        }
                    }
                }
            };

        }

 

 

关于蓝牙连接不上去，大伙可能有很多疑意，下面更新连接的两种方式
这里的MAC就是DeviceId，像：BluetoothLE#BluetoothLE20:0d:b0:16:00:ce-50:51:a9:7d:07:73

连接的时候使用的是id，通过前缀和mac拼接的一个ID，用这个ID去连接

1：按MAC地址查找系统中配对设备

当前设备PC已经已经连接或者配对成功的列表，从PC中寻找这个MAC配对，如果PC未配对则无法找到设备

        /// <summary>
        /// 按MAC地址查找系统中配对设备
        /// </summary>
        /// <param name="MAC"></param>
        public async Task SelectDevice(string MAC)
        {
            CurrentDeviceMAC = MAC;
            CurrentDevice = null;
            DeviceInformation.FindAllAsync(BluetoothLEDevice.GetDeviceSelector()).Completed = async (asyncInfo, asyncStatus) =>
            {
                if (asyncStatus == AsyncStatus.Completed)
                {
                    DeviceInformationCollection deviceInformation = asyncInfo.GetResults();
                    foreach (DeviceInformation di in deviceInformation)
                    {
                        await Matching(di.Id);
                    }
                    if (CurrentDevice == null)
                    {
                        string msg = "没有发现设备";
                        StartBleDeviceWatcher();
                    }
                }
            };
        }

2：按MAC地址直接组装设备ID查找设备

在系统之外寻找并且配对，就是说当前PC未连接配对的设备，添加新的蓝牙、打印机设备并且连接

        /// <summary>
        /// 按MAC地址直接组装设备ID查找设备
        /// </summary>
        /// <param name="MAC"></param>
        /// <returns></returns>
        public async Task SelectDeviceFromIdAsync(string MAC)
        {
            CurrentDeviceMAC = MAC;
            CurrentDevice = null;
            BluetoothAdapter.GetDefaultAsync().Completed = async (asyncInfo, asyncStatus) =>
            {
                if (asyncStatus == AsyncStatus.Completed)
                {
                    BluetoothAdapter mBluetoothAdapter = asyncInfo.GetResults();
                    if (mBluetoothAdapter != null)
                    {
                        await Matching(MAC);
                    }
                    else
                    {
                        string msg = "查找连接蓝牙设备异常.";
                    }
                }

            };
        }

 

代码地址：https://download.youkuaiyun.com/download/code_long/13686504

C# windows与ESP32 BLE蓝牙通讯
Dao_Dao_Yang的博客
04-14 2003
再次执行代码，会发现程序可以给ESP32发送信息，但是ESP32发送的信息我们无法收到，原因是老师源代码可能使用的服务是write|Notify，我实际使用需要将这两个服务分开，因此单独跳入Notify的if判断中时，没有注册接事件。然后参考网上其他老师的帖子，几个老师都提供了一个BleCore的类，但cv过来发现存在各种引用问题，整个痛苦的过程，就不描述了，综合网上其他资料直接上结果。直接执行老师的代码，选择想要连接的蓝牙名字或者地址，把名字或地址卸载老师留好的位置上，就能获得服务的UUID。
windows BLE编程 net winform 连接蓝牙低功耗
03-29
winform 程序调用Windows.Devices.Bluetoot API 实现windows下BLE蓝牙设备自动连接，收发数据功能。不需要使用win10的UWP开发。 实际例子用vs2022编写,可直接编译运行
蓝牙BLE上位机工具开发理论线索梳理_4.蓝牙和蓝牙 LE 服务
最新发布
huaqianzkh的专栏
06-13 813
蓝牙协议支持多个服务，它们全都遵循相同的基本格式。GUID 中的第一组数字因服务而异，但所有蓝牙 GUID 都以 -0000-1000-8000-00805F9B34FB 结尾。例如，RFCOMM 服务开头含有 0x0003，因此完整的 ID 会是 00000003-0000-1000-8000-00805F9B34FB。下表列出了一些常见的蓝牙服务。属于蓝牙协议或蓝牙 LE 协议这两种协议之一。
C#ble低功耗蓝牙
03-07
弄了好久的C#WINFORM上的低功耗蓝牙，需要在WIN10上 VS2017上运行的。
C#和低功耗蓝牙BLE通讯
weixin_40314351的博客
03-07 9445
以前都是用手机APP和蓝牙设备通信，现在在一个项目中需要更改为用电脑端上位机与蓝牙通讯的需求，在此记录自己走过的坑和积攒的经验。
C#低功耗蓝牙通信
12-25
Windows下低功耗网上的资料真的是太少了，终于找到一个有用的上传一下，很多坑都一个个攻克了，这个代码是可行的，实践以证明
C#控制台使用低功耗蓝牙BLE进行多设备通信小结
热门推荐
A_DUO的博客
06-19 1万+
1、使用的为 Windows.Devices.Bluetooth 2、使用的是windows设备蓝牙，和两个外接蓝牙进行通信，外界蓝牙通过串口调试工具进行收发数据显示。 3、本计算机系统为win10，支持版本为win8以上，但未尝试win8 4、原工程为UWP实现，改为C#控制台实现，winform也可以(都为.NET Framework，应该没问题，但未具体操作)
c#低能耗蓝牙连接
小杉杉的博客
11-18 2797
在初学中遇到了很多问题 -好不容易调试成功-特意分享给大家 界面： 连接成功 核心代码 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using Windows.Devices.Bluetooth; using Windows.Devices.Bluetooth.Advertisement; using Windows.
C#蓝牙4.0，低耗蓝牙源码例子
10-22
首先，理解蓝牙4.0低耗能技术的核心概念是必要的。BLE设计的目标是减少能源消耗，提供短距离、高效率的无线通信。它主要服务于那些需要长时间工作但电池有限的设备，如健康监测器、运动追踪器等。BLE协议栈包括广告...
c# ble 4.0 低能耗 蓝牙交互 代码下载
07-09
### 回答1： C是一个字母，也是拉丁字母表中的第三个字母。它在英语中的发音为/si:/，是一个全音的辅音音素。C的字形是一个半圆形，向右弯曲。C也有着一些其他的意义和用法。 在数学中，C代表着复数集，复数是由...
一种通过VS2019，C#语言的Windows版本与低功耗蓝牙通信的源码
02-24
Windows端 C# winform与低功耗蓝牙设备的检测，连接，通信，关闭。需引用库windows.winmd以及System.Runtime.WindowsRuntime.dll
一种通过VS2017，c#语言的Windows版本与低功耗蓝牙通信的源码
06-23
因为需要unity研发pc端与低功耗蓝牙的项目需求。这边做了一个以c# wfm后台运行程序为服务的蓝牙通信中介（VS2017），调通了数据，但是后期与unity通信需要自己根据自己项目去设计研发。这边只做了Windows 端与低功耗蓝牙设备的检测，连接，通信，关闭。
Bluno终端C#源代码-BLE操作
12-29
Bluno终端是拥有集成蓝牙4.0的Bluno开发板并兼容Arduino UNO的无线终端。本应用可以通过蓝牙4.0（BLE）连接到并与Bluno开发板交互。我们可以通过本应用发送AT命令来配置BLE。我们也可以在本应用和Arduino代码程序之间读写数据，只需要初始化相应串口速率为115200（语法： Serial.begin(115200);），然后就可以读写数据了。也可以把Bluno终端看成是一款串口助手应用。程序本身为Windows 8 Store应用，可非常方便改写或增加Windows Phone 8.1应用。程序在Windows 8.1下调试及测试。
C++实现 蓝牙BLE客户端(蓝牙调试工具)
12-27
windows visual studio C++ 蓝牙BLE客户端(蓝牙调试工具)的完整源码和例子，可用于调试蓝牙BLE的开发板，比如esp32。自己用了很多年，稳定，代码结构清晰 //注册通知回调 RegisterBleDeviceRecvData(call_back); //搜索蓝牙，打印搜索结果 ScanBLEDevice(5000); //根据搜索结果ID，连接制定蓝牙 char ID[] = "BluetoothLE#BluetoothLE60:e9:aa:1e:d4:02-34:85:18:98:e1:b2"; BLEHandle handle = ConnectBLEDevice(ID); if (NULL == handle) { printf("连接失败\n"); return -1; } //遍历Service和Characteristic unsigned int UUIDArryS[100] = { 0 };
蓝牙低功耗.zip
11-05
蓝牙低功耗技术最初由蓝牙特别兴趣小组（SIG）于2010年推出，作为蓝牙4.0的一部分，后来在蓝牙5.0、5.1和5.2版本中得到进一步增强。BLE的主要特点是低功耗、低成本和广泛的兼容性，使得它在可穿戴设备、健康监测、...
C#实现BLE4.0蓝牙低能耗交互编程指南
在蓝牙低能耗（BLE 4.0）的编程领域中，开发者会接触到多个关键概念： 1. **蓝牙低功耗（BLE）**：BLE是一种专为低功耗通信设计的蓝牙技术，它与传统的蓝牙技术相比，能够显著降低设备的能耗。BLE适用于健康监测...
掌握C# Windows蓝牙低能耗开发
标题和描述提到的关键知识点是使用C#语言在Windows环境下编写蓝牙低功耗（Bluetooth Low Energy，简称BLE）的应用程序，并提供了一个具体的代码示例或项目名称“BluetoothLEExplorer”。为了详细探讨这一主题，我们...
蓝牙4.0BLE开发
guoyanfang_yuge的博客
03-19 444
BLE全名为Bluetooth Low Energy 顾名思义，蓝牙低能耗。蓝牙4.0以上称之为BLE4.0以下称之为传统蓝牙，二者的区别为：1、低能耗，蓝牙4.0设备与周围设备交流时，其峰值能耗仅为传统蓝牙设备的一半2、传输距离，100米以上3、使用128-bit  AES完全加密，为数据封包提供高度加密性及认证度4、低延时。最短可在3ms内完成连接设置并开始传输数据（传统蓝牙设备延时最高达10...
c# 低功耗蓝牙_C＃中建立从笔记本电脑内置蓝牙4.0流蓝牙低功耗（BLE）外设
weixin_39685578的博客
12-20 477
I am trying to write a program that connects to a Bluetooth Low Energy device (BLE), and then read a characteristic either on updates, or on a given interval.My Peripheral is a Texas instruments CC254...
评论 78
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值