蓝牙通讯单片机程序_单片机蓝牙通信程序 - CSDN
  • 蓝牙(Bluetooth):是一种无线技术标准,可实现固定设备、移动设备...蓝牙技术最初由电信巨头爱立信公司于1994年创制,当时是作为RS232数据线的替代方案, 蓝牙可连接多个设备,在与单片机连接使用也得到了广泛应用。

    蓝牙(Bluetooth):是一种无线技术标准,可实现固定设备、移动设备和楼宇个人域网之间的短距离数据交换(使用2.4—2.485GHz的ISM波段的UHF无线电波)。蓝牙技术最初由电信巨头爱立信公司于1994年创制,当时是作为RS232数据线的替代方案, 蓝牙可连接多个设备,在与单片机连接使用也得到了广泛应用。

    1、端口连接
    与单片机串口连接时,两者之间 相互可以读写。例如51给HC-05传递数据,即51向HC-05写数据,HC-05从51读取数据,那么串口连接处51的写端P3.1引脚(TXD)就与HC-05读端(RXD)相连,反之蓝牙向51传递数据时,HC-05写端(TXD)T与51的读端P3.0引脚(RXD)相连,所以通常为以下连接方式即可实现数据传送。
    注意:只有正确连接读写端才能正常通信。
    端口连接
    2、电平选择
    一般情况下,蓝牙不能正常工作的原因出在电源这得可能比较小,大多数蓝牙模块电压范围比较大,像HC-05蓝牙模块一般在3.3~6V,单片机电源都在这个范围内。不过不排除部分3.3V蓝牙,所以在连接电源前一定按照技术手册,连接正确电源,并保证正负极不能接反。
    3、蓝牙配置
    设置决定了蓝牙模块自动连接工作后的角色,主角色(Master)会自动搜索配对连接,从角色(Slave)只被动接受连接,不会主动搜索,回环角色(Loopback),属于被动连接,接收远程蓝牙主设备数据并将数据原样返回给远程蓝牙主设备。如果两个HC05模块要建立连接,其中一个必须设置为主角色,另外一个可以设置为从角色或回环角色,如果一个HC05模块和电脑蓝牙或者手机蓝牙通信,一般电脑或手机可以主动建立连接,所以HC05可以使用从角色,出厂默认也是设置为从角色的。
    4、AT指令
    在控制电平信号下,可以对蓝牙的一些特性参数进行查询课更改。
    AT+XXX? //查询参数XXX
    AT+XXX=mmm //设置参数XXX为mmm
    例如: 命令: AT+NAME?\r\n //查询蓝牙名称
    返回:+NAME:ChunyuY19 //蓝牙名称为:ChunyuY19
    命令: AT+NAME=Xidian\r\n //设置蓝牙名称为:Xidian
    返回: OK //返回提示符:OK
    命令: AT+PSWD?\r\n //查询蓝牙配对密码
    返回:+PSWD:1234 //配对密码为:1234
    命令: AT+ROLE?\r\n //查询蓝牙模式
    返回:+ROLE:0 //0:从角色,1:主角色,2:回环角色
    注意!!每行命令必须以更多AT命令\r\n结尾,更多的AT指令一般技术手册都会给出,活在网上查询。
    5、实现基于STC51单片机的蓝牙与手机通信
    首先,给单片机载入串口通信程序,注意!!一般下载程序时单片机与蓝牙断开,避免因蓝牙占用单片机串口导致程序无法烧写。载入程序后,按照上图给出的读写连接方式连接,并给给单片机及HC-05连接合适电源,一般都用单片机板子上电源。手机端需先在浏览器上搜索并下载“蓝牙串口调试助手”。
    上电后,蓝牙指示灯一般进入快闪状态,即等待蓝牙连接(从模式),用手机搜索并连接单片机上的蓝牙,配对密码默认为1234。配对成功就可以发送数据给蓝牙,如下图,至此基于STC51单片机的蓝牙与手机通信成功。

    因为毕业设计需要用到无线传输,第一次接触蓝牙串口通信,芯片用的HC-05。调试了一天,复制了不少例程,一直无解认为是程序问题。直到看到这篇文章才发现自己引脚就接错了……
    一定记住单片机TX接蓝牙RX,单片机RX接蓝牙TX。一定记住单片机TX接蓝牙RX,单片机RX接蓝牙TX。一定记住单片机TX接蓝牙RX,单片机RX接蓝牙TX。重要的事说三次。

    附基于STM32的HC-05串口通信框架代码

    #include "stm32f10x.h"    
    #include "stm32f10x_rcc.h"    
    #include "stm32f10x_gpio.h"    
    #include "stm32f10x_usart.h"   
    #include "stm32f10x_crc.h"  
    #include "system_stm32f10x.h"   
    #include "stdio.h"   
      
    #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)  
      
    void RCC_Configuration(void);    
    void GPIO_Configuration(void);   
    void USART_Configuration(void);   
    void delay_ms(u16 time);  
    void UART_PutChar(USART_TypeDef* USARTx, uint8_t Data);  
    void UART_PutStr (USART_TypeDef* USARTx, uint8_t *str);
    int Putchar(int c);
      
    int main()  
    {  
        SystemInit();  
        RCC_Configuration();    
        GPIO_Configuration();     
        USART_Configuration();
    		GPIO_SetBits(GPIOB,GPIO_Pin_5);		
        while(1)  
        {  
          UART_PutStr(USART1, "hello world!"); 
    			delay_ms(1000);			
        }   
          
    }  
    void RCC_Configuration(void)      
    {       
      RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO|RCC_APB2Periph_GPIOB,ENABLE);       
    }     
        
    void GPIO_Configuration(void)      
    {      
      GPIO_InitTypeDef GPIO_InitStructure;      
          
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;    
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;                
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;           
      GPIO_Init(GPIOA, &GPIO_InitStructure);                
          
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;           
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;        
      GPIO_Init(GPIOA, &GPIO_InitStructure);                 
           
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;  
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;    
      GPIO_Init(GPIOB, &GPIO_InitStructure);     
    }  
    void USART_Configuration(void)
    {    
           
        USART_InitTypeDef USART_InitStructure;                   
      
        USART_InitStructure.USART_BaudRate = 9600;                    
        USART_InitStructure.USART_WordLength = USART_WordLength_8b;   
        USART_InitStructure.USART_StopBits = USART_StopBits_1;       
        USART_InitStructure.USART_Parity = USART_Parity_No;        
        USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; 
        USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;   
        USART_Init(USART1,&USART_InitStructure);                    
        USART_Cmd(USART1,ENABLE);    
    }  
    void delay_ms(u16 time)       
    {      
      u16 i=0;      
      while(time--)       
      {      
        i=12000;      
        while(i--);      
      }      
    }   
    int Putchar(int c)                                             
    {    
        if (c == '\n'){putchar('\r');}                                
        USART_SendData(USART1,c);                                  
    		while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET){};
        return c;                                                       
    }   
    void UART_PutChar(USART_TypeDef* USARTx, uint8_t Data)  
    {  
        USART_SendData(USARTx, Data);  
        while(USART_GetFlagStatus(USARTx, USART_FLAG_TC) == RESET){}  
    }  
    void UART_PutStr (USART_TypeDef* USARTx, uint8_t *str)    
    {    
        while (0 != *str)    
        {    
            UART_PutChar(USARTx, *str);    
            str++; 		
        }    
    }  
    
    

    程序员开源交流QQ群 792272915

    展开全文
  • 程序实现了51单片机蓝牙通信程序,并在适当地方做了注释
  • 51单片机蓝牙模块的串口51单片机蓝牙模块的串口通信C程序通信C程序
  • 工具包括淘宝上淘的stc单片机实验板一块,hc-06蓝牙模块一个,杜邦线,win7电脑一部,安卓手机一部,相关软件:单片机小精灵,串口通讯助手,keil以及单片机烧录软件,蓝牙通讯软件APP。软件基本上都是免安装直接...

    打算利用蓝牙芯片HC06实现手机和单片机之间的简单通信。工具包括淘宝上淘的stc单片机实验板一块,hc-06蓝牙模块一个,杜邦线,win7电脑一部,安卓手机一部,相关软件:单片机小精灵,串口通讯助手,keil以及单片机烧录软件,蓝牙通讯软件APP。软件基本上都是免安装直接运行的。

    工作流程简单总结下为以下3步:
    1.利用单片机小精灵软件,做好烧录程序,确定波特率应该设置为2400
    2.hc-06蓝牙模块进入AT模式,串口通讯助手成功将蓝牙模块波特率设置为2400
    3.将烧录程序通过keil编译成功后烧录至单片机实验板上,手机上安装好APP,设置完成后运行,确定成功。

    步骤(2)见


    https://blog.csdn.net/dok12/article/details/80152239
    步骤(3)见
    https://blog.csdn.net/dok12/article/details/801730

    本篇先介绍步骤1。工具,单片机小精灵软件,免安装,直接运行。

    打开单片机小精灵软件,选择串口波特率选项。必须选择好晶振和波特率。其他选项,c语言还是汇编,是否串口中断,波特率加倍,允许接收都自己决定。
    因为淘宝买到的单片机实验板是12M晶振,蓝牙模块的默认波特率是9600。所以一开始输入这两项数据。
    结果发现误差太大,必须修改。晶振改不了,只好改波特率了。
    修改波特率为2400后误差控制在千分之一点六,效果不错,得到了一个C语言的串口通信基本框架了。

    根据这个框架做了个C语言程序,目标是对单片机实现蓝牙通讯,实现不同的单片机流水灯效果,并且得到回复数字8。
    #include <reg51.h>
    unsigned char k;
    void InitUART(void)
    {
        TMOD = 0x20;
        SCON = 0x50;
        TH1 = 0xF3;
        TL1 = 0xF3;
        PCON = 0x00;
        EA = 1;
        ES = 1;
        TR1 = 1;
    }
    /*******延时函数*************/
    void delay(unsigned int i)
    {
        unsigned char j;
        for(i; i > 0; i--)   
            for(j = 255; j > 0; j--);
    }
    void main(void)
    {	k=0;
        InitUART();
    	while  (1){
    	if(k==1)
    	{P1=0xff;delay(500);P1=0x00;delay(500);}
    	else if (k==2)
    	{P1=0x01;delay(500);P1=0xfe;delay(500);}
    	else 
    	{P1=0x02;delay(500);P1=0xfd;delay(500);}
    	}
    }
    void SendOneByte(unsigned char c)
    {
        SBUF = c;
        while(!TI);
        TI = 0;
    }
    
    void UARTInterrupt(void) interrupt 4
    {
        if(RI)
        {
            RI = 0;
            //add your code here!
    		k++;
    		if(k>2)k=0;
    		SendOneByte(8);
        }
        else
            TI = 0;
    }
    
    
    




    展开全文
  • 蓝牙模块:HC05 ...蓝牙单片机接线: 5V–5V GND–GND TX–3.0 RX–3.1 第一次需要用常规方式将下方代码写入 main.c #include <reg52.h> #include “stc_isp_download.h” sbit LED = P0^0...

    在这里插入图片描述

    蓝牙模块:HC05
    波特率:9600
    校验位:无
    停止位:1

    HC05与电脑的蓝牙配对后生成传入传出两个COM口,使用传出COM口

    蓝牙与单片机接线:
    5V–5V
    GND–GND
    TX–3.0
    RX–3.1

    第一次需要用常规方式将下方代码写入

    main.c
    #include <reg52.h>
    #include “stc_isp_download.h”

    sbit LED = P0^0;

    void main()
    {
    Init_Iap_Download();
    LED = 1;
    while (1)
    {
    LED = 0;
    }
    }

    stc_isp_download.c
    #include “stc_isp_download.h”

    void Init_Iap_Download()
    {
    TMOD=0X20;
    SM0=0;
    SM1=1;
    REN=1;
    TH1=0XFD;
    TL1=0XFD; //波特率 9600
    TR1=1; //校验位 无
    EA=1; //停止位 1
    ES=1;
    }
    void Rceive()interrupt 4
    {
    unsigned char i=0;
    unsigned int j,k;

    if(TI==1)
    {
    	TI=0;
    }
    else
    {
    	RI=0;
    	i=SBUF;
    	if(i==Download_command)
    	{
    		for(j=1000;j>0;j--)
    		for(k=123;k>0;k--);
    		Iap_Download =0x60;
    	}
    }
    

    }

    stc_isp_download.h
    #ifndef stc_isp_download
    #define stc_isp_download

    #include <reg52.h>
    #define Download_command 0xf1 //功能码
    sfr Iap_Download=0xE7;//软复位地址
    void Init_Iap_Download();

    #endif

    展开全文
  • 之前两篇都是在说与手机的连接,连接方法,和主动配对连接,都是手机与手机的操作,做起来还是没问题的,但是最终的目的是与单片机蓝牙模块的通信。   下面是到目前为止尝试的与单片机通信方法,没有成功,但是...

    之前两篇都是在说与手机的连接,连接方法,和主动配对连接,都是手机与手机的操作,做起来还是没问题的,但是最终的目的是与单片机的蓝牙模块的通信。

     

    下面是到目前为止尝试的与单片机的通信方法,没有成功,但是从思路上来说没有问题,最大的问题是与单片机配对的时候,单片机的蓝牙模块的PIN配对码是写死的,固定为1234,

    而手机这边连接配对都是自动生成的PIN配对码,这种方式在手机与手机配对的时候是极为方便的,但是在这里与单片机连接却成了最大的问题,因为手机自动生成而且每次都不一样,所以没法与单片机蓝牙模块的1234相同也就没法陪对了。下面只是介绍的到目前为止我们的大题思路,具体代码很多,而且涉及到项目也就没有贴。

    如果关于上面的问题哪位同学有思路或者做过类似的项目还请指点。

     

    首先,如何开启蓝牙设备和设置可见时间:

    private void search() {
            BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
            if (!adapter.isEnabled()) {
                adapter.enable();
            }
            Intent enable = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
            enable.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 3600); //3600为蓝牙设备可见时间
             startActivity(enable);
            Intent searchIntent = new Intent(this, ComminuteActivity.class);
            startActivity(searchIntent);
        }


    正式开始与蓝牙模块进行通信

    public class ComminuteActivity extends Activity {
        private BluetoothReceiver receiver;
        private BluetoothAdapter bluetoothAdapter;
        private List<String> devices;
        private List<BluetoothDevice> deviceList;
        private Bluetooth client;
        private final String lockName = "YESYOU";
        private String message = "000001";
        private ListView listView;
    
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.search_layout);
    
            listView = (ListView) this.findViewById(R.id.list);
            deviceList = new ArrayList<BluetoothDevice>();
            devices = new ArrayList<String>();
            bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
            bluetoothAdapter.startDiscovery();
            IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
            receiver = new BluetoothReceiver();
            registerReceiver(receiver, filter);
    
            listView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
                @Override
                public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
                    setContentView(R.layout.connect_layout);
                    BluetoothDevice device = deviceList.get(position);
                    client = new Bluetooth(device, handler);
                    try {
                        client.connect(message);
                    } catch (Exception e) {
                        Log.e("TAG", e.toString());
                    }
                }
            });
        }
    
        @Override
        protected void onDestroy() {
            unregisterReceiver(receiver);
            super.onDestroy();
        }
    
        private final Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case Bluetooth.CONNECT_FAILED:
                        Toast.makeText(ComminuteActivity.this, "连接失败", Toast.LENGTH_LONG).show();
                        try {
                            client.connect(message);
                        } catch (Exception e) {
                            Log.e("TAG", e.toString());
                        }
                        break;
                    case Bluetooth.CONNECT_SUCCESS:
                        Toast.makeText(ComminuteActivity.this, "连接成功", Toast.LENGTH_LONG).show();
                        break;
                    case Bluetooth.READ_FAILED:
                        Toast.makeText(ComminuteActivity.this, "读取失败", Toast.LENGTH_LONG).show();
                        break;
                    case Bluetooth.WRITE_FAILED:
                        Toast.makeText(ComminuteActivity.this, "写入失败", Toast.LENGTH_LONG).show();
                        break;
                    case Bluetooth.DATA:
                        Toast.makeText(ComminuteActivity.this, msg.arg1 + "", Toast.LENGTH_LONG).show();
                        break;
                }
            }
        };
    
        private class BluetoothReceiver extends BroadcastReceiver {
            @Override
            public void onReceive(Context context, Intent intent) {
                String action = intent.getAction();
                if (BluetoothDevice.ACTION_FOUND.equals(action)) {
                    BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                    if (isLock(device)) {
                        devices.add(device.getName());
                    }
                    deviceList.add(device);
                }
                showDevices();
            }
        }
    
        private boolean isLock(BluetoothDevice device) {
            boolean isLockName = (device.getName()).equals(lockName);
            boolean isSingleDevice = devices.indexOf(device.getName()) == -1;
            return isLockName && isSingleDevice;
        }
    
        private void showDevices() {
            ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1,
                    devices);
            listView.setAdapter(adapter);
        }
    }

    这里需要提一下的是,startDiscovery()这个方法和它的返回值,它是一个异步方法,会对其他蓝牙设备进行搜索,持续时间为12秒。

    搜索过程其实是在System Service中进行,我们可以通过cancelDiscovery()方法来停止这个搜索。在系统搜索蓝牙设备的过程中,系统可能会发送以下三个广播:ACTION_DISCOVERY_START(开始搜索),

    ACTION_DISCOVERY_FINISHED(搜索结束)

    和ACTION_FOUND(找到设备)。

    ACTION_FOUND这个才是我们想要的,这个Intent中包含两个extra fields:    EXTRA_DEVICE和EXTRA_CLASS,

    包含的分别是BluetoothDevice和BluetoothClass

    EXTRA_DEVICE中的BluetoothDevice就是我们搜索到的设备对象,从中获得设备的名称和地址。

    EXTRA_CLASS中的BluetoothClass是搜索到的设备的类型,比如搜索到的是手机还是耳机或者其他,之后我会写一篇关于它的介绍

    在这个上面我现在在想,是否通过判断搜索到的设备类型来识别单片机蓝牙模块与手机蓝牙的不同,采取不一样的配对方式,从而不自动生成配对码。不知是否可行,一会尝试。

     

     搜索到该设备后,我们就要对该设备进行连接和通信。

    public void connect(final String message) {
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    BluetoothSocket tmp = null;
                    Method method;
                    try {
                        method = device.getClass().getMethod("createRfcommSocket", new Class[]{int.class});
                        tmp = (BluetoothSocket) method.invoke(device, 1);
                    } catch (Exception e) {
                        setState(CONNECT_FAILED);
                        Log.e("TAG", e.toString());
                    }
                    socket = tmp;
                    try {
                        socket.connect();
                        isConnect = true;
                    } catch (Exception e) {
                        setState(CONNECT_FAILED);
                        Log.e("TAG", e.toString());
                    }
    	       if (isConnect) {
                        try {
                            OutputStream outStream = socket.getOutputStream();
                            outStream.write(getHexBytes(message));
                        } catch (IOException e) {
                            setState(WRITE_FAILED);
                            Log.e("TAG", e.toString());
                        }
                        try {
                            InputStream inputStream = socket.getInputStream();
                            int data;
                            while (true) {
                                try {
                                    data = inputStream.read();
                                    Message msg = handler.obtainMessage();
                                    msg.what = DATA;
                                    msg.arg1 = data;
                                    handler.sendMessage(msg);
                                } catch (IOException e) {
                                    setState(READ_FAILED);
                                    Log.e("TAG", e.toString());
                                    break;
                                }
                            }
                        } catch (IOException e) {
                            setState(WRITE_FAILED);
                            Log.e("TAG", e.toString());
                        }
                    }
    
                    if (socket != null) {
                        try {
                            socket.close();
                        } catch (IOException e) {
                            Log.e("TAG", e.toString());
                        }
                   }
           }
    }

     这里包括写入和读取,用法和基本的Socket是一样的,但是写入的时候,需要将字符串转化为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;
        }


     

    连接设备之前需要UUID,所谓的UUID,就是用来进行配对的,全称是Universally Unique Identifier,是一个128位的字符串ID,用于进行唯一标识。网上的例子,包括谷歌的例子提供的uuid,通用的"00001101-0000-1000-8000-00805F9B34FB"也试过了,在配对的时候都是自动生成了配对码,也无法正常与单片机的蓝牙模块连接,所以,我就利用反射的原理,让设备自己提供UUID尝试。到这里其实我有点怀疑自己对于UUID的理解是否正确了。

                在谷歌提供的例子中,我们可以看到谷歌的程序员的程序水平很高,一些好的编码习惯我们可以学习一下,像是在try..catch中才定义的变量,我们应该在try...catch之前声明一个临时变量,然后再在try...catch后赋值给我们真正要使用的变量。这种做法的好处就是:如果我们直接就是使用真正的变量,当出现异常的时候,该变量的使用就会出现问题,而且很难进行排查,如果是临时变量,我么可以通过检查变量的值来确定是否是赋值时出错。

       

    作者:jason0539

    微博:http://weibo.com/2553717707

    博客:http://blog.csdn.net/jason0539(转载请说明出处)

    展开全文
  •  手机端打开编写的蓝牙通信软件,与单片机蓝牙串口模块连接,而后,手机通过蓝牙发送读数据命令到单片机单片机开始读取传感器信息,将采集到得传感器信息通过蓝牙发送到手机端,手机端软件接收到后,显示。...

            概述:

               手机端打开编写的蓝牙通信软件,与单片机端蓝牙串口模块连接,而后,手机通过蓝牙发送读数据命令到单片机,单片机开始读取传感器信息,

    将采集到得传感器信息通过蓝牙发送到手机端,手机端软件接收到后,显示。

           整体图:

            

           

          焊接板图:

         



            本项目涉及四个部分。

       一、手机端软件

       二、单片机端编程

       三、外设电路设计

       四、手机与单片机通信

         下面对四个部分进一步叙述。

      1、手机端软件

          手机端软件为安卓软件,只需要编写一个普通的蓝牙串口调试软件即可。但在编写手机端按安卓软件时,我利用一年前做安卓手机通

    过蓝牙远程控制指纹识别器的源码改进,但却始终不能接收到蓝牙串口模块发送的数据。也就是说,手机可以给下位机发送信息,下位机成功接收,

    但是却接收不到下位机上传的信息。我很是疑惑,我以为是蓝牙串口模块的问题,于是换了一个,结果还是一样。我一直坚信去年的源码没有问题,

    但是却查不出原因在哪里。于是,我在相应的安卓蓝牙编程的书本上,找到讲解蓝牙部分的章节,按照步骤重新编写带代码,结果双向通信可以调通。

    先前的问题正在研究之中,下面是正常运行源码中的部分代码:

      (1)蓝牙连接代码

     //接收活动结果,响应startActivityForResult()
        public void onActivityResult(int requestCode, int resultCode, Intent data) {
        	switch(requestCode){
        	case REQUEST_CONNECT_DEVICE:     //连接结果,由DeviceListActivity设置返回
        		// 响应返回结果
                if (resultCode == Activity.RESULT_OK) {   //连接成功,由DeviceListActivity设置返回
                    // MAC地址,由DeviceListActivity设置返回
                    String address = data.getExtras()
                                         .getString(DeviceListActivity.EXTRA_DEVICE_ADDRESS);
                    // 得到蓝牙设备句柄      
                    _device = _bluetooth.getRemoteDevice(address);
     
                    // 用服务号得到socket
                    try{
                    	_socket = _device.createRfcommSocketToServiceRecord(UUID.fromString(MY_UUID));
                    }catch(IOException e){
                    	Toast.makeText(this, "连接失败!", Toast.LENGTH_SHORT).show();
                    }
                    //连接socket
                	Button btn = (Button) findViewById(R.id.Button03);
                    try{
                    	_socket.connect();
                    	Toast.makeText(this, "连接"+_device.getName()+"成功!", Toast.LENGTH_SHORT).show();
                    	btn.setText("断开");
                    }catch(IOException e){
                    	try{
                    		Toast.makeText(this, "连接失败!", Toast.LENGTH_SHORT).show();
                    		_socket.close();
                    		_socket = null;
                    	}catch(IOException ee){
                    		Toast.makeText(this, "连接失败!", Toast.LENGTH_SHORT).show();
                    	}
                    	
                    	return;
                    }
                    
                    //打开接收线程
                    try{
                		is = _socket.getInputStream();   //得到蓝牙数据输入流
                		}catch(IOException e){
                			Toast.makeText(this, "接收数据失败!", Toast.LENGTH_SHORT).show();
                			return;
                		}
                		if(bThread==false){
                			ReadThread.start();
                			bThread=true;
                		}else{
                			bRun = true;
                		}
                }
        		break;
        	default:break;
        	}
        }
        
    
     
    (2)手机蓝牙发送数据代码
     //发送数据线程
        public class SendThread extends Thread{
        	public void run(){
        		int i=0;
            	int n=0;
            	try{
            		OutputStream os = _socket.getOutputStream();   //蓝牙连接输出流
            		byte[] bos = edit0.getText().toString().getBytes();
            		for(i=0;i

      (3)手机蓝牙接收数据代码
    //接收数据线程
        Thread ReadThread=new Thread(){
        	
        	public void run(){
        		int num = 0;
        		byte[] buffer = new byte[1024];
        		byte[] buffer_new = new byte[1024];
        		int i = 0;
        		int n = 0;
        		bRun = true;
        		//接收线程
        		while(true){
        			try{
        				while(is.available()==0){
        					while(bRun == false){}
        				}
        				while(true){
        					num = is.read(buffer);         //读入数据
        					n=0;
        					
        					String s0 = new String(buffer,0,num);
        					fmsg+=s0;    //保存收到数据
        					for(i=0;i

       
      2、单片机端
           单片机采用Arduino开发板,因其简单易学。
           单片机端的代码比较简单,是一些对应的传感器采集数据代码和串口通讯代码。

      3、外设焊接。
        外设有两个传感器,一个蓝牙串口模块。
        蓝牙串口模块负责蓝牙通信,传感器负责采集信息。
       
      4、手机与单片机通信
        首先,约定一个命令 符,当单片机端接收到手机端发送的命令符时,即开始采集传感器信息,将采集到得信息进行加工,然后传给
    安卓手机。安卓手机接收数据后,随即显示出来。

       做成此项目用了三天时间,其中两天时间纠结与蓝牙单向通信问题,一直没有眉目。
    剩下一天用半天调通手机端蓝牙串口调试软件,半天焊接电路板,写Arduino端程序,连接布线等。



    展开全文
  • HC-05蓝牙串口通信模块应该是使用最广泛的一种蓝牙模块之一了。为什么呢? 因为HC05模块是一款高性能主从一体蓝牙串口模块,可以不用知道太多蓝牙相关知识就可以很好的上手。说白了,只是个蓝牙转串口的设备,你...
  • 不久前开始学习使用蓝牙模块,在模块与51单片机连接的过程中出现了非常多的问题,我想应该也是很多新手和我一样会遇到这样的问题,因此特地写这篇文章,想分享下在学习过程中遇到的问题以及解决方法。此次学习用到...
  • 通过蓝牙通讯 使用手机来控制 单片机 上 LED 灯的亮灭。 1)硬件使用 89c52 单片机 2)BT06 蓝牙模块 3) Android 手机一部 手机 —(蓝牙连接)—> BT06 ----(串口通信)–> 单片机 -----> LED 2.蓝牙模块 ...
  • 系列博文: (1)安卓手机与蓝牙模块联合调试(一)——蓝牙模块的串口...本教程的项目地址:1989Jiangtao/BluetoothSCM: 安卓手机通过蓝牙单片机通信-发送指令/接收数据​​​​​​​ 忙里偷闲,承接上一篇文...
  • 基于51单片机的HC-08蓝牙程序,初学51可以试做一下蓝牙遥控小车。
  • 要想使用HC-05蓝牙模块进行单片机之间通讯或者单片机蓝牙设备之间通讯,首先要配置好HC-05蓝牙模块的参数。设置好蓝牙的名称、密码、波特率等待。 step1: 连接usb转ttl模块和蓝牙模块,把两个模块的VCC口相连...
  •  微信小程序是一种新的应用,用户不需要下载应用只用通过扫二维码或者打开链接就能使用,使用完后不需要卸载,直接关闭就行了。微信在2017年初推出微信小程序开发环境。任何企业,媒体,个人都可以注册开发。是一种...
  • 文件中Readme文件有连线方式,压缩包含程序源码,用keil打开口按照...接线方式:本程序采用usart3与蓝牙进行通信蓝牙的RX引脚接usart3的TX,蓝牙的Tx接usart3的rx引脚,VCC接3.3V电源,KEY引脚接PA4,STATE引脚接PA15
  • 电路查了又查,单片机和app的程序改了又改,在第三点里连最简单的一个字符都收不到,前面两点进行长字符串传输毫无问题。现在求大神给个思路。 补充一下,第三点是APP能完美地收到字符,字符串,但是从手机蓝牙发...
  • 单片机或者在其他领域中,蓝牙的传输是比较重要的,虽然理论只有10米的范围可以传输数据,但是被许多开发者所需求,个人在开发中也是需要蓝牙传输,浏览了许多谷歌的APi文档和博客之后,决定好好写一篇关于蓝牙...
  • 一个简单的用蓝牙串口控制LED灯的亮灭,附加手机蓝牙串口助手。注意:这里单片机蓝牙模块接线时,TXD→TX,RXD→RX。
  • 蓝牙模块+51单片机可用手机蓝牙串口控制
  • 在51单片机的众多功能中串口通信占据了重要的地位,通过串口通信,我们可以实现51单片机与其他设备的互联,增加了学习的趣味性。 HC-05蓝牙模块为主从一体的蓝牙模块,并可与手机实现实时的通信。将单片机的串口...
1 2 3 4 5 ... 20
收藏数 1,965
精华内容 786
关键字:

蓝牙通讯单片机程序