由于项目的需要的Android与蓝牙模块通信，发了时间学习了下，实现了Android的与蓝牙模块的通信

1.蓝牙串口模块使用SPP-CA模块

蓝牙串口模块就是使用单片机的TX，RX与蓝牙模块通信，单片机通过TX发送数据给蓝牙模块，然后蓝牙模块在通过蓝牙协议把数据发送出去，蓝牙模块与Android的通信方式使用spp协议。

2.蓝牙通信

蓝牙的通信需要服务端和客户端，客户端搜索蓝牙设备，链接服务端。主要是通过插座通信，相关的知识可以学习了解下插座通信。链接建立起来，通信时数据的读写是通过输入输出流的方式读写。

3.Android蓝牙架构和API的说明

查看“机器人系统原理及开发要点详解”和“深入理解的Android网络编程”里的蓝牙相关章节，2本书里相关的章节有详细的介绍。

4.uuid

提示：如果要连接到蓝牙串行板，请尝试使用着名的SPP UUID 00001101-0000-1000-8000-00805F9B34FB。但是如果您连接到Android对等体，那么请生成您自己的唯一UUID。

这是Android官方文档的说明，如果是连接蓝牙串口模块使用通用的uuid 00001101-0000-1000-8000-00805F9B34FB，如果是Android手机间的通信链接，可以使用生成的uuid，客服端和服务端的uuid必须相同，下面通过蓝牙串口助手读取回来的UUID，下面是我的蓝牙串口模块的UUID。

Android与蓝牙串口模块通信_第1张图片

下面是读取手机的蓝牙的UUID，可以看到比较多的UUID，有比较多的服务。

Android与蓝牙串口模块通信_第2张图片

另外下面是其他蓝牙设备的UUID，应该是蓝牙4.0的。

Android与蓝牙串口模块通信_第3张图片

代码部分还是比较简单的，下面是Android的蓝牙链接的主要部分代码，也是参考网上的。

包gjz.bluetooth;

导入gjz.bluetooth.R;
导入gjz.bluetooth.Bluetooth.ServerOrCilent;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.UUID;
导入android.app.Activity;
导入android.bluetooth.BluetoothAdapter;
导入android.bluetooth.BluetoothDevice;
导入android.bluetooth.BluetoothServerSocket;
导入android.bluetooth.BluetoothSocket;
导入android.content.Context;
导入android.os.Bundle;
导入android.os.Handler;
导入android.os.Message;
导入android.util.Log;
导入android.view.View;
导入android.view.View.OnClickListener;
import android.view.inputmethod.InputMethodManager;
导入android.widget.AdapterView;
导入android.widget.Button;
导入android.widget.EditText;
导入android.widget.ListView;
导入android.widget.Toast;
导入android.widget.AdapterView.OnItemClickListener;

public class chatActivity extends Activity implements OnItemClickListener，OnClickListener {
    / **当活动首次创建时调用。* /
 
 private ListView mListView;
 private ArrayList 列表;
 私人按钮sendButton;
 私人按钮disconnectButton;
 私人EditText editMsgView;
 deviceListAdapter mAdapter;
 上下文mContext;
 
 / *一些常量，代表服务器的名称* /
 public static final String PROTOCOL_SCHEME_L2CAP =“btl2cap”;
 public static final String PROTOCOL_SCHEME_RFCOMM =“btspp”;
 public static final String PROTOCOL_SCHEME_BT_OBEX =“btgoep”;
 public static final String PROTOCOL_SCHEME_TCP_OBEX =“tcpobex”;
 
 private BluetoothServerSocket mserverSocket = null;
 private ServerThread startServerThread = null;
 private clientThread clientConnectThread = null;
 private BluetoothSocket socket = null;
 private BluetoothDevice device = null;
 private readThread mreadThread = null ;; 
 private BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter（）;
 
    @Override
    public void onCreate（Bundle savedInstanceState）{
        super.onCreate（savedInstanceState）;
        的setContentView（R.layout.chat）;
        mContext = this
        在里面（）;
    }
   
 private void init（）{    
  list = new ArrayList （）;
  mAdapter = new deviceListAdapter（this，list）;
  mListView =（ListView）findViewById（R.id.list）;
  mListView.setAdapter（mAdapter）;
  mListView.setOnItemClickListener（本）;
  mListView.setFastScrollEnabled（真）;
  editMsgView =（EditText）findViewById（R.id.MessageText）; 
  editMsgView.clearFocus（）;
  
  sendButton =（Button）findViewById（R.id.btn_msg_send）;
  sendButton.setOnClickListener（new OnClickListener（）{
   @ Override
   public void onClick（View arg0）{
    // TODO自动生成的方法存根
    String msgText = editMsgView.getText（）。toString（）;
    if（msgText.length（）> 0） {
     sendMessageHandle（msgText）; 
     editMsgView.setText（“”）;
     editMsgView.clearFocus（）;
     //关闭InputMethodManager
     InputMethodManager imm =（InputMethodManager）getSystemService（Context.INPUT_METHOD_SERVICE）;
     imm.hideSoftInputFromWindow（editMsgView.getWindowToken（），0）;
    } else
    Toast.makeText（mContext，“发送内容不能为空！”，Toast.LENGTH_SHORT）.show（）;
   }
  }）;
  
  disconnectButton =（Button）findViewById（R.id.btn_disconnect）;
  disconnectButton.setOnClickListener（new OnClickListener（）{
   @ Override
   public void onClick（View arg0）{
    // TODO自动生成的方法存根
          if（Bluetooth.serviceOrCilent == ServerOrCilent.CILENT）
    {
           shutdownClient（）;
    }
    else if（Bluetooth.serviceOrCilent == ServerOrCilent.SERVICE）
    {
     shutdownServer（）;
    }
    Bluetooth.isOpen = false;
    Bluetooth.serviceOrCilent = ServerOrCilent.NONE;
    Toast.makeText（mContext，“已断开连接！”，Toast.LENGTH_SHORT）.show（）;
   }
  }）;  
 }   

    private Handler LinkDetectedHandler = new Handler（）{
        @
        Override public void handleMessage（Message msg）{
         //Toast.makeText(mContext，（String）msg.obj，Toast.LENGTH_SHORT）.show（）;
         if（msg.what == 1）
         {
          list.add（new deviceListItem（（String）msg.obj，true））;
         }
         else
         {
          list.add（new deviceListItem（（String）msg.obj，false））;
         }
   mAdapter.notifyDataSetChanged（）;
   mListView.setSelection（list.size（） - 1）;
        }
       
    };   
   
    @Override
    public synchronized void onPause（）{
        super.onPause（）;
    }
    @Override
    public synchronized void onResume（）{
        super.onResume（）;
        if（Bluetooth.isOpen）
        {
         Toast.makeText（mContext，“连接已经打开，可以通信，如果要再建立连接，请先断开！”，Toast.LENGTH_SHORT）.show（）;
         返回;
        }
        if（Bluetooth.serviceOrCilent == ServerOrCilent.CILENT）
        {
   String address = Bluetooth.BlueToothAddress;
   if（！address.equals（“null”））
   {
    device = mBluetoothAdapter.getRemoteDevice（address）; 
    clientConnectThread = new clientThread（）;
    clientConnectThread.start（）;
    Bluetooth.isOpen = true;
   }
   else
   {
    Toast.makeText（mContext，“address is null！”，Toast.LENGTH_SHORT）.show（）;
   }
        }
        else if（Bluetooth.serviceOrCilent == ServerOrCilent.SERVICE）
        {                
         startServerThread = new ServerThread（）;
         startServerThread.start（）;
         Bluetooth.isOpen = true;
        }
    }
 //开启客户端
 私有类clientThread extends Thread {   
  public void run（）{
   try {
    //创建一个Socket连接：只需要服务器在注册时的UUID号
    // socket = device.createRfcommSocketToServiceRecord（BluetoothProtocols.OBEX_OBJECT_PUSH_PROTOCOL_UUID）;
    socket = device.createRfcommSocketToServiceRecord（UUID.fromString（“00001101-0000-1000-8000-00805F9B34FB”））;
    //连接
    消息msg2 = new Message（）;
    msg2.obj =“请稍候，正在连接服务器：”+ Bluetooth.BlueToothAddress;
    msg2.what = 0;
    LinkDetectedHandler.sendMessage（MSG2）;
    
    socket.connect（）;
    
    消息msg = new Message（）;
    msg.obj =“已经连接上服务端！可以发送信息”。
    msg.what = 0;
    LinkDetectedHandler.sendMessage（MSG）;
    //启动接受数据
    mreadThread = new readThread（）;
    mreadThread.start（）;
   }
   catch（IOException e）
   {
    Log.e（“connect”，“”，e）;
    消息msg = new Message（）;
    msg.obj =“连接服务端异常！断开连接重新试一试”。
    msg.what = 0;
    LinkDetectedHandler.sendMessage（MSG）;
   }
  }
 };

 //开启服务器
 私有类ServerThread extends Thread {
  public void run（）{
     
   try {
    / *创建一个蓝牙服务器
     *参数分别：服务器名称，UUID * / 
    mserverSocket = mBluetoothAdapter.listenUsingRfcommWithServiceRecord（PROTOCOL_SCHEME_RFCOMM，
      UUID.fromString（“00001101-0000 -1000-8000-00805F9B34FB“））;  
    
    Log.d（“server”，“wait cilent connect ...”）;
    
    消息msg = new Message（）;
    msg.obj =“请稍候，正在等待客户端的连接...”;
    msg.what = 0;
    LinkDetectedHandler.sendMessage（MSG）;
    
    / *接受客户端的连接请求* /
    socket = mserverSocket.accept（）;
    Log.d（“server”，“accept success！”）;
    
    消息msg2 = new Message（）;
    String info =“客户端已经连接上！可以发送信息”。
    msg2.obj = info;
    msg.what = 0;
    LinkDetectedHandler.sendMessage（MSG2）;
    //启动接受数据
    mreadThread = new readThread（）;
    mreadThread.start（）;
   } catch（IOException e）{
    // TODO自动生成的catch块
    e.printStackTrace（）;
   }
  }
 };
 / *停止服务器* /
 private void shutdownServer（）{
  new Thread（）{
   public void run（）{
    if（startServerThread！= null）
    {
     startServerThread.interrupt（）;
     startServerThread = null;
    }
    if（mreadThread！= null）
    {
     mreadThread.interrupt（）;
     mreadThread = null;
    }    
    try {     
     if（socket！= null）
     {
      socket.close（）;
      socket = null;
     }
     if（mserverSocket！= null）
     {
      mserverSocket.close（）; / *关闭服务器* /
      mserverSocket = null;
     }
    } catch（IOException e）{
     Log.e（“server”，“mserverSocket.close（）”，e）;
    }
   };
  }。开始（）;
 }
 / *停止客户端连接* /
 private void shutdownClient（）{
  new Thread（）{
   public void run（）{
    if（clientConnectThread！= null）
    {
     clientConnectThread.interrupt（）;
     clientConnectThread = null;
    }
    if（mreadThread！= null）
    {
     mreadThread.interrupt（）;
     mreadThread = null;
    }
    if（socket！= null）{
     try {
      socket.close（）;
     } catch（IOException e）{
      // TODO自动生成的catch块
      e.printStackTrace（）;
     }
     socket = null;
    }
   };
  }。开始（）;
 }
 //发送数据
 private void sendMessageHandle（String msg）
 {  
  if（socket == null）
  {
   Toast.makeText（mContext，“没有连接”，Toast.LENGTH_SHORT）.show（）;
   返回;
  }
  try {    
   OutputStream os = socket.getOutputStream（）;
   os.write（msg.getBytes（））;
  } catch（IOException e）{
   // TODO自动生成的catch块
   e.printStackTrace（）;
  }   
  list.add（new deviceListItem（msg，false））;
  mAdapter.notifyDataSetChanged（）;
  mListView.setSelection（list.size（） - 1）;
 }
 //读取数据
    private class readThread extends Thread {
        public void run（）{
         
            byte [] buffer = new byte [1024];
            int字节;
            InputStream mmInStream = null;
           
   尝试{
    mmInStream = socket.getInputStream（）;
   } catch（IOException e1）{
    // TODO自动生成的catch块
    e1.printStackTrace（）;
   } 
            while（true）{
                try {
                    //从InputStream读取
                    if（（bytes = mmInStream.read（buffer））> 0）
                    {
                     byte [] buf_data = new byte [bytes];
         for（int i = 0; i          {
          buf_data [i] = buffer [i];
         }
      的String =新字符串（buf_data）;
      消息msg = new Message（）;
      msg.obj = s;
      msg.what = 1;
      LinkDetectedHandler.sendMessage（MSG）;
                    }
                } catch（IOException e）{
                 try {
      mmInStream.close（）;
     } catch（IOException e1）{
      // TODO自动生成的catch块
      e1.printStackTrace（）;
     }
                    休息
                }
            }
        }
    }
    @Override
    protected void onDestroy（）{
        super.onDestroy（）;

        if（Bluetooth.serviceOrCilent == ServerOrCilent.CILENT）
  {
         shutdownClient（）;
  }
  else if（Bluetooth.serviceOrCilent == ServerOrCilent.SERVICE）
  {
   shutdownServer（）;
  }
        Bluetooth.isOpen = false;
  Bluetooth.serviceOrCilent = ServerOrCilent.NONE;
    }
 public class SiriListItem {
  String message;
  boolean isSiri;

  public SiriListItem（String msg，boolean siri）{
   message = msg;
   isSiri = siri
  }
 }
 @覆盖
 公共无效onItemClick（适配器视图<？>为arg0，查看ARG1，INT ARG2，长ARG3）{
  // TODO自动生成方法存根
 }
 @覆盖
 公共无效的onClick（查看为arg0）{
  // TODO自动生成方法stub
 } 
 public class deviceListItem {
  String message;
  boolean isSiri;

  public deviceListItem（String msg，boolean siri）{
   message = msg;
   isSiri = siri
  }
 }
}

下面是实现的效果。

1.Android手机通信

一台手机作为服务端，等待客服端链接。

Android与蓝牙串口模块通信_第4张图片

另一台手机作为客户端，链接服务端，链接成功，发送数据

Android与蓝牙串口模块通信_第5张图片

2.Android和蓝牙模块的通信

蓝牙模块作为服务器端，安卓手机作为客户端，链接蓝牙模块。

Android与蓝牙串口模块通信_第6张图片

蓝牙模块通过串口线链接PC，通过串口工具接收Android手机端发送数据，Android手机端链接成功信息连接<< A0：E4：53：18：BB：42 CONNETED，链接成功发送信息hellokitty mina123456789，Android链接断开信息DISC：SUCCESS + READY + PAIRABLE

Android与蓝牙串口模块通信_第7张图片 

看到不少朋友需要源码：找了电脑上源码

下面是源码下载地址：

http://download.csdn.net/detail/cwcwj3069/9876795



更多相关文章

  1. Android 关于AIDL通信，RemoteCallbackList实现Server回调Client
  2. Android之实用库xUtils四大模块以及用ViewInject代替findViewByI
  3. 【android 蓝牙开发——BLE（低功耗）蓝牙】
  4. 开启本地服务器，利用二维码进行通信[Demo]
  5. Android下的串口通信实战之控制客显
  6. 关于蓝牙设备之间共享网络的问题（android4.2）
  7. 阿里Android开发规范：进程、线程与消息通信
  8. Android netd和Framework以及netd和kernel之间的通信

随机推荐

  1. WIMM Labs 1.4 英寸可佩戴 Android(安卓)
  2. KISS Android(安卓)Library - Android库
  3. Android日志:Google官方下拉刷新控件
  4. Android手机终端长连接心跳检测自动化测
  5. Android判断设备网络连接状态及判断连接
  6. Android(安卓)Arcore 简单的实现人脸增强
  7. Growth发布iOS版 — 距今为止最好的开源
  8. 这是一份非常适合收藏的Android进阶/面试
  9. Android中的线性布局详解
  10. Android(安卓)自动化测试工具初探