蓝牙模块和单片机

2018-07-16 14:34:30 weixin_42133183 阅读数 19061

技术小白,感谢大家阅读和点赞!使用蓝牙模块也有段时间了,更新……

 

现在市面上用的蓝牙芯片大部分是ble的了,也就是低功耗透传模式。最近用到蓝牙SOC(片上系统),和大家分享下。

我们平时用蓝牙,一般是单片机的串口与蓝牙的串口连接,实现数据传输,同时,也会用到mcu的其他一些功能,比如IIC,比如定时器,ADC等。但对于一些功能相对较少的产品,或者要求小体积的产品,这时候可以考虑把mcu省略掉,通过蓝牙直接实现需求,这就是soc。

目前市面上用的比较多的soc包括TI的CC2640, Nordic的nRF52832和nRF52840,高通的CSR102x,各个品牌的功能和价格都大同小异,开发环境稍有不同,一般能满足可穿戴、物联产品的需求,博主最近在使用CSR102X,  使用后分享经验哈!

 

以下帖子为原内容

第一次用蓝牙通讯,现在市场上很多蓝牙模块功能都很强大,如果只是使用,不需要过多了解内部结构原理,只需要设置一些自己用到的参数就行了。

蓝牙分为传统蓝牙和ble蓝牙,现在大部分用到的都是ble低功耗蓝牙。蓝牙分主从模式,主模式是主动连接其它蓝牙设备,作为主模式可同时连接7个从设备,作为从设备只能被一个主设备连接。

使用蓝牙模块时,看模块支持哪种电平,有的可以直接接单片机的串口(TTL电平),有的需要经过232芯片连接。选定串口,设置好波特率,写好通讯协议,就可以通讯了。

以上都是很简单的内容,这里需要跟大家分享的惨痛的教训是关于串口和单片机的隔离。

我采购的SKY369可以直接连在单片机串口上,而且也可以3.3v供电。所以在设计电路时,我直接把蓝牙模块与单片机的某个串口接在一起,同时从模块引出四个排针,分别是vcc、gnd、rx、tx,注意,此时蓝牙模块已经焊在板子上了,按道理,在电路板不供电的情况下,我用usb转ttl线接四个排针,是可以进行AT指令设置的。但是,此处却出现了很多问题,很多问题!

问题如下图,我用的是友善串口助手,串口设置好了(可以在电脑计算机右键——设备管理——端口处查询自己用的串口号),蓝牙模块都有初始波特率,可以参考蓝牙模块的手册,数据位校验位停止位也是参考手册。发送和接收都是ASCII,然后点击发送,没反应,再点击,还是没反应。

排查串口波特率、排查串口线电压、排查tx、rx接没接反,最后发现都没问题,总不可能是蓝牙坏了吧,事实证明现在的模块都很稳定,一般不会出现质量问题,芯片坏了的情况基本不要考虑。

而且,这个现象并不是每次都出现,而且蓝牙的通讯功能完好,只是设置出问题。同时,这个问题不是每次都会出现,有时候发送AT指令,有的可以实现,有的就会出现00 00 00 00……

这个现象据蓝牙模块厂家说,是供电问题,换了好几个串口工具和线,确认不是此处的原因。

经历了蓝牙模块返厂等一系列,发现,单片机和蓝牙模块之间在设置模式下,最好不要直接连接,拿一块板子做测试,把单片机与模块间的线割掉,就再也没出现发送数据没反应的现象了。

串口连接蓝牙模块时,同时也给单片机供电了,发送给串口的数据同时也发给单片机了,这时就混乱了,处理方法是单片机与蓝牙模块之间加跳线帽,设置时拔开,通讯时插上。

 

经验教训:外接设备与单片机连接时,最好做好隔离,包括编码器、蓝牙模块、wifi模块等。

另外,做通讯协议时,单片机通过蓝牙收到数据,处理返回数据时,返回处理函数最好清晰,此串口用作接受处理函数后,就不要再定时器里写其他的定时返回函数,否则会很混乱!收发乱七八糟……这也是血的教训。

例如,用单片机usart5做蓝牙通讯,蓝牙收到00,返回01,同时,蓝牙还要每隔0.01秒返回02,这样就会乱,导致蓝牙发送接收丢数据。

同时,还要强调,一定要检查自己的电脑com口有没有问题,博主用自己的台式机一直失败,换了个笔记本莫名其妙好了!

蓝牙篇就到这。

2015-08-05 15:19:59 cjc_karen 阅读数 5813
·简介:由于业务关系,需要开发一个向单片机发送数据的应用,不过由于需求很简单,只  需要发送数据即可,所以该dome的功能只有发送数据功能,并没有对输入的数据   做进一步的处理

这里有蓝牙开发的基本资料,建议蓝牙基础欠缺的可以先悉知一下:http://pan.baidu.com/s/1ntrHntB

这里是我的dome工程目录





布局文件:
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
    android:layout_height="match_parent" android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    android:paddingBottom="@dimen/activity_vertical_margin" tools:context=".MainActivity">



    <TextView
        android:id="@+id/textView1"
        android:text="@string/hello_world"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
    <TextView
        android:id="@+id/textView2"
        android:layout_below="@id/textView1"
        android:text="@string/hello_world"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

    <TextView
        android:id="@+id/textView3"
        android:layout_below="@id/textView2"
        android:text="@string/hello_world"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />


    <SeekBar
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/seekBar1"
        android:layout_below="@+id/textView2"
        android:layout_alignParentLeft="true"
        android:layout_alignParentStart="true"
        android:layout_marginTop="108dp" />
    <SeekBar
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/seekBar2"
        android:layout_centerVertical="true"
        android:layout_alignParentRight="true"
        android:layout_alignParentEnd="true" />

</RelativeLayout>

总的来说,通讯过程是:
1、得到本地蓝牙设备,
 void initOpenBluetooth() {
        //取得本地蓝牙设备
        mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

        if (mBluetoothAdapter == null) {
            Toast.makeText(this, "蓝牙不可用", Toast.LENGTH_SHORT).show();
            finish();
            return;
        }

        //如果蓝牙没打开,提醒用户打开蓝牙
        if (!mBluetoothAdapter.isEnabled()) {
            Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
            startActivityForResult(intent, REQUEST_ENABLE_BT);
        }else {
            if(mBluetoothAdapter.isEnabled()){
                initGetDevice();
            }
        }

    }

2、得到远程设备,
private void initGetDevice(){
        //获取远程BlueToothDevice
        device = mBluetoothAdapter.getRemoteDevice(address);
        textView3.setText(device.getAddress() + ":" + device.getName());

        if (mChatService == null) {
            mChatService = new BluetoothChatService(this);
            if (D) Log.v(TAG, "当前蓝牙状态:" + mChatService.getState());

            mChatService.connect(device);//启动了蓝牙连接线程,
            if (D) Log.v(TAG, "当前蓝牙状态:" + mChatService.getState());
        }
    }

3、找到已配对的设备,连接,连接需要唯一的通讯信道UUID
 /*********************    连接线程   ****************/
    private class ConnectThread extends Thread {
        private final BluetoothSocket mmSocket;
        private final BluetoothDevice mmDevice;

        public ConnectThread(BluetoothDevice device) {
            mmDevice = device;
            BluetoothSocket tmp = null;

            // Get a BluetoothSocket for a connection with the
            // given BluetoothDevice
            try {
                tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
            } catch (IOException e) {
                Log.e(TAG, "create() failed", e);
            }
            mmSocket = tmp;
        }

        public void run() {
            Log.i(TAG, "BEGIN mConnectThread");
            setName("ConnectThread");

            // Always cancel discovery because it will slow down a connection
            mAdapter.cancelDiscovery();

            // Make a connection to the BluetoothSocket
            try {
                // This is a blocking call and will only return on a
                // successful connection or an exception
                mmSocket.connect();
            } catch (IOException e) {
                connectionFailed();
                // Close the socket
                try {
                    mmSocket.close();
                } catch (IOException e2) {
                    Log.e(TAG, "unable to close() socket during connection failure", e2);
                }
                /*// Start the service over to restart listening mode
                BluetoothChatService.this.start();*/
                return;
            }

            // Reset the ConnectThread because we're done
            synchronized (BluetoothChatService.this) {
                mConnectThread = null;
            }

            // Start the connected thread
            connected(mmSocket, mmDevice);
        }

        public void cancel() {
            try {
                mmSocket.close();
            } catch (IOException e) {
                Log.e(TAG, "close() of connect socket failed", e);
            }
        }
    }

3、连接后的连接管理,通讯
 /*********************   连接管理,通讯线程   **********************/
    private class ConnectedThread extends Thread {
        private final BluetoothSocket mmSocket;
        private final InputStream mmInStream;
        private final OutputStream mmOutStream;

        public ConnectedThread(BluetoothSocket socket) {
            Log.d(TAG, "create ConnectedThread");
            mmSocket = socket;
            InputStream tmpIn = null;
            OutputStream tmpOut = null;

            // Get the BluetoothSocket input and output streams
            try {
                tmpIn = socket.getInputStream();
                tmpOut = socket.getOutputStream();
            } catch (IOException e) {
                Log.e(TAG, "temp sockets not created", e);
            }

            mmInStream = tmpIn;
            mmOutStream = tmpOut;
        }

        public void run() {
            Log.i(TAG, "BEGIN mConnectedThread");
            byte[] buffer = new byte[1024];
            int bytes;

            // Keep listening to the InputStream while connected
            while (true) {
                try {
                    // Read from the InputStream
                    bytes = mmInStream.read(buffer);

                } catch (IOException e) {
                    Log.e(TAG, "disconnected", e);
                    connectionLost();
                    break;
                }
            }
        }

        /**
         * Write to the connected OutStream.
         * @param buffer  The bytes to write
         */
        public void write(byte[] buffer) {
            try {
                mmOutStream.write(buffer);

            } catch (IOException e) {
                Log.e(TAG, "Exception during write", e);
            }
        }

        public void cancel() {
            try {
                mmSocket.close();
            } catch (IOException e) {
                Log.e(TAG, "close() of connect socket failed", e);
            }
        }
    }

4、最后一步,修复一些小Bug,然后可以根据自己的业务需求来更改代码。
     本来还有一个等待连接线程的,但该次业务无此需求,故不列出来了。

5:这里是整个dome的代码:
MainActivity:
public class MainActivity extends ActionBarActivity implements SeekBar.OnSeekBarChangeListener {

    // Debugging
    private static final String TAG = "MainActivity";
    private static final boolean D = true;

    //定义打开蓝牙的请求码
    private static final int REQUEST_ENABLE_BT = 2;

    // 本地蓝牙设备
    private BluetoothAdapter mBluetoothAdapter = null;
    // Member object for the chat services
    private BluetoothChatService mChatService = null;

    BluetoothDevice device;
    private static String address = "30:14:11:12:38:01";

    SeekBar seekBar1,seekBar2;
    TextView textView1,textView2,textView3;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        if(D) Log.v(TAG, "+++ ON CREATE +++");
        System.out.println("+++ ON CREATE +++");

        seekBar1 = (SeekBar) findViewById(R.id.seekBar1);
        seekBar2 = (SeekBar) findViewById(R.id.seekBar2);
        textView1 = (TextView) findViewById(R.id.textView1);
        textView2 = (TextView) findViewById(R.id.textView2);
        textView3 = (TextView) findViewById(R.id.textView3);

        //两种方式监听
        seekBar1.setOnSeekBarChangeListener(this);
        seekBar2.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
            @Override
            public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
                textView2.setText("当前值:" + progress);

                //  发送数据
                String msg = String.valueOf(progress);

                if (mChatService.getState() == BluetoothChatService.STATE_CONNECTED) {

                    mChatService.write(getHexBytes(msg));

                }else {
                    System.out.println("没有连接好");
                }
            }

            @Override
            public void onStartTrackingTouch(SeekBar seekBar) {

            }

            @Override
            public void onStopTrackingTouch(SeekBar seekBar) {

            }
        });

        initOpenBluetooth();

    }

    /***************  再按一次退出程序  ****************/
    private long _doubleClickedTime = 0;
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (keyCode == KeyEvent.KEYCODE_BACK) {
            long clickedTime = System.currentTimeMillis();
            if (clickedTime - _doubleClickedTime <= 2000) {
                // 两次点击退出
                finish();
            } else {
                Toast.makeText(getApplicationContext(), "再按一次退出程序", Toast.LENGTH_SHORT).show();
                _doubleClickedTime = clickedTime;
            }
            return true;
        }
        return super.onKeyDown(keyCode, event);
    }


    /***********  退出后,把蓝牙的连接注销   ***********/
    @Override
    protected void onDestroy() {
        super.onDestroy();
        mChatService.stop();
        finish();
    }


    /*************  当“打开蓝牙的dialog结束后,要回调的函数”    ************/
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        if(requestCode == REQUEST_ENABLE_BT){

            initGetDevice();

        }
    }


    /*******************  initOpenBluetooth    *********************/
    void initOpenBluetooth() {
        //取得本地蓝牙设备
        mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

        if (mBluetoothAdapter == null) {
            Toast.makeText(this, "蓝牙不可用", Toast.LENGTH_SHORT).show();
            finish();
            return;
        }

        //如果蓝牙没打开,提醒用户打开蓝牙
        if (!mBluetoothAdapter.isEnabled()) {
            Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
            startActivityForResult(intent, REQUEST_ENABLE_BT);
        }else {
            if(mBluetoothAdapter.isEnabled()){
                initGetDevice();
            }
        }

    }


    /********************  intDetDevice  **********************/
    private void initGetDevice(){
        //获取远程BlueToothDevice
        device = mBluetoothAdapter.getRemoteDevice(address);
        textView3.setText(device.getAddress() + ":" + device.getName());

        if (mChatService == null) {
            mChatService = new BluetoothChatService(this);
            if (D) Log.v(TAG, "当前蓝牙状态:" + mChatService.getState());

            mChatService.connect(device);//启动了蓝牙连接线程,
            if (D) Log.v(TAG, "当前蓝牙状态:" + mChatService.getState());
        }
    }


    /******************** 字符串转换为16进制  **********************/
    private byte[] getHexBytes(String message) {
        int len = message.length() / 2;
        char[] chars = message.toCharArray();
        String[] hexStr = new String[len];
        byte[] bytes = new byte[len];
        for (int i = 0, j = 0; j < len; i += 2, j++) {
            hexStr[j] = "" + chars[i] + chars[i + 1];
            bytes[j] = (byte) Integer.parseInt(hexStr[j], 16);
        }
        return bytes;
    }


    /********************************  拖动发送数据   ********************************/
    @Override
    public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {

        textView1.setText("当前值:" + progress);
        //  发送数据
        String msg = String.valueOf(progress);

        if (mChatService.getState() == BluetoothChatService.STATE_CONNECTED) {

            mChatService.write(getHexBytes(msg));

        }else {
            System.out.println("没有连接好");
        }
    }
    @Override
    public void onStartTrackingTouch(SeekBar seekBar) {

    }
    @Override
    public void onStopTrackingTouch(SeekBar seekBar) {

    }

/******************************   标题栏  ************************************/
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_main, menu);
        return true;
    }
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

工具类:BluetoothChatService:
public class BluetoothChatService {
    // Debugging
    private static final String TAG = "BluetoothChatService";
    private static final boolean D = true;

    // Name for the SDP record when creating server socket
    private static final String NAME = "BluetoothChat";

    // Unique UUID for this application

    private static final UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");

    // Member fields
    private final BluetoothAdapter mAdapter;

    private AcceptThread mAcceptThread;
    private ConnectThread mConnectThread;
    private ConnectedThread mConnectedThread;
    private int mState;

    // Constants that indicate the current connection state
    public static final int STATE_NONE = 0;       // we're doing nothing
    public static final int STATE_LISTEN = 1;     // now listening for incoming connections
    public static final int STATE_CONNECTING = 2; // now initiating an outgoing connection
    public static final int STATE_CONNECTED = 3;  // now connected to a remote device


    public BluetoothChatService(Context context) {
        mAdapter = BluetoothAdapter.getDefaultAdapter();
        mState = STATE_NONE;
    }


    private synchronized void setState(int state) {
        if (D) Log.d(TAG, "setState() " + mState + " -> " + state);
        mState = state;


    }

    public synchronized int getState() {
        return mState;
    }

    /***************  本来还有个监听线程入口 和 监听线程。此应用没用到  ***********/

    /**********************   启动连接线程  ************************/
    public synchronized void connect(BluetoothDevice device) {
        if (D) Log.d(TAG, "connect to: " + device);

        // Cancel any thread attempting to make a connection
      /*  if (mState == STATE_CONNECTING) {
            if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}
        }
*/
        if (mState == STATE_NONE) {
            if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}
        }

        // Cancel any thread currently running a connection
        if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}

        // Start the thread to connect with the given device
        mConnectThread = new ConnectThread(device);
        mConnectThread.start();
        setState(STATE_CONNECTING);
    }


    /*******************  启动连接管理,通讯线程的入口 **************************/
    public synchronized void connected(BluetoothSocket socket, BluetoothDevice device) {
        if (D) Log.d(TAG, "connected");

        // Cancel the thread that completed the connection
        if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}

        // Cancel any thread currently running a connection
        if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}

        // Cancel the accept thread because we only want to connect to one device
        if (mAcceptThread != null) {mAcceptThread.cancel(); mAcceptThread = null;}

        // Start the thread to manage the connection and perform transmissions
        mConnectedThread = new ConnectedThread(socket);
        mConnectedThread.start();
        setState(STATE_CONNECTED);
    }

    /******************   注销掉所有  *****************/
    public synchronized void stop() {
        if (D) Log.d(TAG, "stop");
        if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}
        if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}
        if (mAcceptThread != null) {mAcceptThread.cancel(); mAcceptThread = null;}
        setState(STATE_NONE);
    }

    /***************  写出给通许线程,由线程来发送数据  ***********/
    public void write(byte[] out) {
        // Create temporary object
        ConnectedThread r;
        // Synchronize a copy of the ConnectedThread
        synchronized (this) {
            if (mState != STATE_CONNECTED) return;
            r = mConnectedThread;
        }
        // Perform the write unsynchronized
        r.write(out);
    }


    private void connectionFailed() {
        setState(STATE_LISTEN);
    }

    private void connectionLost() {
        setState(STATE_LISTEN);
    }


   /*********************  等待监听线程,此应用没用到  ****************/
    private class AcceptThread extends Thread {
        // The local server socket
        private final BluetoothServerSocket mmServerSocket;

        public AcceptThread() {
            BluetoothServerSocket tmp = null;

            // Create a new listening server socket
            try {
                tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
            } catch (IOException e) {
                Log.e(TAG, "listen() failed", e);
            }
            mmServerSocket = tmp;
        }

        public void run() {
            if (D) Log.d(TAG, "BEGIN mAcceptThread" + this);
            setName("AcceptThread");
            BluetoothSocket socket = null;

            // Listen to the server socket if we're not connected
            while (mState != STATE_CONNECTED) {
                try {
                    // This is a blocking call and will only return on a
                    // successful connection or an exception
                    socket = mmServerSocket.accept();
                } catch (IOException e) {
                    Log.e(TAG, "accept() failed", e);
                    break;
                }

                // If a connection was accepted
                if (socket != null) {
                    synchronized (BluetoothChatService.this) {
                        switch (mState) {
                            case STATE_LISTEN:
                            case STATE_CONNECTING:
                                // Situation normal. Start the connected thread.
                                connected(socket, socket.getRemoteDevice());
                                break;
                            case STATE_NONE:
                            case STATE_CONNECTED:
                                // Either not ready or already connected. Terminate new socket.
                                try {
                                    socket.close();
                                } catch (IOException e) {
                                    Log.e(TAG, "Could not close unwanted socket", e);
                                }
                                break;
                        }
                    }
                }
            }
            if (D) Log.i(TAG, "END mAcceptThread");
        }

        public void cancel() {
            if (D) Log.d(TAG, "cancel " + this);
            try {
                mmServerSocket.close();
            } catch (IOException e) {
                Log.e(TAG, "close() of server failed", e);
            }
        }
    }


   /*********************    连接线程   ****************/
    private class ConnectThread extends Thread {
        private final BluetoothSocket mmSocket;
        private final BluetoothDevice mmDevice;

        public ConnectThread(BluetoothDevice device) {
            mmDevice = device;
            BluetoothSocket tmp = null;

            // Get a BluetoothSocket for a connection with the
            // given BluetoothDevice
            try {
                tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
            } catch (IOException e) {
                Log.e(TAG, "create() failed", e);
            }
            mmSocket = tmp;
        }

        public void run() {
            Log.i(TAG, "BEGIN mConnectThread");
            setName("ConnectThread");

            // Always cancel discovery because it will slow down a connection
            mAdapter.cancelDiscovery();

            // Make a connection to the BluetoothSocket
            try {
                // This is a blocking call and will only return on a
                // successful connection or an exception
                mmSocket.connect();
            } catch (IOException e) {
                connectionFailed();
                // Close the socket
                try {
                    mmSocket.close();
                } catch (IOException e2) {
                    Log.e(TAG, "unable to close() socket during connection failure", e2);
                }
                /*// Start the service over to restart listening mode
                BluetoothChatService.this.start();*/
                return;
            }

            // Reset the ConnectThread because we're done
            synchronized (BluetoothChatService.this) {
                mConnectThread = null;
            }

            // Start the connected thread
            connected(mmSocket, mmDevice);
        }

        public void cancel() {
            try {
                mmSocket.close();
            } catch (IOException e) {
                Log.e(TAG, "close() of connect socket failed", e);
            }
        }
    }

  /*********************   连接管理,通讯线程   **********************/
    private class ConnectedThread extends Thread {
        private final BluetoothSocket mmSocket;
        private final InputStream mmInStream;
        private final OutputStream mmOutStream;

        public ConnectedThread(BluetoothSocket socket) {
            Log.d(TAG, "create ConnectedThread");
            mmSocket = socket;
            InputStream tmpIn = null;
            OutputStream tmpOut = null;

            // Get the BluetoothSocket input and output streams
            try {
                tmpIn = socket.getInputStream();
                tmpOut = socket.getOutputStream();
            } catch (IOException e) {
                Log.e(TAG, "temp sockets not created", e);
            }

            mmInStream = tmpIn;
            mmOutStream = tmpOut;
        }

        public void run() {
            Log.i(TAG, "BEGIN mConnectedThread");
            byte[] buffer = new byte[1024];
            int bytes;

            // Keep listening to the InputStream while connected
            while (true) {
                try {
                    // Read from the InputStream
                    bytes = mmInStream.read(buffer);

                } catch (IOException e) {
                    Log.e(TAG, "disconnected", e);
                    connectionLost();
                    break;
                }
            }
        }

        /**
         * Write to the connected OutStream.
         * @param buffer  The bytes to write
         */
        public void write(byte[] buffer) {
            try {
                mmOutStream.write(buffer);

            } catch (IOException e) {
                Log.e(TAG, "Exception during write", e);
            }
        }

        public void cancel() {
            try {
                mmSocket.close();
            } catch (IOException e) {
                Log.e(TAG, "close() of connect socket failed", e);
            }
        }
    }
}


希望这边文章可以帮到阅读者

顺便一提:参考的出处的时候太久远了,忘了出处,在这里给他(他)说声:不好意思。。。


2018-10-02 22:34:20 qimi923511491 阅读数 21053

需要的工具:

usb转ttl模块*1


模块如下:

        要想使用HC-05蓝牙模块进行单片机之间通讯或者单片机和蓝牙设备之间通讯,首先要配置好HC-05蓝牙模块的参数。设置好蓝牙的名称、密码、波特率等待。

step1:

        连接usb转ttl模块蓝牙模块,把两个模块的VCC口相连,GND口相连,TX和RX交叉相连(既TX连RX,RX连TX)。

然后下载蓝牙串口配置软件进行配置:提取码:6d32

软件界面如下:

step2:

        连接好两个模块之后,按住蓝牙模块上的小按钮(按住上电是配置模式,直接上电是正常使用模式),然后把usb转ttl模块插上电脑。

选择好端口设置上的COM口,其它配置默认不需要改,点击打开串口。如果硬件连接和端口设置没问题的话这时候就可以连接成功了。

之后点击AT按钮,如果左边界面出现OK字样就证明已经连接成功了,然后就开始根据需求进行配置


手机连接51单片机+蓝牙

  1. 点击设置从机。
  2. 点击设置模式,在右上角改1为0然后点击手动发送。
  3. 点击设置波特率,PS:这里设置的波特率和刚刚端口设置中的波特率是不一样的,这个是正常模式下蓝牙和单片机通讯的波特率,端口设置中的波特率是配置模式下的波特率,修改这里的波特率不是改变配置模式的波特率,下次配置蓝牙模块的端口设置中的波特率还是保持默认。波特率要和单片机的波特率设置为一样,通常51单片机的程序都是用9600,这里默认9600。
  4. 设置密码,看个人喜好。
  5. 设置名称,看个人喜好。

如果以上设置中出现什么问题的话,点击恢复出厂设置重新设置一边。如果没问题的话就可以开始把蓝牙换到单片机上进行使用了。

 

step3:

        吧蓝牙和单片机串口进行连接,蓝牙和单片机的连接和上面的一样,注意TX和RX之间要交叉连接。

        只要连接好蓝牙,烧录好单片机程序,蓝牙就会把单片机串口发送来的数据向已经连接上的蓝牙设备进行发送。

51单片机的demo:

/*串口初始化配置*/
void UartConfiguration()  
{
    TMOD=0x20;      //设置计数器1的工作方式2
    TH1=0xfd;	    //设置计数器1的初值,决定波特率
    TL1=0xfd;		//设置计数器1的初值,决定波特率
    PCON=0x00;      // 波特率倍增0x00不加倍	 0x80加倍
    SCON=0x50;		//设置工作方式1 开启接受允许
    EA=1;		    //开启总中断
    ES=1;			//开启串口接受中断
    TR1=1;			//计数器1开始运行
}
/*发送数据*/
void sendDate(char date)
{
    SBUF=date;		  //接收到的数据放入发送缓存器发送
    while(!TI);       //等待发送数据完成
    TI=0;			  //清除发送完成标志位
}

/*主函数*/
void main()
{
    UartConfiguration();

    sendDate('1');  //发送字符1

    while(1);
}

/*中断函数*/
void Uart() interrupt 4
{
    uchar date;
    date=SBUF;        //取出接受到的数据
    RI=0;			  //清除接受中断标志位

    //收到的数据是date
	
}

这是51单片机向串口发送数据的例程,其中while(!TI)是等待消息发送成功,如果发送不成功的话会一直等待阻塞程序。

        而且51单片机的串口中断是一个字节一个字节地接收数据的,比如手机向单片机发送了数据“123”,单片机中的中断函数Uart()会进入三次,把数据“123”分三次接收完,一次接收一个字符,所以要在其中添加自己的逻辑把单个字符组合成一个字符串来进行处理。

                                           

2019-04-07 16:09:07 the__future 阅读数 1184

来源:http://tieba.baidu.com/p/3324405179

问题0010:蓝牙串口模块使用的正确步骤
很多人现在都开始使用蓝口模块,利用手机蓝牙或者PC蓝牙进行控制单片机系统。但是很多人一上来就直接把蓝牙模块和单片机相连接,然后编写程序,效果实现不了,就不知该如何了。蓝牙模块很多都是结合了串口通信的,通常拿到模块,需要经过一下步骤(自己总结,可做参考):

(1)首先,需要蓝牙模块和PC的硬件连接,这里有两种方法:

1.1 把你的开发板的单片机取下来,然后从开发板引出电源线VCC和GND,还有P30、P31接口,连接蓝牙模块的四个端口(注意RXD和TXD不要反接了)

1.2 如果你有USB-TTL模块,可以直接连接蓝牙模块,无需单片机开发板转接过去。

(2)通过PC的串口软件(比如STC-ISP软件自带的串口),设置好软件的波特率和通信数据格式,通过串口软件发送AT命令(通常购买时卖家提供了),看是否有返回数据,如果没有返回,有可能是P30、P31接口需要换过来,如果发送命令,有返回信息且不是乱码,表示蓝牙模块和PC可以串口通信了。

(3)手机下载软件“蓝牙串口”,通过此软件连接蓝牙模块(蓝牙的名称和配对密码可通过 AT命令设置),然后给蓝牙模块供电,PC打开串口软件,手机发送任意字符到蓝牙模块,会发现PC串口软件接收到了信息,这表示蓝牙可以正常工作。

(4)编写单片机程序,此时需要分为两步:
4.1 先不连接蓝牙模块,编写程序,单片机接收到串口数据,做出相应动作,写好后下载,然后打开PC的串口软件,发送命令,检验现象是否正确,如果正确,开始第二步

4.2 把蓝牙模块连接到单片机,手机蓝牙连接模块,手机发送命令,此时只要步骤<a>现象经过反复验证没有问题,第二步肯定没问题。(如果第二步不对,那就返回去做第一步)

(5)其他。如果需要用PC的蓝牙进行控制,还需要购买蓝牙适配器,也就是模块发送信息到电脑时,需要一个接收器。如果不是很必要,就用手机蓝牙软件就好了,省钱省事。

HC-05蓝牙模块AT模式设置

蓝牙模块无法检测的一些原因

2018-02-22 12:17:38 qq_40277973 阅读数 71303

不久前开始学习使用蓝牙模块,在模块与51单片机连接的过程中出现了非常多的问题,我想应该也是很多新手和我一样会遇到这样的问题,因此特地写这篇文章,想分享下在学习过程中遇到的问题以及解决方法。


此次学习用到模块是HC-06蓝牙模块,如下图:

该模块某宝有售,价格约为20RMB。某宝上的HC-06有两种,分别是带引脚不带引脚的,建议新手购买带引脚的。我从试验开始到成功,一共使用了四块蓝牙模块。第一次买的是带引脚的,但是模块本身是坏的;第二次买的是不带引脚的,但是由于自身的焊功有限,导致模块损坏,无法使用;第三次是朋友送的蓝牙4.0,由于某些原因无法使用,在此也特别感谢朋友送我蓝牙;第四次购买,就是上图所示的蓝牙,才最终完成了试验。

总结:在某宝购买时,最好货比三家,虽然模块不值钱,但是在购买过程遇到问题会耽误时间,影响开发,非常麻烦。

单片机用了两个,分别是新手常用的开发板还有一个单片机最小模块,两者有什么区别我稍后会说明。

开发板:


单片机最小模块:


我特别标注了两者的晶振,分别为12MHZ11.0594MHZ,就是晶振的不同导致我在学习中问题的发生。以下是学习试验过程。


蓝牙模块的调试:

接线,蓝牙模块的RX接转换模块的TX蓝牙模块的TX接转换模块的RX,如下图所示:


接入电脑,在PC端下载好串口调试助手,软件自搜,此处不再赘述。

附可能会用到的驱动:链接:https://pan.baidu.com/s/1bpYLfCr 密码:yabv

进入到调试助手,其实基本不怎么用调参数了,蓝牙模块基本都默认设置好波特率为9600,因此直接启动软件调试即可。具体调参数的方法可以自行百度其他文章,都有很详细的介绍。

启动串口,成功后左下角显示成功:


发送AT指令,返回OK:


表明串口正常,此时用手机连接蓝牙模块。手机端也是用到调试助手,请自行下载。

搜索蓝牙模块:

备注:我的蓝牙模块此前已经被我改名为Ezio,未改名前默认为HC06。


连接成功:


尝试发送消息hello:


此时在PC端的串口助手上,可以收到来自手机端发送的消息:


在此说明一点,在蓝牙模块上电以后,模块上的LED灯为闪烁状态,此时处于从机模式,与手机成功连接后,LED灯会变为常亮。自此,蓝牙模块调试成功,可以与单片机连接进行试验


蓝牙模块与51单片机接线:

和连接转换模块一样,蓝牙模块的RX连接单片机的TX,蓝牙模块的TX连接单片机的RX,此处说明单片机的RX和TX引脚分别为P3.0和P3.1,如图(图片来自网络):


正确接线后,向单片机中写入程序,程序如下:

#include <reg52.h>

sbit P1_0 = P1^0;	//测试口,可用可不用
sbit P1_3 = P1^3;	//输出口

unsigned char tempbuf;	//存储接收到的信息

/*初始化串口*/
void BlueteethInit()
{
	SCON = 0x50;	//串口模式1,允许接收
	TMOD = 0x20;	//T1工作模式为2,自动重装
	PCON = 0x00;	//波特率不倍增

	REN = 1;

	TH1 = 0xfd;		//设置波特率为9600
	TL1 = 0xfd;

	RI = 0;

	EA = 1;
	ES = 1;

	TR1 = 1;
}

void main()
{
	BlueteethInit();
	P1_0 = 0;
	P1_3 = 0;
	TI = 0;
	while(1)
	{
		if(tempbuf == 0x31)	//可以使用
			P1_3 = 1;
		if(tempbuf == 0)	//不可以使用
			P1_3 = 0;
		if(tempbuf == 'A')	//可以使用
			P1_3 = 1;
		if(tempbuf == 'B')	//可以使用
			P1_3 = 0;
	}
}

void Serial(void) interrupt 4
{
	tempbuf = SBUF;
	RI = 0;	//读标志清零
	SBUF = tempbuf;	//将内容返回到手机端,可在手机查看发送的内容
	while(!TI);
	TI = 0;	//写标志清零
}

该程序为最简单的测试程序,利用蓝牙接收手机发来的信息,控制P1.3口输出高或者低电平,以测试是否正确接收到信息。


第一步,用蓝牙模块与开发板接线,并成功用手机与蓝牙模块连接,尝试发送信息,过程如图所示:


无论是发送数字或者是其他字符,都可以看见返回的是乱码,因此可以知道,单片机接收的也是乱码,故程序中的判断:

while(1)
	{
		if(tempbuf == 0x31)	//可以使用
			P1_3 = 1;
		if(tempbuf == 0)	//不可以使用
			P1_3 = 0;
		if(tempbuf == 'A')	//可以使用
			P1_3 = 1;
		if(tempbuf == 'B')	//可以使用
			P1_3 = 0;
	}

无法正确执行,P1.3口自然也无法根据需要来输出高或者低电平。

第二步,用蓝牙模块与单片机最小模块接线,成功用手机连接收尝试发送信息,如下图所示:


可见,此时返回的内容与发出的内容相同,经测试此时程序也可以正确执行,使用万用表可以检查出P1.3口输出电平的变化,表明此时蓝牙模块可以正常使用。

特别说明:

if(tempbuf == 0x31)	//可以使用
	P1_3 = 1;
if(tempbuf == 0)	//不可以使用
	P1_3 = 0;

当发送数字消息时,应为十六进制,因此在判断时,如接收到1,应判断是否等于0x31,而不是判断是否等于1。此处经过测试,发送1时,判断tempbuf == 0x31,该判断有效;当发送0时,判断tempbuf == 0,判断无效。判断字符加单引号即可。

第三步,为什么使用两个相同的单片机会导致结果不同?这也是困扰了我很久的问题,后来经过检查,才知道原来就是晶振的问题。此处PO一下大神关于晶振的说明,暂时未看懂:https://www.zhihu.com/question/30930577

但可以得出的结论就是,如果使用串口通信,应使用的晶振为11.0594MHZ,否则可能出现乱码的情况。

另附:开发板上的晶振如图:


是可以更换的,某宝也有售,可以根据需要的晶振购买。