单片机论坛

 找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 2712|回复: 8
打印 上一主题 下一主题
收起左侧

android与蓝牙模块HC-05和单片机STC89C52RC通信问题

[复制链接]
跳转到指定楼层
楼主
asd9988775 发表于 2017-6-19 22:09 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
单片机上的程序,我贴了出来,接收串口得到的数据,判断是什么,我用keil仿真得到的是0xA1 0x96 0xb2这些数据可以其实我发送的只有一个
我用过解析ascii转字符串得到的特殊字符,UTF-8,UTF-16LE,UTF-16BE,GBK,unicode,都是特殊字符。现在用.toHexString,得到的是B2。
请求大神帮我看看,哪里的问题现在的问题数据接收问题。不知道是手机发送的有问题,还是怎么样。我打过断点,我发送字母a,转化为char数组后是97,然后发送给,单片机。
不管,单片机里怎么判断,返回的结果应该是"Success"或"Error"。
求大神赐教。

  1. #include“ reg52.h“
  2. #include”intrins.h“

  3. unsigned char SenData,Flag = 0;

  4. char代码str1 [] =“成功”;
  5. char code str2 [] =“Error”;

  6. void send_str();
  7. void InitUART(void);
  8. void send_str2();
  9. void delayms(unsigned char ms);
  10. void send_char(unsigned char txd);

  11. sbit led = P2 ^ 0; //将单片机的P2.0端口定义为led
  12. sbit led2 = P2 ^ 1; //将单片机的P2。
  13. 0端口定义为led void InitUART(void)
  14. {
  15. / *******************设定串口**************** ****** /
  16. SCON = 0x50; //设置为工作方式1
  17. TMOD = 0x20; //设置计数器工作方式2
  18. PCON = 0x80; //波特率加倍
  19. TH1 = 0xFA回应; //计数器初始值设置,注意波特率是9600的
  20. TL1 = TH1;
  21. ES = 1; //打开接收中断
  22. EA = 1; //打开总中断
  23. TR1 = 1; //打开计数器
  24. / ******************设定中断********************** /
  25. }
  26. void main()//主函数
  27. {         
  28. InitUART();
  29. while(1){  
  30. if(Flag == 1)
  31. {
  32.         
  33.         ES = 0;
  34.         delayms(50);
  35. // ----------------------该段即对接收的数据进行处理
  36.         if(SenData == 97)// 97为字符a的ascii - ----------网上有人说接受的是ascii
  37.         {
  38.         led = 0; //P2.0端口设置为低电平
  39.         delayms(10); //延时去抖动
  40.         send_str(); //发送数据
  41.         导致= 1; //P2.0端口设置为低电平         
  42.         }
  43.         else
  44.         {
  45.                 led2 = 0;
  46.         delayms(10);
  47.         send_str2();
  48.                 led2 = 1;
  49.         }

  50.         ES = 1;
  51. }
  52. }
  53. }

  54. void ser_int()interrupt 4 //接收字符串
  55. {   
  56. if(RI == 1)// RI接受中断标志
  57. {  
  58. SenData = SBUF;
  59. RI = 0; //清除标志。
  60. Flag = 1;
  61. //标志位置1表示有新数据进来}
  62. }


  63. void send_str()//发送字串
  64. {
  65. unsigned char i = 0;
  66. Flag = 0; //数据处理完毕后将标志位置0,表示没有新数据要处理
  67. while(str1!='\ 0')
  68. {
  69. SBUF = str1;
  70. while(!TI); //等待数据传送
  71. TI = 0; //清除数据传输标志
  72. i ++; //下一个字符串
  73. }
  74. }

  75. void send_str2()//发送字串
  76. {
  77. unsigned char i = 0;
  78. Flag = 0; //数据处理完毕后将标志位置0,表示没有新数据要处理
  79. while(str2!='\ 0')
  80. {
  81. SBUF = str2;
  82. while(!TI); //等待数据传送
  83. TI = 0; //清除数据传输标志
  84. i ++; //下一个字符串
  85. }
  86. }



  87. void delayms(unsigned char ms)//延时子程序
  88. {
  89. unsigned char i;
  90. while(ms--)
  91. {
  92. for(i = 0; i <120; i ++);
  93. }
  94. }
  95. 上面是烧录缉拿stc89c52rc芯片里程序
  96. //////////////////////////////////// ///////////////////////
  97. 下面是我在安卓使用蓝牙的接收与发送
  98. / *************** ********************************** /         

  99. 发送
  100.     字符串executStr = edit_name.getText()。toString();
  101.                             executStr + =“\ r \ n”;
  102.                             mChatService.write(executStr.getBytes());
  103.   public void write(byte [] buffer){
  104.             if(mmSocket == null){
  105.                 Log.d(“----------------------”,“没有连接“);
  106.                 返回;
  107.             }
  108.             try {
  109.               / * BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(mmOutStream));
  110.                 bw.write(buffer); * /
  111.                 mmOutStream.write(buffer);
  112.                 if(mmSocket!= null){
  113.                     mmOutStream.flush();
  114.                 }
  115.                 //将发送的消息分享回UI活动
  116.                 mHandler.obtainMessage(Constants.MESSAGE_WRITE,-1,-1,buffer)
  117.                         .sendToTarget();
  118.             } catch(IOException e){
  119.                 Log.e(TAG,“写入时异常”,e);
  120.             }
  121.         }
  122. / ************************************************* ** /  
  123. 接收
  124. 字节[] buffer = new byte [1024];
  125.             StringBuilder sb = new StringBuilder();
  126.             int字节;
  127.             String b =“”,str =“”;
  128.             Log.d(TAG,“”+ mState);
  129.             if(mmSocket == null){
  130.                 Log.d(“----------------------”,“没有连接”);
  131.                 返回;
  132.             }
  133.             //继续听InputStream的同时连接
  134.             而(mState == STATE_CONNECTED){
  135.                 尝试{
  136.                     的BufferedInputStream读者=新的BufferedInputStream(mmInStream);
  137.                     bytes = reader.read(buffer);
  138.                     String tempStr = new String(buffer); // temp写入日志
  139.                     tempStr.replace(“\ r \ n”,“***”);
  140.                     /*mHandler.obtainMessage(Constants.MESSAGE_READ,bytes,0,new String(buffer)).
  141.                             sendToTarget(); * /
  142.                     // sb.append(new String(buffer,0,bytes));
  143.                     for(int i = 0; i <bytes;
  144.                         i ++){ b = Integer.toHexString(buffer [ i]&0x000000FF).toUpperCase();                         str = Integer.toHexString((buffer &0x000000ff)| 0xffffff00)                                .substring(6).toUpperCase();                         if(b.length()<2)                            sb.append(“0”);                         sb.append(b)中;                     }                     log.d(“message”,str);
  145.                   / *                     if(sb.indexOf(“Success”)> = 0 || sb.indexOf(“Error”)> = 0){* / ------------------ -----因为返回的只有成功和异常。所有在这里判断                    mHandler.obtainMessage(Constants.MESSAGE_READ,                            bytes - 1,-1,sb.toString()). sendToTarget();                     //sb.delete(0,sb.length());
复制代码

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏3 转播转播 分享分享 分享淘帖 顶 踩
回复

使用道具 举报

沙发
HC6800-ES-V2.0 发表于 2017-6-20 08:23 | 只看该作者
最近,有很多帖子问题串口通讯问题。你可以搜一搜,我都有回复。
其实,串口通讯没什么难搞的,要搞清楚几个关键:
第一:你贴程序,为什么不说说你的单片机板子相关的硬件,重要的——晶振,是多少。从你的程序上看,应该是11.0592MHz(那个FA是我判断的依据),但你的硬件是不是这个?
如果是,这个就没问题了;如果不是,问题就大了。如果是12M的,那么,串口通讯的误差就非常大,接收、发送的数据就不是你发送的,当然没法判断和控制了!
第二:你有没有手机端的原程序?或者配套的51端原程序。我在本论坛看到好多别人的例子,要专门对照两个程序,看它们发送、接收的数据类型。以前我搞这个时,就是不清楚这个数据格式或叫数据类型,在看了别人例子,搞清楚发送、接收数据类型后,我的手机控制51单片机就成功了。所以,你要找找手机端原程序,看看它到底发送的是什么,或者与之配套的51程序,看看它到底接收的是什么数据。
从你的描述上看,你能测量得到是什么数据,却不知道发送的是什么内容,看来没有手机端程序了,也没有配套的51原程序,这个很难办,建议全部重新自己做过。
第三:不知道你是不是第一次做这样的串口设计。可以先参看别人的例子。本论坛中有好的例子,而且是完整的,51端、手机端都有,我就是看过他们的例子才搞出我自己的蓝牙控制的。
回复

使用道具 举报

板凳
cjjcjj1 发表于 2017-6-20 10:00 | 只看该作者
提示: 作者被禁止或删除 内容自动屏蔽
回复

使用道具 举报

地板
 楼主| asd9988775 发表于 2017-6-30 18:34 | 只看该作者
HC6800-ES-V2.0 发表于 2017-6-20 08:23
最近,有很多帖子问题串口通讯问题。你可以搜一搜,我都有回复。
其实,串口通讯没什么难搞的,要搞清楚几 ...

嗯,好的
回复

使用道具 举报

5#
 楼主| asd9988775 发表于 2017-6-30 18:35 | 只看该作者
cjjcjj1 发表于 2017-6-20 10:00
你好!这个还是要一步步的来测试,看看问题出在那个环节上;
你的手机APP用的什么软件?是通用的还是自己 ...

自己写的app。不太懂什么是通用的?我只是用android的蓝牙类写的程序
回复

使用道具 举报

6#
 楼主| asd9988775 发表于 2017-7-1 17:20 | 只看该作者
HC6800-ES-V2.0 发表于 2017-6-20 08:23
最近,有很多帖子问题串口通讯问题。你可以搜一搜,我都有回复。
其实,串口通讯没什么难搞的,要搞清楚几 ...

/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package com.myapplication.bluetoothconnection;

import android.annotation.TargetApi;
import android.app.ProgressDialog;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.content.Context;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.URLDecoder;
import java.nio.CharBuffer;
import java.util.UUID;

/**
* This class does all the work for setting up and managing Bluetooth
* connections with other devices. It has a thread that listens for
* incoming connections, a thread for connecting with a device, and a
* thread for performing data transmissions when connected.
*/
public class BluetoothChatService {
    // Debugging
    private static final String TAG = "BluetoothChatService";

    // Name for the SDP record when creating server socket
    private static final String NAME_SECURE = "BluetoothChatSecure";
    private static final String NAME_INSECURE = "BluetoothChatInsecure";

    // Unique UUID for this application
    private static final UUID MY_UUID_SECURE =
            UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
    private static final UUID MY_UUID_INSECURE =
            UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");

    // Member fields
    private final BluetoothAdapter mAdapter;
    private final Handler mHandler;

    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

    private ProgressDialog progressDialog;
    Context context;

    /**
     * Constructor. Prepares a new BluetoothChat session.
     *
     * @param context The UI Activity Context
     * @param handler A Handler to send messages back to the UI Activity
     */
    public BluetoothChatService(Context context, Handler handler) {
        this.context = context;
        mAdapter = BluetoothAdapter.getDefaultAdapter();
        mState = STATE_NONE;//蓝牙状态
        mHandler = handler;//用来跟新ui
        progressDialog = new ProgressDialog(context);
        setDialog();
    }

    private void setDialog() {

        progressDialog.setTitle("连接蓝牙");
        progressDialog.setMessage("连接蓝牙中....");
        progressDialog.setCancelable(true);

    }

    /**
     * Set the current state of the chat connection
     *
     * @param state An integer defining the current connection state
     */
    private synchronized void setState(int state) {
        /*Log.d(TAG, "setState() " + mState + " -> " + state);*/
        mState = state;

        // Give the new state to the Handler so the UI Activity can update
        mHandler.obtainMessage(Constants.MESSAGE_STATE_CHANGE, state, -1).sendToTarget();
    }

    /**
     * Return the current connection state.
     */
    public synchronized int getState() {
        return mState;
    }


    /**
     * Start the ConnectThread to initiate a connection to a remote device.
     *
     * @param device The BluetoothDevice to connect
     * @param secure Socket Security type - Secure (true) , Insecure (false)
     */
    public synchronized void connect(BluetoothDevice device, boolean secure) {
        // Cancel any thread attempting to make a connection
        if (mState == STATE_CONNECTING) {
            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, secure);
        mConnectThread.start();
        setState(STATE_CONNECTING);
        progressDialog.show();
    }

    /**
     * Start the ConnectedThread to begin managing a Bluetooth connection
     *
     * @param socket The BluetoothSocket on which the connection was made
     * @param device The BluetoothDevice that has been connected
     */
    public synchronized void connected(BluetoothSocket socket, BluetoothDevice
            device, final String socketType) {
        Log.d(TAG, "connected, Socket Type:" + socketType);
        progressDialog.dismiss();//连接成功取消进度框
        // 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;
        }

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

        // 发送已经连接成功的设备名字返回ui线程,即通过ui一开始构造器传进来的mHandler来处理
        Message msg = mHandler.obtainMessage(Constants.MESSAGE_DEVICE_NAME);
        Bundle bundle = new Bundle();
        bundle.putString(Constants.DEVICE_NAME, device.getName());
        msg.setData(bundle);
        mHandler.sendMessage(msg);
    }

    /**
     * Stop all threads
     */
    public synchronized void stop() {
        Log.d(TAG, "stop");

        if (mConnectThread != null) {
            mConnectThread.cancel();
            mConnectThread = null;
        }

        if (mConnectedThread != null) {
            mConnectedThread.cancel();
            mConnectedThread = null;
        }


        setState(STATE_NONE);
    }

    /**
     * Write to the ConnectedThread in an unsynchronized manner
     *
     * @param out The bytes to write
     * @see ConnectedThread#(byte[])
     */
    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);
    }

    /**
     * Indicate that the connection attempt failed and notify the UI Activity.
     */
    private void connectionFailed() {
        // Send a failure message back to the Activity
        Message msg = mHandler.obtainMessage(Constants.MESSAGE_TOAST);
        Bundle bundle = new Bundle();
        bundle.putString(Constants.TOAST, "Unable to connect device");
        msg.setData(bundle);
        mHandler.sendMessage(msg);

        // Start the service over to restart listening mode
        //BluetoothChatService.this.start();
    }

    /**
     * Indicate that the connection was lost and notify the UI Activity.
     */
    private void connectionLost() {
        // Send a failure message back to the Activity
        Message msg = mHandler.obtainMessage(Constants.MESSAGE_TOAST);
        Bundle bundle = new Bundle();
        bundle.putString(Constants.TOAST, "Device connection was lost");
        msg.setData(bundle);
        mHandler.sendMessage(msg);

        // Start the service over to restart listening mode
        //BluetoothChatService.this.start();
    }


    /**
     * This thread runs while attempting to make an outgoing connection
     * with a device. It runs straight through; the connection either
     * succeeds or fails.
     */
    private class ConnectThread extends Thread {
        private final BluetoothSocket mmSocket;
        private final BluetoothDevice mmDevice;
        private String mSocketType;

        @TargetApi(Build.VERSION_CODES.GINGERBREAD_MR1)
        public ConnectThread(BluetoothDevice device, boolean secure) {
            mmDevice = device;//连接必须要有device这个对象
            BluetoothSocket tmp = null;
            mSocketType = secure ? "Secure" : "Insecure";
            // 拿到socket,
            //这里uuid有分安全模式和非安全模式之分
            try {
                if (secure) {
                    tmp = device.createRfcommSocketToServiceRecord(
                            MY_UUID_SECURE);
                    Log.d(TAG, "get temp over");
                } else {
                    tmp = device.createInsecureRfcommSocketToServiceRecord(
                            MY_UUID_INSECURE);
                    Log.d(TAG, "get temp over");
                }
            } catch (IOException e) {
                Log.e(TAG, "Socket Type: " + mSocketType + "create() failed", e);
            }
            mmSocket = tmp;
        }

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

            // 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) {
                // Close the socket
                try {
                    mmSocket.close();
                } catch (IOException e2) {
                    Log.e(TAG, "unable to close() " + mSocketType +
                            " socket during connection failure", e2);
                }
                connectionFailed();
                return;
            }

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

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

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

    /**
     * This thread runs during a connection with a remote device.
     * It handles all incoming and outgoing transmissions.
     */
    private class ConnectedThread extends Thread {
        private final BluetoothSocket mmSocket;
        private final InputStream mmInStream;
        private final OutputStream mmOutStream;

        public ConnectedThread(BluetoothSocket socket, String socketType) {
            Log.d(TAG, "create ConnectedThread: " + socketType);
            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.d(TAG, "BEGIN mConnectedThread");
            byte[] buffer = new byte[1024];
            StringBuilder sb = new StringBuilder();
            int bytes;
            String b = "", str= "";
            Log.d(TAG, "" + mState);
            if (mmSocket == null) {
                Log.d("----------------------", "没有连接");
                return;
            }
            // Keep listening to the InputStream while connected
            while (mState == STATE_CONNECTED) {
                try {
                    BufferedInputStream reader = new BufferedInputStream(mmInStream);
                    bytes = reader.read(buffer);
                    String tempStr = new String(buffer);//temp write to log
                    tempStr.replace("\r\n", "***");
                    /*mHandler.obtainMessage(Constants.MESSAGE_READ, bytes, 0, new String(buffer))
                            .sendToTarget();*/
                    // sb.append(new String(buffer, 0, bytes));
                    for (int i = 0; i < bytes; i++) {
                        b = Integer.toHexString(buffer & 0x000000FF).toUpperCase();
                        str = Integer.toHexString((buffer & 0x000000ff) | 0xffffff00)
                                .substring(6).toUpperCase();
                        if (b.length() < 2)
                            sb.append("0");
                        sb.append(b);
                    }
                    Log.d("message",str);

                  /*
                    if (sb.indexOf("Success") >= 0 || sb.indexOf("Error") >= 0) {*/
                    mHandler.obtainMessage(Constants.MESSAGE_READ, bytes - 1, -1, sb.toString())
                            .sendToTarget();
                    //sb.delete(0, sb.length());
                    //  }
                    buffer = new byte[1024];
                 /*  if(sb.charAt(sb.length()-1)=='$'){
                        sb.deleteCharAt(sb.length()-1);
                        Toast.makeText(MainActivity.myContext,sb.toString()+"》MESSAGE_READ",1000).show();
                        mHandler.obtainMessage(Constants.MESSAGE_READ, bytes-1, -1,sb.toString())
                            .sendToTarget();
                        sb.delete(0,sb.length());
                    }*/
                    // Send the obtained bytes to the UI Activity
                } catch (IOException e) {
                    Log.e(TAG, "disconnected", e);
                    connectionLost();
                    // Start the service over to restart listening mode
                    //BluetoothChatService.this.start();
                    break;
                }
                try {
                    Thread.sleep(50);// 延迟
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

        /**
         * Write to the connected OutStream.
         *
         * @param buffer The bytes to write
         */
        public void write(byte[] buffer) {
            if (mmSocket == null) {
                Log.d("----------------------", "没有连接");
                return;
            }
            try {
              /*  BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(mmOutStream));
                bw.write(buffer);
                */
                byte[]  buffers ={0};
                mmOutStream.write(buffers);
                if (mmSocket != null) {
                    mmOutStream.flush();
                }
                // Share the sent message back to the UI Activity
                mHandler.obtainMessage(Constants.MESSAGE_WRITE, -1, -1, buffer)
                        .sendToTarget();
            } 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);
            }
        }
    }
}
回复

使用道具 举报

7#
 楼主| asd9988775 发表于 2017-7-1 17:22 | 只看该作者
HC6800-ES-V2.0 发表于 2017-6-20 08:23
最近,有很多帖子问题串口通讯问题。你可以搜一搜,我都有回复。
其实,串口通讯没什么难搞的,要搞清楚几 ...

我回复的是我的安卓程序,我的开发板的晶振12Mhz的我改了TH1=0xF9;        。可是我发送0,在单片机上接收的却是0xc5, 0xf2, 0xef。
回复

使用道具 举报

8#
juewang 发表于 2018-5-28 16:37 | 只看该作者
asd9988775 发表于 2017-6-30 18:35
自己写的app。不太懂什么是通用的?我只是用android的蓝牙类写的程序

如果我的蓝牙模块要接收数据怎么办
回复

使用道具 举报

9#
roachwz 发表于 2019-4-28 15:33 | 只看该作者
楼主问题解决了吗?我最近也在做类似的
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|手机版|小黑屋|单片机论坛 |51黑电子论坛5群 联系QQ:125739409;技术交流QQ群174280738

Powered by 单片机教程网

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