EMDK 蓝牙本地设备

Question

一个简单的问题是，如何获取已使用 Motorola EMDK 2.4 与 MC75 设备配对的本地蓝牙设备？似乎我可以获取 RemoteDevice 列表，但没有方法可以查看本地堆栈和已配对的内容，这样我可以读取已分配的串行端口并自动为用户打开 SerialPort 对象。

Answer 1

答案是您不这样做或不能...您可以使用 Microsoft 蓝牙。下载此适用于摩托罗拉设备上的 Windows Mobile 蓝牙...也可能适用于其他设备。您可以从移动示例中获取，我在硬盘驱动器上找到了它...C:\Program Files (x86)\Windows Mobile 6 SDK\Samples\Common\CS\Bluetooth。我将其添加到我的项目中，然后我所要做的就是将所有当前配对的设备添加到列表框中，

BluetoothRadio radio = new BluetoothRadio();
listBox1.DataSource = radio.PairedDevices;
listBox1.DisplayMember = "Name";

然后当选择一个设备时，您可以将其作为蓝牙设备访问，如下所示：

BluetoothDevice device = listBox1.SelectedItem as BluetoothDevice;

然后您开始流式传输，

    if (device != null) {
         BTConnectionManager.Instance.startThread(
                    StandardServices.SerialPortServiceGuid,
                    new ThreadStart(StreamProcessor));

    if (BTConnectionManager.Instance.Connect(device)) { 
        ...Do something...

我必须修改StreamProcessor 和 BTConnectionManager 有点适合我，但这是我的版本，其中没有表单引用。

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading;
using System.Net.Sockets;
using Microsoft.WindowsMobile.SharedSource.Bluetooth;

namespace Project2 {
/// <summary>
/// Connection Manager to marshal the data connection and reference the
/// data streams to push/pull data.
/// </summary>
public class BTConnectionManager {
    BTConnectionManager() { }

    /// <summary>
    /// reference the Singleton and make a singleton object out of
    /// this since we only want one for now.
    /// </summary>
    public static BTConnectionManager Instance {
        get {
            return Nested.instance;
        }
    }

    /// <summary>
    /// easiest way to make this a singleton that is thread safe.
    /// </summary>
    class Nested {
        static Nested() { }
        internal static readonly BTConnectionManager instance = new BTConnectionManager();
    }

    /// <summary>
    /// The Bluetooth radio.
    /// </summary>
    private BluetoothRadio radio = new BluetoothRadio();


    /// <summary>
    /// Guid of the Bluetooth service
    /// </summary>
    private Guid guid;

    /// <summary>
    /// Thread function that processes data from the stream.
    /// </summary>
    private ThreadStart streamProcessor;

    /// <summary>
    /// The two-way communication stream to the other Bluetooth device.
    /// </summary>
    private NetworkStream stream;

    /// <summary>
    /// A BinaryReader on top of this.stream
    /// </summary>
    private BinaryReader reader;

    /// <summary>
    /// A BinaryWriter on top of this.stream
    /// </summary>
    private BinaryWriter writer;

    /// <summary>
    /// Should we stop the service thread, in preparation for 
    /// exiting the app?
    /// </summary>
    private bool exiting = false;

    /// <summary>
    /// The Bluetooth service.
    /// </summary>
    private BluetoothService bluetoothService;

    /// <summary>
    /// A BinaryWriter used to write to the other Bluetooth device.
    /// </summary>
    public BinaryWriter Writer {
        get { return writer; }
    }

    /// <summary>
    /// A BinaryReader used to read from the other Bluetooth device.
    /// </summary>
    public BinaryReader Reader {
        get { return reader; }
    }

    /// <summary>
    /// Gets a value indicating whether a connection is established with 
    /// the other Bluetooth device.
    /// </summary>
    public bool Connected {
        get { return stream != null; }
    }


    /// <summary>
    /// The two-way communication stream to the other Bluetooth device.
    /// </summary>
    private NetworkStream Stream {
        get { return stream; }
        set {
            stream = value;
            if (stream == null) {
                if (writer != null) {
                    writer.Close();
                    writer = null;
                }
                if (reader != null) {
                    reader.Close();
                    reader = null;
                }
            } else {
                writer = new BinaryWriter(stream);
                reader = new BinaryReader(stream);
            }
        }
    }


    /// <summary>
    /// Creates a new instance of a ConnectionManager.
    /// </summary>
    /// <param name="guid">The Bluetooth service guid.</param>
    /// <param name="streamProcessor">A callback function that will read and process data from the stream.</param>
    public void startThread(Guid guid, ThreadStart dataProcessor) {
        this.guid = guid;
        this.streamProcessor = dataProcessor;
        Thread t = new Thread(new ThreadStart(ServiceThread));
        t.Start();
    }



    /// <summary>
    /// The thread that listens for Bluetooth connections, and processes
    /// the data read from a connection once established.
    /// </summary>
    private void ServiceThread() {
        bluetoothService = new BluetoothService(this.guid);

        while (!exiting) {
            if (!bluetoothService.Started) {
                bluetoothService.Start();
            }
            try {
                this.Stream = bluetoothService.AcceptConnection();
            } catch (System.Net.Sockets.SocketException) {
                // bluetoothService.Stop() was called.  
                // Treat this like a graceful return from AcceptConnection().
            }
            if (!exiting) {
                // Call the streamProcessor to handle the data from the stream.
                streamProcessor();
            }
        }
        exiting = false;

    }

    /// <summary>
    /// Force the service thread to exit.
    /// </summary>
    public void Exit() {
        // This will cause us to fall out of the ServiceThread() loop.
        exiting = true;

        if (!Connected) {
            // We must be waiting on AcceptConnection(), so we need to
            // force an exception to break out.
            bluetoothService.Stop();
        }
    }


    /// <summary>
    /// Connect to another Bluetooth device.
    /// </summary>
    public bool Connect(BluetoothDevice device) {
        if (device != null) {
            try {
                this.Stream = device.Connect(this.guid);
            } catch (System.Net.Sockets.SocketException) {
                // Couldn't connect.
            }

            if (this.Stream == null) {
                System.Windows.Forms.MessageBox.Show("Could not connect to device " + device.Name);
                return false;
            } else {
                // Forcibly break out of the AcceptConnection in 
                // ServiceThread(), and continue on to streamProcessor().
                bluetoothService.Stop();
                return true;
            }
        }
        return false;
    }

    /// <summary>
    /// Disconnect from the other Bluetooth device.
    /// </summary>
    public void Disconnect() {
        Stream = null;
    }



    internal void Disconnect(BluetoothDevice device) {
        Disconnect();
    }
}
}