OpenEdv-开源电子网

 找回密码
 立即注册
正点原子全套STM32/Linux/FPGA开发资料，上千讲STM32视频教程免费下载...
OpenEdv-开源电子网»首页 › 操作系统/图形界面 › Linux › 《I.MX6U 嵌入式Qt开发指南》第二十章 USB Bluetooth
返回列表 发新帖
查看: 3377|回复: 0

《I.MX6U 嵌入式Qt开发指南》第二十章 USB Bluetooth

[复制链接]
正点原子运营

1117

主题

1128

帖子

2

精华

超级版主

Rank: 8Rank: 8

积分
4666
金钱
4666
注册时间
2019-5-8
在线时间
1224 小时
发表于 2022-8-29 10:43:37 | 显示全部楼层 |阅读模式
正点原子逻辑分析仪DL16热卖中，最多16通道，采样率最高可达1GHz，存储深度可达3.5Gbit
本帖最后由 正点原子运营 于 2022-8-29 10:43 编辑

1）实验平台：正点原子阿尔法Linux开发板
2)  章节摘自【正点原子】《I.MX6U 嵌入式Qt开发指南》
3）购买链接:https://detail.tmall.com/item.htm?id=609033604451
4）全套实验源码+手册+视频下载地址：http://www.openedv.com/docs/boards/arm-linux/zdyz-i.mx6ull.html
5）正点原子官方B站：https://space.bilibili.com/394620890
6）正点原子阿尔法Linux交流群：1027879335




第二十章 USB Bluetooth

Qt官方提供了蓝牙的相关类和API函数，也提供了相关的例程给我们参考。编者根据Qt官方的例程编写出适合我们Ubuntu和正点原子I.MX6U开发板的例程。注意Windows上不能使用Qt的蓝牙例程，因为底层需要有BlueZ协议栈，而Windows没有。Windows可能需要去移植。编者就不去探究了。确保我们正点原子I.MX6U开发板与Ubuntu可用即可，所以大家还是老实的用Ubuntu来开发吧！

20.1 资源简介
在正点原子IMX6U开发板上虽然没有带板载蓝牙，但是可以外接免驱USB蓝牙，直接在USB接口插上一个USB蓝牙模块就可以进行本章节的实验了。详细请看【正点原子】I.MX6U用户快速体验V1.x.pdf的第3.29小节蓝牙测试，先了解蓝牙是如何在Linux上如何使用的，切记先看正点原子快速体验文档，了解用哪种蓝牙芯片，和怎么测试蓝牙的。本Qt教程就不再介绍了。

20.2 应用实例
  1. 1   QT       += core gui bluetooth
  2. 2
  3. 3   greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
  4. 4
  5. 5   CONFIG += c++11
  6. 6
  7. 7   # The following define makes your compiler emit warnings if you use
  8. 8   # any Qt feature that has been marked deprecated (the exact warnings
  9. 9   # depend on your compiler). Please consult the documentation of the
  10. 10  # deprecated API in order to know how to port your code away from it.
  11. 11  DEFINES += QT_DEPRECATED_WARNINGS
  12. 12
  13. 13  # You can also make your code fail to compile if it uses deprecated APIs.
  14. 14  # In order to do so, uncomment the following line.
  15. 15  # You can also select to disable deprecated APIs only up to a certain version of Qt.
  16. 16  #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
  17. 17
  18. 18  SOURCES += \
  19. 19      chatclient.cpp \
  20. 20      chatserver.cpp \
  21. 21      main.cpp \
  22. 22      mainwindow.cpp \
  23. 23      remoteselector.cpp
  24. 24
  25. 25  HEADERS += \
  26. 26      chatclient.h \
  27. 27      chatserver.h \
  28. 28      mainwindow.h \
  29. 29      remoteselector.h
  30. 30
  31. 31  # Default rules for deployment.
  32. 32  qnx: target.path = /tmp/${TARGET}/bin
  33. 33  else: unix:!android: target.path = /opt/${TARGET}/bin
  34. 34  !isEmpty(target.path): INSTALLS += target
复制代码

项目简介：Qt蓝牙聊天。将蓝牙设置成一个服务器，或者用做客户端，连接手机即可通信。
例06_bluetooth_chat，Qt蓝牙聊天（难度：难）。项目路径为Qt/3/06_bluetooth_chat。
Qt使用蓝牙，需要在项目文件加上相应的蓝牙模块。添加的代码如下红色加粗部分。06_bluetooth_chat.pro文件代码如下。
  1. /******************************************************************
  2.     Copyright (C) 2015 The Qt Company Ltd.
  3.     Copyright © Deng Zhimao Co., Ltd. 1990-2021. All rights reserved.
  4.     * @projectName   06_bluetooth_chat
  5.     * @brief         chatclient.h
  6.     * [url=home.php?mod=space&uid=90321]@Author[/url]        Deng Zhimao
  7.     * [url=home.php?mod=space&uid=55957]@EMAIL[/url]         1252699831@qq.com
  8.     * [url=home.php?mod=space&uid=28414]@net[/url]            www.openedv.com
  9.     * @date           2021-03-20
  10.     *******************************************************************/
  11. 1   #ifndef CHATCLIENT_H
  12. 2   #define CHATCLIENT_H
  13. 3
  14. 4   #include <qbluetoothserviceinfo.h>
  15. 5   #include <QBluetoothSocket>
  16. 6   #include <QtCore/QObject>
  17. 7
  18. 8   QT_FORWARD_DECLARE_CLASS(QBluetoothSocket)
  19. 9
  20. 10  class ChatClient : public QObject
  21. 11  {
  22. 12      Q_OBJECT
  23. 13
  24. 14  public:
  25. 15      explicit ChatClient(QObject *parent = nullptr);
  26. 16      ~ChatClient();
  27. 17
  28. 18      /* 开启客户端 */
  29. 19      void startClient(const QBluetoothServiceInfo &remoteService);
  30. 20
  31. 21      /* 停止客户端 */
  32. 22      void stopClient();
  33. 23
  34. 24  public slots:
  35. 25      /* 发送消息 */
  36. 26      void sendMessage(const QString &message);
  37. 27
  38. 28      /* 主动断开连接 */
  39. 29      void disconnect();
  40. 30
  41. 31  signals:
  42. 32      /* 接收到消息信号 */
  43. 33      void messageReceived(const QString &sender, const QString &message);
  44. 34
  45. 35      /* 连接信号 */
  46. 36      void connected(const QString &name);
  47. 37
  48. 38      /* 断开连接信号 */
  49. 39      void disconnected();
  50. 40
  51. 41  private slots:
  52. 42      /* 从socket里读取消息 */
  53. 43      void readSocket();
  54. 44
  55. 45      /* 连接 */
  56. 46      void connected();
  57. 47
  58. 48  private:
  59. 49      /* socket通信 */
  60. 50      QBluetoothSocket *socket;
  61. 51  };
  62. 52
  63. 53  #endif // CHATCLIENT_H
复制代码
      chatclient.h文件主要是客户端的头文件，其中写一些接口，比如开启客户端，关闭客户端，接收信号与关闭信号等等。
      chatclient.cpp的代码如下。
  1. /******************************************************************
  2.     Copyright (C) 2015 The Qt Company Ltd.
  3.     Copyright &#169; Deng Zhimao Co., Ltd. 1990-2021. All rights reserved.
  4.     * @projectName   06_bluetooth_chat
  5.     * @brief         chatclient.cpp
  6.     * @author        Deng Zhimao
  7.     * @email         1252699831@qq.com
  8.     * @net            www.openedv.com
  9.     * @date           2021-03-20
  10.     *******************************************************************/

  12. 1   #include "chatclient.h"
  13. 2   #include <qbluetoothsocket.h>
  14. 3
  15. 4   ChatClient::ChatClient(QObject *parent)
  16. 5       :   QObject(parent), socket(0)
  17. 6   {
  18. 7   }
  19. 8
  20. 9   ChatClient::~ChatClient()
  21. 10  {
  22. 11      stopClient();
  23. 12  }
  24. 13
  25. 14  /* 开启客户端 */
  26. 15  void ChatClient::startClient(const QBluetoothServiceInfo &remoteService)
  27. 16  {
  28. 17      if (socket)
  29. 18          return;
  30. 19      
  31. 20      // Connect to service
  32. 21      socket = new QBluetoothSocket(QBluetoothServiceInfo::RfcommProtocol);
  33. 22      qDebug() << "Create socket";
  34. 23      socket->connectToService(remoteService);
  35. 24      qDebug() << "ConnectToService done";
  36. 25      
  37. 26      connect(socket, SIGNAL(readyRead()),
  38. 27              this, SLOT(readSocket()));
  39. 28      connect(socket, SIGNAL(connected()),
  40. 29              this, SLOT(connected()));
  41. 30      connect(socket, SIGNAL(disconnected()),
  42. 31              this, SIGNAL(disconnected()));
  43. 32  }
  44. 33
  45. 34  /* 停止客户端 */
  46. 35  void ChatClient::stopClient()
  47. 36  {
  48. 37      delete socket;
  49. 38      socket = 0;
  50. 39  }
  51. 40
  52. 41  /* 从Socket读取消息 */
  53. 42  void ChatClient::readSocket()
  54. 43  {
  55. 44      if (!socket)
  56. 45          return;
  57. 46      
  58. 47      while (socket->canReadLine()) {
  59. 48          QByteArray line = socket->readLine();
  60. 49          emit messageReceived(socket->peerName(),
  61. 50                               QString::fromUtf8(line.constData(),
  62. 51                                                 line.length()));
  63. 52      }
  64. 53  }
  65. 54
  66. 55  /* 发送的消息 */
  67. 56  void ChatClient::sendMessage(const QString &message)
  68. 57  {
  69. 58      qDebug()<<"Sending data in client: " + message;
  70. 59      
  71. 60      QByteArray text = message.toUtf8() + '\n';
  72. 61      socket->write(text);
  73. 62  }
  74. 63
  75. 64  /* 主动连接 */
  76. 65  void ChatClient::connected()
  77. 66  {
  78. 67      emit connected(socket->peerName());
  79. 68  }
  80. 69
  81. 70  /* 主动断开连接*/
  82. 71  void ChatClient::disconnect() {
  83. 72      qDebug()<<"Going to disconnect in client";
  84. 73      if (socket) {
  85. 74          qDebug()<<"diconnecting...";
  86. 75          socket->close();
  87. 76      }
  88. 77  }
复制代码
       chatclient.cpp文件主要是客户端的chatclient.h头文件的实现。代码参考Qt官方btchat例子，代码比较长，也有相应的注释了，大家自由查看。主要我们关注的是下面的代码。
       第15~32行，我们需要开启客户端模式，那么我们需要将扫描服务器（手机蓝牙）的结果，实例化一个蓝牙socket，使用socket连接传入来的服务器信息，即可将本地蓝牙当作客户端，实现了客户端创建。
       chatserver.h代码如下。
  1. /******************************************************************
  2.     Copyright (C) 2015 The Qt Company Ltd.
  3.     Copyright &#169; Deng Zhimao Co., Ltd. 1990-2021. All rights reserved.
  4.     * @projectName   06_bluetooth_chat
  5.     * @brief         chatserver.h
  6.     * @author        Deng Zhimao
  7.     * @email         1252699831@qq.com
  8.     * @net            www.openedv.com
  9.     * @date           2021-03-20
  10.     *******************************************************************/

  12. 1   #ifndef CHATSERVER_H
  13. 2   #define CHATSERVER_H
  14. 3
  15. 4   #include <qbluetoothserviceinfo.h>
  16. 5   #include <qbluetoothaddress.h>
  17. 6   #include <QtCore/QObject>
  18. 7   #include <QtCore/QList>
  19. 8   #include <QBluetoothServer>
  20. 9   #include <QBluetoothSocket>
  21. 10
  22. 11
  23. 12  class ChatServer : public QObject
  24. 13  {
  25. 14      Q_OBJECT
  26. 15
  27. 16  public:
  28. 17      explicit ChatServer(QObject *parent = nullptr);
  29. 18      ~ChatServer();
  30. 19
  31. 20      /* 开启服务端 */
  32. 21      void startServer(const QBluetoothAddress &localAdapter = QBluetoothAddress());
  33. 22
  34. 23      /* 停止服务端 */
  35. 24      void stopServer();
  36. 25
  37. 26  public slots:
  38. 27      /* 发送消息 */
  39. 28      void sendMessage(const QString &message);
  40. 29
  41. 30      /* 服务端主动断开连接 */
  42. 31      void disconnect();
  43. 32
  44. 33  signals:
  45. 34      /* 接收到消息信号 */
  46. 35      void messageReceived(const QString &sender, const QString &message);
  47. 36
  48. 37      /* 客户端连接信号 */
  49. 38      void clientConnected(const QString &name);
  50. 39
  51. 40      /* 客户端断开连接信号 */
  52. 41      void clientDisconnected(const QString &name);
  53. 42
  54. 43  private slots:
  55. 44
  56. 45      /* 客户端连接 */
  57. 46      void clientConnected();
  58. 47
  59. 48      /* 客户端断开连接 */
  60. 49      void clientDisconnected();
  61. 50
  62. 51      /* 读socket */
  63. 52      void readSocket();
  64. 53
  65. 54  private:
  66. 55      /* 使用rfcomm协议 */
  67. 56      QBluetoothServer *rfcommServer;
  68. 57
  69. 58      /* 服务器蓝牙信息 */
  70. 59      QBluetoothServiceInfo serviceInfo;
  71. 60
  72. 61      /* 用于保存客户端socket */
  73. 62      QList<QBluetoothSocket *> clientSockets;
  74. 63
  75. 64      /* 用于保存客户端的名字 */
  76. 65      QList<QString> socketsPeername;
  77. 66  };
  78. 67
  79. 68  #endif // CHATSERVER_H
复制代码
      chatserver.h文件主要是服务端的头文件，其中写一些接口，比如开启服务端，关闭服务端，接收信号与关闭信号等等。
chatserver.cpp代码如下。
  1. /******************************************************************
  2.     Copyright (C) 2015 The Qt Company Ltd.
  3.     Copyright &#169; Deng Zhimao Co., Ltd. 1990-2021. All rights reserved.
  4.     * @projectName   06_bluetooth_chat
  5.     * @brief         chatserver.cpp
  6.     * @author        Deng Zhimao
  7.     * @email         1252699831@qq.com
  8.     * @net            www.openedv.com
  9.     * @date           2021-03-20
  10.     *******************************************************************/

  12. 1   #include "chatserver.h"
  13. 2  
  14. 3   #include <qbluetoothserver.h>
  15. 4   #include <qbluetoothsocket.h>
  16. 5   #include <qbluetoothlocaldevice.h>
  17. 6  
  18. 7   static const QLatin1String serviceUuid("e8e10f95-1a70-4b27-9ccf-02010264e9c8");
  19. 8   ChatServer::ChatServer(QObject *parent)
  20. 9       :   QObject(parent), rfcommServer(0)
  21. 10  {
  22. 11  }
  23. 12
  24. 13  ChatServer::~ChatServer()
  25. 14  {
  26. 15      stopServer();
  27. 16  }
  28. 17
  29. 18  /* 开启服务端，设置服务端使用rfcomm协议与serviceInfo的一些属性 */
  30. 19  void ChatServer::startServer(const QBluetoothAddress& localAdapter)
  31. 20  {
  32. 21      if (rfcommServer)
  33. 22          return;
  34. 23
  35. 24      rfcommServer = new QBluetoothServer(QBluetoothServiceInfo::RfcommProtocol, this);
  36. 25      connect(rfcommServer, SIGNAL(newConnection()), this, SLOT(clientConnected()));
  37. 26      bool result = rfcommServer->listen(localAdapter);
  38. 27      if (!result) {
  39. 28          qWarning()<<"Cannot bind chat server to"<<localAdapter.toString();
  40. 29          return;
  41. 30      }
  42. 31
  43. 32      //serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceRecordHandle, (uint)0x00010010);
  44. 33
  45. 34      QBluetoothServiceInfo::Sequence classId;
  46. 35
  47. 36      classId<<QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::SerialPort));
  48. 37      serviceInfo.setAttribute(QBluetoothServiceInfo::BluetoothProfileDescriptorList,
  49. 38                               classId);
  50. 39
  51. 40      classId.prepend(QVariant::fromValue(QBluetoothUuid(serviceUuid)));
  52. 41
  53. 42      serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceClassIds, classId);
  54. 43      serviceInfo.setAttribute(QBluetoothServiceInfo::BluetoothProfileDescriptorList,classId);
  55. 44
  56. 45      serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceName, tr("Bt Chat Server"));
  57. 46      serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceDescription,
  58. 47                               tr("Example bluetooth chat server"));
  59. 48      serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceProvider, tr("qt-project.org"));
  60. 49
  61. 50      serviceInfo.setServiceUuid(QBluetoothUuid(serviceUuid));
  62. 51
  63. 52      QBluetoothServiceInfo::Sequence publicBrowse;
  64. 53      publicBrowse<< QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::PublicBrowseGroup));
  65. 54      serviceInfo.setAttribute(QBluetoothServiceInfo::BrowseGroupList,
  66. 55                               publicBrowse);
  67. 56
  68. 57      QBluetoothServiceInfo::Sequence protocolDescriptorList;
  69. 58      QBluetoothServiceInfo::Sequence protocol;
  70. 59      protocol<< QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::L2cap));
  71. 60      protocolDescriptorList.append(QVariant::fromValue(protocol));
  72. 61      protocol.clear();
  73. 62      protocol<< QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::Rfcomm))
  74. 63              << QVariant::fromValue(quint8(rfcommServer->serverPort()));
  75. 64      protocolDescriptorList.append(QVariant::fromValue(protocol));
  76. 65      serviceInfo.setAttribute(QBluetoothServiceInfo::ProtocolDescriptorList,
  77. 66                               protocolDescriptorList);
  78. 67
  79. 68      serviceInfo.registerService(localAdapter);
  80. 69  }
  81. 70
  82. 71  /* 停止服务端 */
  83. 72  void ChatServer::stopServer()
  84. 73  {
  85. 74      // Unregister service
  86. 75      serviceInfo.unregisterService();
  87. 76
  88. 77      // Close sockets
  89. 78      qDeleteAll(clientSockets);
  90. 79
  91. 80      // Close server
  92. 81      delete rfcommServer;
  93. 82      rfcommServer = 0;
  94. 83  }
  95. 84
  96. 85  /* 主动断开连接 */
  97. 86  void ChatServer::disconnect()
  98. 87  {
  99. 88      qDebug()<<"Going to disconnect in server";
  100. 89
  101. 90      foreach (QBluetoothSocket *socket, clientSockets) {
  102. 91          qDebug()<<"sending data in server!";
  103. 92          socket->close();
  104. 93      }
  105. 94  }
  106. 95
  107. 96  /* 发送消息 */
  108. 97  void ChatServer::sendMessage(const QString &message)
  109. 98  {
  110. 99      qDebug()<<"Going to send message in server: " << message;
  111. 100     QByteArray text = message.toUtf8() + '\n';
  112. 101
  113. 102     foreach (QBluetoothSocket *socket, clientSockets) {
  114. 103         qDebug()<<"sending data in server!";
  115. 104         socket->write(text);
  116. 105     }
  117. 106     qDebug()<<"server sending done!";
  118. 107 }
  119. 108
  120. 109 /* 客户端连接 */
  121. 110 void ChatServer::clientConnected()
  122. 111 {
  123. 112     qDebug()<<"clientConnected";
  124. 113
  125. 114     QBluetoothSocket *socket = rfcommServer->nextPendingConnection();
  126. 115     if (!socket)
  127. 116         return;
  128. 117
  129. 118     connect(socket, SIGNAL(readyRead()), this, SLOT(readSocket()));
  130. 119     connect(socket, SIGNAL(disconnected()), this, SLOT(clientDisconnected()));
  131. 120     clientSockets.append(socket);
  132. 121     socketsPeername.append(socket->peerName());
  133. 122     emit clientConnected(socket->peerName());
  134. 123 }
  135. 124
  136. 125 /* 客户端断开连接 */
  137. 126 void ChatServer::clientDisconnected()
  138. 127 {
  139. 128     QBluetoothSocket *socket = qobject_cast<QBluetoothSocket *>(sender());
  140. 129     if (!socket)
  141. 130         return;
  142. 131
  143. 132     if (clientSockets.count() != 0) {
  144. 133         QString peerName;
  145. 134
  146. 135         if (socket->peerName().isEmpty())
  147. 136             peerName = socketsPeername.at(clientSockets.indexOf(socket));
  148. 137         else
  149. 138             peerName = socket->peerName();
  150. 139
  151. 140         emit clientDisconnected(peerName);
  152. 141
  153. 142         clientSockets.removeOne(socket);
  154. 143         socketsPeername.removeOne(peerName);
  155. 144     }
  156. 145
  157. 146     socket->deleteLater();
  158. 147
  159. 148 }
  160. 149
  161. 150 /* 从Socket里读取数据 */
  162. 151 void ChatServer::readSocket()
  163. 152 {
  164. 153     QBluetoothSocket *socket = qobject_cast<QBluetoothSocket *>(sender());
  165. 154     if (!socket)
  166. 155         return;
  167. 156
  168. 157     while (socket->bytesAvailable()) {
  169. 158         QByteArray line = socket->readLine().trimmed();
  170. 159         qDebug()<<QString::fromUtf8(line.constData(), line.length())<<endl;
  171. 160         emit messageReceived(socket->peerName(),
  172. 161                              QString::fromUtf8(line.constData(), line.length()));
  173. 162         qDebug()<<QString::fromUtf8(line.constData(), line.length())<<endl;
  174. 163     }
  175. 164 }
复制代码
       chatserver.cpp文件主要是服务端的chatserver.h头文件的实现。代码也是参考Qt官方btchat例子，代码比较长，也有相应的注释了，大家自由查看。主要我们关注的是下面的代码。
       第19~69行，我们需要开启服务端模式，那么我们需要将本地的蓝牙localAdapter的地址传入，创建一个QBluetoothServer对象rfcommServer。在19至69行代码很长，其中使用了serviceInfo.setAttribute()设置了许多参数，这个流程是官方给出的流程，我们只需要了解下就可以了。大体流程：使用了QBluetoothServiceInfo类允许访问服务端蓝牙服务的属性，其中有设置蓝牙的UUID为文件开头定义的serviceUuid，设置serviceUuid的目的是为了区分其他蓝牙，用于搜索此类型蓝牙，但是作用并不是很大，因为我们的手机并不一定开启了这个uuid标识。最后必须用registerService()启动蓝牙。
第36行，转换串行端口（SerialPort），转换成classId，然后再设置串行端口服务。通信原理就是串行端口连接到RFCOMM server channel。（PS：蓝牙使用的协议多且复杂，本教程并不能清晰解释这种原理，如果有错误，欢迎指出）。
remoteselector.h代码如下。
  1. /******************************************************************
  2.     Copyright (C) 2015 The Qt Company Ltd.
  3.     Copyright &#169; Deng Zhimao Co., Ltd. 1990-2021. All rights reserved.
  4.     * @projectName   06_bluetooth_chat
  5.     * @brief         remoteselector.h
  6.     * @author        Deng Zhimao
  7.     * @email         1252699831@qq.com
  8.     * @net            www.openedv.com
  9.     * @date           2021-03-20
  10.     *******************************************************************/

  12. 1   #ifndef REMOTESELECTOR_H
  13. 2   #define REMOTESELECTOR_H
  14. 3
  15. 4   #include <qbluetoothuuid.h>
  16. 5   #include <qbluetoothserviceinfo.h>
  17. 6   #include <qbluetoothservicediscoveryagent.h>
  18. 7   #include <QListWidgetItem>
  19. 8
  20. 9   /* 声明一个蓝牙适配器类 */
  21. 10  class RemoteSelector : public QObject
  22. 11  {
  23. 12      Q_OBJECT
  24. 13
  25. 14  public:
  26. 15      explicit RemoteSelector(QBluetoothAddress&,
  27. 16                              QObject *parent = nullptr);
  28. 17      ~RemoteSelector();
  29. 18
  30. 19      /* 开启发现蓝牙 */
  31. 20      void startDiscovery(const QBluetoothUuid &uuid);
  32. 21
  33. 22      /* 停止发现蓝牙 */
  34. 23      void stopDiscovery();
  35. 24
  36. 25      /* 蓝牙服务 */
  37. 26      QBluetoothServiceInfo service() const;
  38. 27
  39. 28  signals:
  40. 29      /* 找到新服务 */
  41. 30      void newServiceFound(QListWidgetItem*);
  42. 31
  43. 32      /* 完成 */
  44. 33      void finished();
  45. 34
  46. 35  private:
  47. 36      /* 蓝牙服务代理，用于发现蓝牙服务 */
  48. 37      QBluetoothServiceDiscoveryAgent *m_discoveryAgent;
  49. 38
  50. 39      /* 服务信息 */
  51. 40      QBluetoothServiceInfo m_serviceInfo;
  52. 41
  53. 42  private slots:
  54. 43      /* 服务发现完成 */
  55. 44      void serviceDiscovered(const QBluetoothServiceInfo &serviceInfo);
  56. 45
  57. 46      /* 蓝牙发现完成 */
  58. 47      void discoveryFinished();
  59. 48
  60. 49  public:
  61. 50      /* 键值类容器 */
  62. 51      QMap<QString, QBluetoothServiceInfo> m_discoveredServices;
  63. 52  };
  64. 53
  65. 54  #endif // REMOTESELECTOR_H
  66. 55
复制代码
      remoteselector.h翻译成远程选择器，代码也是参考Qt官方btchat例子，这个头文件定义了开启蓝牙发现模式，蓝牙关闭发现模式，还有服务完成等等，代码有注释，请自由查看。
      remoteselector.cpp代码如下。
  1. /******************************************************************
  2.     Copyright (C) 2015 The Qt Company Ltd.
  3.     Copyright &#169; Deng Zhimao Co., Ltd. 1990-2021. All rights reserved.
  4.     * @projectName   06_bluetooth_chat
  5.     * @brief         remoteselector.cpp
  6.     * @author        Deng Zhimao
  7.     * @email         1252699831@qq.com
  8.     * @net            www.openedv.com
  9.     * @date           2021-03-20
  10.     *******************************************************************/
  11. 1   #include "remoteselector.h"
  12. 2
  13. 3   /* 初始化本地蓝牙 */
  14. 4   RemoteSelector::RemoteSelector(QBluetoothAddress &localAdapter, QObject *parent)
  15. 5       : QObject(parent)
  16. 6   {
  17. 7       m_discoveryAgent = new QBluetoothServiceDiscoveryAgent(localAdapter);
  18. 8
  19. 9       connect(m_discoveryAgent, SIGNAL(serviceDiscovered(QBluetoothServiceInfo)),
  20. 10              this, SLOT(serviceDiscovered(QBluetoothServiceInfo)));
  21. 11      connect(m_discoveryAgent, SIGNAL(finished()), this, SLOT(discoveryFinished()));
  22. 12      connect(m_discoveryAgent, SIGNAL(canceled()), this, SLOT(discoveryFinished()));
  23. 13  }
  24. 14
  25. 15  RemoteSelector::~RemoteSelector()
  26. 16  {
  27. 17      delete m_discoveryAgent;
  28. 18  }
  29. 19
  30. 20  /* 开启发现模式，这里无需设置过滤uuid，否则搜索不到手机
  31. 21   * uuid会过滤符合条件的uuid服务都会返回相应的蓝牙设备
  32. 22   */
  33. 23  void RemoteSelector::startDiscovery(const QBluetoothUuid &uuid)
  34. 24  {
  35. 25      Q_UNUSED(uuid);
  36. 26      qDebug()<<"startDiscovery";
  37. 27      if (m_discoveryAgent->isActive()) {
  38. 28          qDebug()<<"stop the searching first";
  39. 29          m_discoveryAgent->stop();
  40. 30      }
  41. 31
  42. 32      //m_discoveryAgent->setUuidFilter(uuid);
  43. 33      m_discoveryAgent->start(QBluetoothServiceDiscoveryAgent::FullDiscovery);
  44. 34  }
  45. 35
  46. 36  /* 停止发现 */
  47. 37  void RemoteSelector::stopDiscovery()
  48. 38  {
  49. 39      qDebug()<<"stopDiscovery";
  50. 40      if (m_discoveryAgent){
  51. 41          m_discoveryAgent->stop();
  52. 42      }
  53. 43  }
  54. 44
  55. 45  QBluetoothServiceInfo RemoteSelector::service() const
  56. 46  {
  57. 47      return m_serviceInfo;
  58. 48  }
  59. 49
  60. 50  /* 扫描蓝牙服务信息 */
  61. 51  void RemoteSelector::serviceDiscovered(const QBluetoothServiceInfo &serviceInfo)
  62. 52  {
  63. 53  #if 0
  64. 54      qDebug() << "Discovered service on"
  65. 55               << serviceInfo.device().name() << serviceInfo.device().address().toString();
  66. 56      qDebug() << "\tService name:" << serviceInfo.serviceName();
  67. 57      qDebug() << "\tDescription:"
  68. 58               << serviceInfo.attribute(QBluetoothServiceInfo::ServiceDescription).toString();
  69. 59      qDebug() << "\tProvider:"
  70. 60               << serviceInfo.attribute(QBluetoothServiceInfo::ServiceProvider).toString();
  71. 61      qDebug() << "\tL2CAP protocol service multiplexer:"
  72. 62               << serviceInfo.protocolServiceMultiplexer();
  73. 63      qDebug() << "\tRFCOMM server channel:" << serviceInfo.serverChannel();
  74. 64  #endif
  75. 65
  76. 66      QMapIterator<QString, QBluetoothServiceInfo> i(m_discoveredServices);
  77. 67      while (i.hasNext()){
  78. 68          i.next();
  79. 69          if (serviceInfo.device().address() == i.value().device().address()){
  80. 70              return;
  81. 71          }
  82. 72      }
  83. 73
  84. 74      QString remoteName;
  85. 75      if (serviceInfo.device().name().isEmpty())
  86. 76          remoteName = serviceInfo.device().address().toString();
  87. 77      else
  88. 78          remoteName = serviceInfo.device().name();
  89. 79
  90. 80      qDebug()<<"adding to the list....";
  91. 81      qDebug()<<"remoteName: "<< remoteName;
  92. 82      QListWidgetItem *item =
  93. 83              new QListWidgetItem(QString::fromLatin1("%1%2")
  94. 84                                  .arg(remoteName, serviceInfo.serviceName()));
  95. 85      m_discoveredServices.insert(remoteName, serviceInfo);
  96. 86      emit newServiceFound(item);
  97. 87  }
  98. 88
  99. 89  /* 发现完成 */
  100. 90  void RemoteSelector::discoveryFinished()
  101. 91  {
  102. 92      qDebug()<<"discoveryFinished";
  103. 93      emit finished();
  104. 94  }
复制代码
remoteselector .cpp是remoteselector.h的实现代码。主要看以下几点。
       第4~13行，初始化本地蓝牙，实例化对象discoveryAgent（代理对象），蓝牙主要通过本地代理对象去扫描其他蓝牙。
       第32行，这里官方Qt代码设计是过滤uuid。只有符合对应的uuid的蓝牙，才会返回结果。因为我们要扫描我们的手机，所以这里我们要把它注释掉。手机的uuid没有设置成设定的uuid，如果设置了uuid过滤，手机就扫描不出了。（uuid指的是唯一标识，手机蓝牙有很多uuid，不同的uuid有不同的作用，指示着不同的服务）。
       其他代码都是一些逻辑性的代码，比较简单，请自由查看。
mainwindow.h代码如下。
  1. /******************************************************************
  2.     Copyright &#169; Deng Zhimao Co., Ltd. 1990-2021. All rights reserved.
  3.     * @projectName   06_bluetooth_chat
  4.     * @brief         mainwindow.h
  5.     * @author        Deng Zhimao
  6.     * @email         1252699831@qq.com
  7.     * @net            www.openedv.com
  8.     * @date           2021-03-19
  9.     *******************************************************************/
  10. 1   #ifndef MAINWINDOW_H
  11. 2   #define MAINWINDOW_H
  12. 3  
  13. 4   #include <QMainWindow>
  14. 5   #include <qbluetoothserviceinfo.h>
  15. 6   #include <qbluetoothsocket.h>
  16. 7   #include <qbluetoothhostinfo.h>
  17. 8   #include <QDebug>
  18. 9   #include <QTabWidget>
  19. 10  #include <QHBoxLayout>
  20. 11  #include <QVBoxLayout>
  21. 12  #include <QPushButton>
  22. 13  #include <QListWidget>
  23. 14  #include <QTextBrowser>
  24. 15  #include <QLineEdit>
  25. 16
  26. 17  class ChatServer;
  27. 18  class ChatClient;
  28. 19  class RemoteSelector;
  29. 20
  30. 21  class MainWindow : public QMainWindow
  31. 22  {
  32. 23      Q_OBJECT
  33. 24
  34. 25  public:
  35. 26      MainWindow(QWidget *parent = nullptr);
  36. 27      ~MainWindow();
  37. 28
  38. 29  public:
  39. 30      /* 暴露的接口，主动连接设备*/
  40. 31      Q_INVOKABLE void connectToDevice();
  41. 32
  42. 33  signals:
  43. 34      /* 发送消息信号 */
  44. 35      void sendMessage(const QString &message);
  45. 36
  46. 37      /* 连接断开信号 */
  47. 38      void disconnect();
  48. 39
  49. 40      /* 发现完成信号 */
  50. 41      void discoveryFinished();
  51. 42
  52. 43      /* 找到新服务信号 */
  53. 44      void newServicesFound(const QStringList &list);
  54. 45
  55. 46  public slots:
  56. 47      /* 停止搜索 */
  57. 48      void searchForDevices();
  58. 49
  59. 50      /* 开始搜索 */
  60. 51      void stopSearch();
  61. 52
  62. 53      /* 找到新服务 */
  63. 54      void newServiceFound(QListWidgetItem*);
  64. 55
  65. 56      /* 已连接 */
  66. 57      void connected(const QString &name);
  67. 58
  68. 59      /* 显示消息 */
  69. 60      void showMessage(const QString &sender, const QString &message);
  70. 61
  71. 62      /* 发送消息 */
  72. 63      void sendMessage();
  73. 64
  74. 65      /* 作为客户端断开连接 */
  75. 66      void clientDisconnected();
  76. 67
  77. 68      /* 主动断开连接 */
  78. 69      void toDisconnected();
  79. 70
  80. 71      /* 作为服务端时，客户端断开连接 */
  81. 72      void disconnected(const QString &name);
  82. 73
  83. 74  private:
  84. 75      /* 选择本地蓝牙 */
  85. 76      int adapterFromUserSelection() const;
  86. 77
  87. 78      /* 本地蓝牙的Index */
  88. 79      int currentAdapterIndex;
  89. 80
  90. 81      /* 蓝牙本地适配器初始化 */
  91. 82      void localAdapterInit();
  92. 83
  93. 84      /* 布局初始化 */
  94. 85      void layoutInit();
  95. 86
  96. 87      /* 服务端*/
  97. 88      ChatServer *server;
  98. 89
  99. 90      /* 多个客户端 */
  100. 91      QList<ChatClient *> clients;
  101. 92
  102. 93      /* 远程选择器，使用本地蓝牙去搜索蓝牙，可过滤蓝牙等 */
  103. 94      RemoteSelector *remoteSelector;
  104. 95
  105. 96      /* 本地蓝牙 */
  106. 97      QList<QBluetoothHostInfo> localAdapters;
  107. 98
  108. 99      /* 本地蓝牙名称 */
  109. 100     QString localName;
  110. 101
  111. 102     /* tabWidget视图，用于切换页面 */
  112. 103     QTabWidget *tabWidget;
  113. 104
  114. 105     /* 3个按钮，扫描按钮，连接按钮，发送按钮 */
  115. 106     QPushButton *pushButton[5];
  116. 107
  117. 108     /* 2个垂直布局，一个用于页面一，另一个用于页面二 */
  118. 109     QVBoxLayout *vBoxLayout[2];
  119. 110
  120. 111     /* 2个水平布局，一个用于页面一，另一个用于页面二 */
  121. 112     QHBoxLayout *hBoxLayout[2];
  122. 113
  123. 114     /* 页面一和页面二容器 */
  124. 115     QWidget *pageWidget[2];
  125. 116
  126. 117     /* 用于布局, pageWidget包含subWidget */
  127. 118     QWidget *subWidget[2];
  128. 119
  129. 120     /* 蓝牙列表 */
  130. 121     QListWidget *listWidget;
  131. 122
  132. 123     /* 显示对话的内容 */
  133. 124     QTextBrowser *textBrowser;
  134. 125
  135. 126     /* 发送消息输入框 */
  136. 127     QLineEdit *lineEdit;
  137. 128
  138. 129 };
  139. 130 #endif // MAINWINDOW_H
复制代码
mainwindow.h是整个代码重要的文件，这里使用了客户端类，服务端类和远程服务端类。前面介绍的客户端类，服务端类和远程服务端类都是为mainwindow.h服务的。我们在编程的时候可以不用改动客户端类，服务端类和远程服务端类了，直接像mainwindow.h一样使用它们的接口就可以编程了。
       其中编者还在mainwindow.h使用了很多控件，这些控件都是界面组成的重要元素。并不复杂，如果看不懂界面布局，或者理解不了界面布局，请回到本教程的第七章学习基础，本教程不再一一说明这种简单的布局了。
mainwindow.cpp代码如下。
  1. /******************************************************************
  2.     Copyright &#169; Deng Zhimao Co., Ltd. 1990-2021. All rights reserved.
  3.     * @projectName   06_bluetooth_chat
  4.     * @brief         mainwindow.cpp
  5.     * @author        Deng Zhimao
  6.     * @email         1252699831@qq.com
  7.     * @net            www.openedv.com
  8.     * @date           2021-03-19
  9.     *******************************************************************/
  10. 1   #include "mainwindow.h"
  11. 2   #include "remoteselector.h"
  12. 3   #include "chatserver.h"
  13. 4   #include "chatclient.h"
  14. 5   #include <qbluetoothuuid.h>
  15. 6   #include <qbluetoothserver.h>
  16. 7   #include <qbluetoothservicediscoveryagent.h>
  17. 8   #include <qbluetoothdeviceinfo.h>
  18. 9   #include <qbluetoothlocaldevice.h>
  19. 10  #include <QGuiApplication>
  20. 11  #include <QScreen>
  21. 12  #include <QRect>
  22. 13  #include <QTimer>
  23. 14  #include <QDebug>
  24. 15  #include <QTabBar>
  25. 16  #include <QHeaderView>
  26. 17  #include <QTableView>
  27. 18
  28. 19
  29. 20  static const QLatin1String
  30. 21  serviceUuid("e8e10f95-1a70-4b27-9ccf-02010264e9c8");
  31. 22
  32. 23  MainWindow::MainWindow(QWidget *parent)
  33. 24      : QMainWindow(parent)
  34. 25  {
  35. 26      /* 本地蓝牙初始化 */
  36. 27      localAdapterInit();
  37. 28
  38. 29      /* 界面布局初始化 */
  39. 30      layoutInit();
  40. 31  }
  41. 32
  42. 33  MainWindow::~MainWindow()
  43. 34  {
  44. 35      qDeleteAll(clients);
  45. 36      delete server;
  46. 37  }
  47. 38
  48. 39  /* 初始化本地蓝牙，作为服务端 */
  49. 40  void MainWindow::localAdapterInit()
  50. 41  {
  51. 42      /* 查找本地蓝牙的个数 */
  52. 43      localAdapters = QBluetoothLocalDevice::allDevices();
  53. 44      qDebug() << "localAdapter: " << localAdapters.count();
  54. 45
  55. 46      QBluetoothLocalDevice localDevice;
  56. 47      localDevice.setHostMode(QBluetoothLocalDevice::HostDiscoverable);
  57. 48
  58. 49      QBluetoothAddress adapter = QBluetoothAddress();
  59. 50      remoteSelector = new RemoteSelector(adapter, this);
  60. 51      connect(remoteSelector,
  61. 52              SIGNAL(newServiceFound(QListWidgetItem*)),
  62. 53              this, SLOT(newServiceFound(QListWidgetItem*)));
  63. 54
  64. 55      /* 初始化服务端 */
  65. 56      server = new ChatServer(this);
  66. 57
  67. 58      connect(server, SIGNAL(clientConnected(QString)),
  68. 59              this, SLOT(connected(QString)));
  69. 60
  70. 61      connect(server, SIGNAL(clientDisconnected(QString)),
  71. 62              this, SLOT(disconnected(QString)));
  72. 63
  73. 64      connect(server, SIGNAL(messageReceived(QString, QString)),
  74. 65              this, SLOT(showMessage(QString, QString)));
  75. 66
  76. 67      connect(this, SIGNAL(sendMessage(QString)),
  77. 68              server, SLOT(sendMessage(QString)));
  78. 69
  79. 70      connect(this, SIGNAL(disconnect()),
  80. 71              server, SLOT(disconnect()));
  81. 72
  82. 73      server->startServer();
  83. 74
  84. 75      /* 获取本地蓝牙的名称 */
  85. 76      localName = QBluetoothLocalDevice().name();
  86. 77  }
  87. 78
  88. 79  void MainWindow::layoutInit()
  89. 80  {
  90. 81      /* 获取屏幕的分辨率，Qt官方建议使用这
  91. 82       * 种方法获取屏幕分辨率，防上多屏设备导致对应不上
  92. 83       * 注意，这是获取整个桌面系统的分辨率
  93. 84       */
  94. 85      QList <QScreen *> list_screen =  QGuiApplication::screens();
  95. 86
  96. 87      /* 如果是ARM平台，直接设置大小为屏幕的大小 */
  97. 88  #if __arm__
  98. 89      /* 重设大小 */
  99. 90      this->resize(list_screen.at(0)->geometry().width(),
  100. 91                   list_screen.at(0)->geometry().height());
  101. 92  #else
  102. 93      /* 否则则设置主窗体大小为800x480 */
  103. 94      this->resize(800, 480);
  104. 95  #endif
  105. 96
  106. 97      /* 主视图 */
  107. 98      tabWidget = new QTabWidget(this);
  108. 99
  109. 100     /* 设置主窗口居中视图为tabWidget */
  110. 101     setCentralWidget(tabWidget);
  111. 102
  112. 103     /* 页面一对象实例化 */
  113. 104     vBoxLayout[0] = new QVBoxLayout();
  114. 105     hBoxLayout[0] = new QHBoxLayout();
  115. 106     pageWidget[0] = new QWidget();
  116. 107     subWidget[0] = new QWidget();
  117. 108     listWidget = new QListWidget();
  118. 109     /* 0为扫描按钮，1为连接按钮 */
  119. 110     pushButton[0] = new QPushButton();
  120. 111     pushButton[1] = new QPushButton();
  121. 112     pushButton[2] = new QPushButton();
  122. 113     pushButton[3] = new QPushButton();
  123. 114     pushButton[4] = new QPushButton();
  124. 115
  125. 116     /* 页面二对象实例化 */
  126. 117     hBoxLayout[1] = new QHBoxLayout();
  127. 118     vBoxLayout[1] = new QVBoxLayout();
  128. 119     subWidget[1] = new QWidget();
  129. 120     textBrowser = new QTextBrowser();
  130. 121     lineEdit = new QLineEdit();
  131. 122     pushButton[2] = new QPushButton();
  132. 123     pageWidget[1] = new QWidget();
  133. 124
  134. 125
  135. 126     tabWidget->addTab(pageWidget[1], "蓝牙聊天");
  136. 127     tabWidget->addTab(pageWidget[0], "蓝牙列表");
  137. 128
  138. 129     /* 页面一 */
  139. 130     vBoxLayout[0]->addWidget(pushButton[0]);
  140. 131     vBoxLayout[0]->addWidget(pushButton[1]);
  141. 132     vBoxLayout[0]->addWidget(pushButton[2]);
  142. 133     vBoxLayout[0]->addWidget(pushButton[3]);
  143. 134     subWidget[0]->setLayout(vBoxLayout[0]);
  144. 135     hBoxLayout[0]->addWidget(listWidget);
  145. 136     hBoxLayout[0]->addWidget(subWidget[0]);
  146. 137     pageWidget[0]->setLayout(hBoxLayout[0]);
  147. 138     pushButton[0]->setMinimumSize(120, 40);
  148. 139     pushButton[1]->setMinimumSize(120, 40);
  149. 140     pushButton[2]->setMinimumSize(120, 40);
  150. 141     pushButton[3]->setMinimumSize(120, 40);
  151. 142     pushButton[0]->setText("开始扫描");
  152. 143     pushButton[1]->setText("停止扫描");
  153. 144     pushButton[2]->setText("连接");
  154. 145     pushButton[3]->setText("断开");
  155. 146
  156. 147     /* 页面二 */
  157. 148     hBoxLayout[1]->addWidget(lineEdit);
  158. 149     hBoxLayout[1]->addWidget(pushButton[4]);
  159. 150     subWidget[1]->setLayout(hBoxLayout[1]);
  160. 151     vBoxLayout[1]->addWidget(textBrowser);
  161. 152     vBoxLayout[1]->addWidget(subWidget[1]);
  162. 153     pageWidget[1]->setLayout(vBoxLayout[1]);
  163. 154     pushButton[4]->setMinimumSize(120, 40);
  164. 155     pushButton[4]->setText("发送");
  165. 156     lineEdit->setMinimumHeight(40);
  166. 157     lineEdit->setText("正点原子论坛网址www.openedv.com");
  167. 158
  168. 159     /* 设置表头的大小 */
  169. 160     QString str = tr("QTabBar::tab {height:40; width:%1};")
  170. 161             .arg(this->width()/2);
  171. 162     tabWidget->setStyleSheet(str);
  172. 163
  173. 164     /* 开始搜寻蓝牙 */
  174. 165     connect(pushButton[0], SIGNAL(clicked()),
  175. 166             this, SLOT(searchForDevices()));
  176. 167
  177. 168     /* 停止搜寻蓝牙 */
  178. 169     connect(pushButton[1], SIGNAL(clicked()),
  179. 170             this, SLOT(stopSearch()));
  180. 171
  181. 172     /* 点击连接按钮，本地蓝牙作为客户端去连接外界的服务端 */
  182. 173     connect(pushButton[2], SIGNAL(clicked()),
  183. 174             this, SLOT(connectToDevice()));
  184. 175
  185. 176     /* 点击断开连接按钮，断开连接 */
  186. 177     connect(pushButton[3], SIGNAL(clicked()),
  187. 178             this, SLOT(toDisconnected()));
  188. 179
  189. 180     /* 发送消息 */
  190. 181     connect(pushButton[4], SIGNAL(clicked()),
  191. 182             this, SLOT(sendMessage()));
  192. 183 }
  193. 184
  194. 185 /* 作为客户端去连接 */
  195. 186 void MainWindow::connectToDevice()
  196. 187 {
  197. 188     if (listWidget->currentRow() == -1)
  198. 189         return;
  199. 190
  200. 191     QString name = listWidget->currentItem()->text();
  201. 192     qDebug() << "Connecting to " << name;
  202. 193
  203. 194     // Trying to get the service
  204. 195     QBluetoothServiceInfo service;
  205. 196     QMapIterator<QString,QBluetoothServiceInfo>
  206. 197             i(remoteSelector->m_discoveredServices);
  207. 198     bool found = false;
  208. 199     while (i.hasNext()){
  209. 200         i.next();
  210. 201
  211. 202         QString key = i.key();
  212. 203
  213. 204         /* 判断连接的蓝牙名称是否在发现的设备里 */
  214. 205         if (key == name) {
  215. 206             qDebug() << "The device is found";
  216. 207             service = i.value();
  217. 208             qDebug() << "value: " << i.value().device().address();
  218. 209             found = true;
  219. 210             break;
  220. 211         }
  221. 212     }
  222. 213
  223. 214     /* 如果找到，则连接设备 */
  224. 215     if (found) {
  225. 216         qDebug() << "Going to create client";
  226. 217         ChatClient *client = new ChatClient(this);
  227. 218         qDebug() << "Connecting...";
  228. 219
  229. 220         connect(client, SIGNAL(messageReceived(QString,QString)),
  230. 221                 this, SLOT(showMessage(QString,QString)));
  231. 222         connect(client, SIGNAL(disconnected()),
  232. 223                 this, SLOT(clientDisconnected()));;
  233. 224         connect(client, SIGNAL(connected(QString)),
  234. 225                 this, SLOT(connected(QString)));
  235. 226         connect(this, SIGNAL(sendMessage(QString)),
  236. 227                 client, SLOT(sendMessage(QString)));
  237. 228         connect(this, SIGNAL(disconnect()),
  238. 229                 client, SLOT(disconnect()));
  239. 230
  240. 231         qDebug() << "Start client";
  241. 232         client->startClient(service);
  242. 233
  243. 234         clients.append(client);
  244. 235     }
  245. 236 }
  246. 237
  247. 238 /* 本地蓝牙选择，默认使用第一个蓝牙 */
  248. 239 int MainWindow::adapterFromUserSelection() const
  249. 240 {
  250. 241     int result = 0;
  251. 242     QBluetoothAddress newAdapter = localAdapters.at(0).address();
  252. 243     return result;
  253. 244 }
  254. 245
  255. 246 /* 开始搜索 */
  256. 247 void MainWindow::searchForDevices()
  257. 248 {
  258. 249     /* 先清空 */
  259. 250     listWidget->clear();
  260. 251     qDebug() << "search for devices!";
  261. 252     if (remoteSelector) {
  262. 253         delete remoteSelector;
  263. 254         remoteSelector = NULL;
  264. 255     }
  265. 256
  266. 257     QBluetoothAddress adapter = QBluetoothAddress();
  267. 258     remoteSelector = new RemoteSelector(adapter, this);
  268. 259
  269. 260     connect(remoteSelector,
  270. 261             SIGNAL(newServiceFound(QListWidgetItem*)),
  271. 262             this, SLOT(newServiceFound(QListWidgetItem*)));
  272. 263
  273. 264     remoteSelector->m_discoveredServices.clear();
  274. 265     remoteSelector->startDiscovery(QBluetoothUuid(serviceUuid));
  275. 266     connect(remoteSelector, SIGNAL(finished()),
  276. 267             this, SIGNAL(discoveryFinished()));
  277. 268 }
  278. 269
  279. 270 /* 停止搜索 */
  280. 271 void MainWindow::stopSearch()
  281. 272 {
  282. 273     qDebug() << "Going to stop discovery...";
  283. 274     if (remoteSelector) {
  284. 275         remoteSelector->stopDiscovery();
  285. 276     }
  286. 277 }
  287. 278
  288. 279 /* 找到蓝牙服务 */
  289. 280 void MainWindow::newServiceFound(QListWidgetItem *item)
  290. 281 {
  291. 282     /* 设置项的大小 */
  292. 283     item->setSizeHint(QSize(listWidget->width(), 50));
  293. 284
  294. 285     /* 添加项 */
  295. 286     listWidget->addItem(item);
  296. 287
  297. 288     /* 设置当前项 */
  298. 289     listWidget->setCurrentRow(listWidget->count() - 1);
  299. 290
  300. 291     qDebug() << "newServiceFound";
  301. 292
  302. 293     // get all of the found devices
  303. 294     QStringList list;
  304. 295
  305. 296     QMapIterator<QString, QBluetoothServiceInfo>
  306. 297             i(remoteSelector->m_discoveredServices);
  307. 298     while (i.hasNext()){
  308. 299         i.next();
  309. 300         qDebug() << "key: " << i.key();
  310. 301         qDebug() << "value: " << i.value().device().address();
  311. 302         list << i.key();
  312. 303     }
  313. 304
  314. 305     qDebug() << "list count: "  << list.count();
  315. 306
  316. 307     emit newServicesFound(list);
  317. 308 }
  318. 309
  319. 310 /* 已经连接 */
  320. 311 void MainWindow::connected(const QString &name)
  321. 312 {
  322. 313     textBrowser->insertPlainText(tr("%1:已连接\n").arg(name));
  323. 314     tabWidget->setCurrentIndex(0);
  324. 315     textBrowser->moveCursor(QTextCursor::End);
  325. 316 }
  326. 317
  327. 318 /* 接收消息 */
  328. 319 void MainWindow::showMessage(const QString &sender,
  329. 320                              const QString &message)
  330. 321 {
  331. 322     textBrowser->insertPlainText(QString::fromLatin1("%1: %2\n")
  332. 323                                  .arg(sender, message));
  333. 324     tabWidget->setCurrentIndex(0);
  334. 325     textBrowser->moveCursor(QTextCursor::End);
  335. 326 }
  336. 327
  337. 328 /* 发送消息 */
  338. 329 void MainWindow::sendMessage()
  339. 330 {
  340. 331     showMessage(localName, lineEdit->text());
  341. 332     emit sendMessage(lineEdit->text());
  342. 333 }
  343. 334
  344. 335 /* 作为客户端断开连接 */
  345. 336 void MainWindow::clientDisconnected()
  346. 337 {
  347. 338     ChatClient *client = qobject_cast<ChatClient *>(sender());
  348. 339     if (client) {
  349. 340         clients.removeOne(client);
  350. 341         client->deleteLater();
  351. 342     }
  352. 343
  353. 344     tabWidget->setCurrentIndex(0);
  354. 345     textBrowser->moveCursor(QTextCursor::End);
  355. 346 }
  356. 347
  357. 348 /* 主动断开连接 */
  358. 349 void MainWindow::toDisconnected()
  359. 350 {
  360. 351     emit disconnect();
  361. 352     textBrowser->moveCursor(QTextCursor::End);
  362. 353     tabWidget->setCurrentIndex(0);
  363. 354 }
  364. 355
  365. 356 /* 作为服务端时，客户端断开连接 */
  366. 357 void MainWindow::disconnected(const QString &name)
  367. 358 {
  368. 359     textBrowser->insertPlainText(tr("%1:已断开\n").arg(name));
  369. 360     tabWidget->setCurrentIndex(0);
  370. 361     textBrowser->moveCursor(QTextCursor::End);
  371. 362 }
复制代码
mainwindow.cpp则是整个项目的核心文件，包括处理界面点击的事件，客户端连接，服务端连接，扫描蓝牙，断开蓝牙和连接蓝牙等。设计这样的一个逻辑界面并不难，只要我们前面第七章Qt控件打下了基础。上面的代码注释详细，请自由查看。

20.3 程序运行效果
本例程运行后，默认开启蓝牙的服务端模式，可以用手机安装蓝牙调试软件（安卓手机如蓝牙调试宝、蓝牙串口助手）。当我们点击蓝牙列表页面时，点击扫描后请等待扫描的结果，选中需要连接的蓝牙再点击连接。
下面程序效果是Ubuntu虚拟机上连接USB蓝牙模块，用手机连接后运行的蓝牙聊天第一页效果图。
image002.jpg
下面程序效果是Ubuntu虚拟机上连接USB蓝牙模块运行的蓝牙聊天第二页效果图。
image004.jpg
   安卓手机可以用蓝牙调试宝等软件进行配对连接。IOS手机请下载某些蓝牙调试软件测试即可。手机接收到的消息如下。
image006.jpg
  在编者测试的过程中，发现在Ubuntu上运行蓝牙聊天程序不太好用，需要开启扫描后，才能连接得上，而且接收的消息反应比较慢，有可能是虚拟机的原因吧。不过在正点原子I.MX6U开发板上运行没有问题。先按照详细请看【正点原子】I.MX6U用户快速体验V1.x.pdf的第3.29小节蓝牙测试开启蓝牙，启用蓝牙被扫描后，先进行配对，手机用蓝牙调试软件就可以连接上进行聊天了。
     注意：本程序需要在确保蓝牙能正常使用的情况下才能运行，默认使用第一个蓝牙，如果Ubuntu上查看有两个蓝牙，请不要插着USB蓝牙启动电脑，先等Ubuntu启动后再插蓝牙模块。连接前应先配对，连接不上的原因可能或者蓝牙质量问题，或者系统里的软件没有开启蓝牙，或者使用的手机蓝牙调试软件不支持SPP（串行端口）蓝牙调试等，请退出重试等。程序仅供学习与参考。


【正点原子Linux】

相关帖子

正点原子逻辑分析仪DL16劲爆上市
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则



关闭

原子哥极力推荐上一条 /2 下一条

正点原子公众号

QQ|手机版|OpenEdv-开源电子网 ( 粤ICP备12000418号-1 )

GMT+8, 2024-11-22 08:52

Powered by OpenEdv-开源电子网

© 2001-2030 OpenEdv-开源电子网

快速回复 返回顶部 返回列表