单片机通信 手机android_单片机与android手机通信 - CSDN
  • android手机接收并波形图显示单片机通过蓝牙传输的传感器数据
  • 之前两篇都是在说与手机的连接,连接方法,和主动配对连接,都是手机手机的操作,做起来还是没问题的,但是最终的目的是与单片机的蓝牙模块的通信。   下面是到目前为止尝试的与单片机通信方法,没有成功,但是...

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

     

    下面是到目前为止尝试的与单片机的通信方法,没有成功,但是从思路上来说没有问题,最大的问题是与单片机配对的时候,单片机的蓝牙模块的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(转载请说明出处)

    展开全文
  • 实现Android手机通过蓝牙控制51单片机小车 #一、材料: 1.stc51单片机最小系统板(最好带上拉电阻); 2.HC-02蓝牙芯片; 3.蓝牙小车,带驱动; 4.充电宝; 5.Android手机及app; #二、硬件连接 1.把小车...

    基于51单片机与Android手机通信的android蓝牙小车

    (班门弄斧,请各位大神批评指正,烦请提出宝贵意见。)
    整车图片

    #一、材料:

    1.stc51单片机最小系统板(最好带上拉电阻);

    2.HC-02蓝牙芯片;

    3.减速电机,电机驱动;

    4.充电宝(感谢刘帆同学赞助的充电宝);

    5.车架是自己设计,3D打印出来的,打印件下载

    5.Android手机及app,APP下载

    部分零件

    减速电机

    二、硬件连接

    1.把小车电机驱动上的四根控制线接在单片机4个IO口上;

    2.把HC-02的rxd接在单片机的txd上,txd接在单片机的rxd上;

    3.把单片机、HC-02、小车电机驱动的电源线接在充电宝输出上;

    4.把码盘(用于测速)上的GND、VCC连上电源,输入连在51单片机的IO 口上;

    4.给单片机烧程序;

    5.打开Android手机扫描蓝牙,连接测试;

    6.手机控制小车。
    #三、调试过程及相关代码

    1.调试HC-02蓝牙芯片(买的时候店家会送调试程序及教程);

    2.调试单片机蓝牙通信;

    (1).扫描,连接,键盘模式。

    (2).右上角三点,设定IO模式,接收:hex字符串,发送:hex字符串。

    (3).配置键盘值(发送给蓝牙芯片的字符串就是这个);

    (4).前进(1A),长按(1A),释放(DD)

    (5).左转(1B),长按(1B),释放(DD)

    (6).后退(1F),长按(1F),释放(DD)

    (7).右转(1C),长按(1C),释放(DD)

    (8).刹车(DD),长按(DD),释放(DD)
    3.相关代码

    /*
    程序名称: 蓝牙手机遥控小车
    功能原理: 利用智能手机app连接HC-02蓝牙芯片实现蓝牙串口通信,
               利用stc51单片机控制电机驱动模块驱动小车 。
    扩展功能:循迹、避障等。
    */
    #include "reg52.h"    //此文件中定义了单片机的一些特殊功能寄存器
    #define time_0 5
    typedef unsigned int u16;	  //对数据类型进行声明定义
    typedef unsigned char u8;
    
    sbit output_date1=P2^7;
    sbit output_date2=P2^6;
    sbit output_date3=P2^5;
    sbit output_date4=P2^4;
    sbit STA=P1^0;
    
    #define GO_STAIGHT  {output_date1=1,output_date2=0,output_date3=1,output_date4=0;}	        //前进
    #define GO_BACK     {output_date1=0,output_date2=1,output_date3=0,output_date4=1;}			//后退
    #define TURN_RIGHT	{output_date1=0,output_date2=1,output_date3=1,output_date4=0;}		    //右转
    #define TURN_LEFT   {output_date1=1,output_date2=0,output_date3=0,output_date4=1;}		    //左转
    #define STOP_CAR    {output_date1=0,output_date2=0,output_date3=0,output_date4=0;}			//停车
    
    
    #define USART_MAX_RECV_LEN	40
    u8 USART_RX_BUF[USART_MAX_RECV_LEN];
    u16 USART_RX_STA=0; 
    
    void delay(u16 n);
    void UsartInit();
    void USART_SendData();
    
    
    
    void delay(u16 n)   //1ms   (误差 -0.651041666667us)
    {
       u16 i ;
        unsigned char a,b;
    	for(i=1;i<=n;i++)
    	{
        for(b=102;b>0;b--)
            for(a=3;a>0;a--);
    	}
    }
    
    
    void UsartInit()
    {
    	SCON=0X50;			//设置为工作方式1
    	TMOD=0X20;			//设置计数器工作方式2
    	PCON=0X80;			//波特率加倍
    	TH1=0XFa;			//计数器初始值设置,注意波特率是9600的
    	TL1=0XFa;
    	ES=1;						//打开接收中断
    	EA=1;						//打开总中断
    	TR1=1;					//打开计数器
    }
    
    void USART_SendData(u8 datbuf[])
    {
    	u8 i=0;
    	for(i=0;i<1;i++)
    	{
    		SBUF=datbuf[i];//将接收到的数据放入到发送寄存器
    		while(!TI);//等待发送数据完成
    		TI=0;//清除发送完成标志位	
    	}
    }
    
    
    void main()
    {	u8	date_get=0;
    	STA=0;
    	UsartInit();  //串口初始化
    
    	
    	while(1)
    	{
    		
    		date_get=USART_RX_BUF[0];
    		switch(date_get)
    		{
    			case 0x1B:				//左转
    					 		  
    					TURN_LEFT;		
    					USART_SendData(USART_RX_BUF);
    					 delay(time_0);
    
    					break;	
    			case 0x1A:				 //前进		  
    				    GO_STAIGHT;					
    					USART_SendData(USART_RX_BUF); 
    					delay(time_0);
    					break;
    			case 0x1F:				 //后退
    						  
    				    GO_BACK;
    					USART_SendData(USART_RX_BUF); 
    					delay(time_0);
    					break;
    			case 0x1C:				 //右转			  
    					TURN_RIGHT;
    					USART_SendData(USART_RX_BUF); 
    					delay(time_0);
    					break;
    			case 0xDD:
    							  //停
    					STOP_CAR;
    					USART_SendData(USART_RX_BUF); 
    					delay(time_0); 
    					STOP_CAR;
    				
    		}
    	            	STOP_CAR;  
    	}		
    }
    
    void Usart() interrupt 4		//串口中断
    {
    	u8 res;
    	res=SBUF;
    	USART_RX_BUF[0]=res;
        RI=0;//清除接收中断标志位	
    								 
    }
    
    
    展开全文
  • 刚好碰到这蓝牙通信方面的项目,上网也看过其他人在蓝牙这方面写的博客,但大多都不全,给一些初触蓝牙的开发者造成一定的麻烦,自己当初也费了不少劲。所以把自己参考网上的一些资料用Android studio写的代码完全放...

    刚好碰到这蓝牙通信方面的项目,上网也看过其他人在蓝牙这方面写的博客,但大多都不全,给一些初触蓝牙的开发者造成一定的麻烦,自己当初也费了不少劲。所以把自己参考网上的一些资料用Android studio写的代码完全放出来,分享一下。菜鸟初写博客,若有不恰之处,请指出,必改正。下面我会把自己的思路和代码一一呈现。(PS:由于后期做了些逻辑操作,代码可能有点臃肿,请勿怪。还好完整的代码是会有的,里面有多出来的一两个类没有用的,但懒得重新打包了)

    第一篇博客写完,感觉好菜。资源下载:http://download.csdn.net/detail/u013168302/9146907

    1.添加权限

    <uses-permission android:name="android.permission.BLUETOOTH"/>
    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>
    

    2.成员变量跟onCreate()方法,为了方便阅读,把这些摆出来

    public class PipelineActivity extends Activity {
        public static BluetoothSocket btSocket;
        private BluetoothAdapter bluetoothAdapter;
        private ArrayAdapter<String> deviceAdapter;
        private List<String> listDevices;
        private ListView listView;
        private LinearLayout btContent;
        private TextView btAllData;
        private Button openBT;
        private Button searchBT;
        final private static int MESSAGE_READ = 100;
        int i = 0;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.pipeline);
    
            listView = (ListView) this.findViewById(R.id.list);
            btContent = (LinearLayout) findViewById(R.id.bt_content_llt);
            btAllData = (TextView) findViewById(R.id.all_data);
            btAllData.setText(btAllData.getText(), TextView.BufferType.EDITABLE);//这行可实现TextView尾部追加http://blog.csdn.net/u013168302/article/details/48785927
    
            openBT = (Button) findViewById(R.id.open_btn);
            searchBT = (Button) findViewById(R.id.search_btn);
    
            listDevices = new ArrayList<String>();
            bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
            if (bluetoothAdapter.isEnabled()) {
                openBT.setText("关闭蓝牙");
            }
            deviceAdapter = new ArrayAdapter<String>(getApplicationContext(), R.layout.list_item, listDevices);
    
            openBT.setOnClickListener(new BTListener());
            searchBT.setOnClickListener(new BTListener());
    
            listView.setAdapter(deviceAdapter);
            listView.setOnItemClickListener(new ItemClickListener());//添加监听
        }
    


    3.注册广播(因为下面搜索时要用到,所以现在前面注册)

    private BroadcastReceiver receiver = new BroadcastReceiver() {
    
            public void onReceive(Context context, Intent intent) {
                String action = intent.getAction();
                
                //下面几行是为了在logcat里面看到搜索到的设备细节,需要的话,可以将注释打开
    //            Bundle b = intent.getExtras();
    //            Object[] lstName = b.keySet().toArray();
    //            // 显示所有收到的消息及其细节
    //            for (int i = 0; i < lstName.length; i++) {
    //                String keyName = lstName[i].toString();
    //                Log.e("-----" + keyName, String.valueOf(b.get(keyName)));
    //            }
                
                //搜索设备时,取得设备的MAC地址
                if (BluetoothDevice.ACTION_FOUND.equals(action)) {
                    BluetoothDevice device = intent
                            .getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                    String str = device.getName() + "|" + device.getAddress();
                    if (listDevices.indexOf(str) == -1)// 防止重复添加
                        listDevices.add(str); // 获取设备名称和mac地址
                    if (deviceAdapter != null) {
                        deviceAdapter.notifyDataSetChanged();
                    }
                }
            }
        };
    



    
    
    
    4.点击开启蓝牙,搜索蓝牙设备。 将搜索到设备名称和mac地址通过BroadcastReceiver保存到list集合,再在listview中展示
    

    /**
         * 蓝牙开启与搜索按钮点击监听
         */
        class BTListener implements View.OnClickListener {
            @Override
            public void onClick(View view) {
                if (view.getId() == R.id.open_btn) {
                    if (!bluetoothAdapter.isEnabled()) {
                        bluetoothAdapter.enable();//开启蓝牙
                        Intent enable = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
                        enable.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300); //300秒为蓝牙设备可见时间
                        startActivity(enable);
                        openBT.setText("关闭蓝牙");
    
                    } else {
                        bluetoothAdapter.disable();//关闭蓝牙
                        openBT.setText("开启蓝牙");
                        if (btSocket != null) {
                            try {
                                btSocket.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                } else if (view.getId() == R.id.search_btn) {
                    if (!bluetoothAdapter.isEnabled()) {
                        Toast.makeText(getApplicationContext(), "请先开启蓝牙", Toast.LENGTH_SHORT).show();
                    } else {
                        btContent.setVisibility(View.GONE);
                        listView.setVisibility(View.VISIBLE);
                        if (listDevices != null) {
                            listDevices.clear();
                            if (deviceAdapter != null) {
                                deviceAdapter.notifyDataSetChanged();
                            }
                        }
                        bluetoothAdapter.startDiscovery();
                        IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
                        registerReceiver(receiver, filter);
    
                    }
                }
            }
        }



    5.点击listview的item,通过反射连接设备。连接设备之前需要UUID来配对。查看网上的例子和自己的一些实践发现,通过UUID会出现一些问题,当然也有可能只是我自己的代码有问题。所以在此采取反射来获取蓝牙socket对象。

    /**
         * 蓝牙选项,listview列表点击监听
         */
        class ItemClickListener implements AdapterView.OnItemClickListener {
            @Override
            public void onItemClick(AdapterView<?> adapterView, View view, int position, long l) {
    
                if (!bluetoothAdapter.isEnabled()) {
                    Toast.makeText(getApplicationContext(), "请先开启蓝牙", Toast.LENGTH_SHORT).show();
                } else {
                    bluetoothAdapter.cancelDiscovery();//停止搜索
                    String str = listDevices.get(position);
                    String macAdress = str.split("\\|")[1];
    
                    BluetoothDevice device = bluetoothAdapter.getRemoteDevice(macAdress);
                    try {
                        Method clientMethod = device.getClass()
                                .getMethod("createRfcommSocket", new Class[]{int.class});
                        btSocket = (BluetoothSocket) clientMethod.invoke(device, 1);
                        connect(btSocket);//连接设备
    
                    } catch (NoSuchMethodException e) {
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    } catch (InvocationTargetException e) {
                        e.printStackTrace();
                    }
                }
            }
        }


    6.连接蓝牙设备,并开辟子线程通信

    在这里值得注意while里面的2行代码。这2行代码花了不少功夫才弄到的

    (1)if(inputStream.available() >0==false)

    (2)Thread.sleep(400);//等待0.4秒,作用:让数据接收完整
    这2行用于处理inputStream读取数据不完整或混乱的问题,但感觉还是不够好。若谁有更好的方法,欢迎提出。
    另外inputStream在这里是关不掉的,因为这是蓝牙通信,单片机每产生的数据都要传输到手机端。试过多次:一旦断开inputstream,while循环结束,单片机再次产生的数据无法传送。不知道我有没有弄错,欢迎指出。

    
    

     /**
         * 连接蓝牙及获取数据
         */
        public void connect(final BluetoothSocket btSocket) {
            try {
                btSocket.connect();//连接
                if (btSocket.isConnected()) {
                    Log.e("----connect--- :", "连接成功");
                    Toast.makeText(getApplicationContext(), "蓝牙连接成功", Toast.LENGTH_SHORT).show();
                    listView.setVisibility(View.GONE);
                    btContent.setVisibility(View.VISIBLE);
                    new ConnetThread().start();//通信
    
                } else {
                    Toast.makeText(getApplicationContext(), "蓝牙连接失败", Toast.LENGTH_SHORT).show();
                    btSocket.close();
                    listView.setVisibility(View.VISIBLE);
                    btContent.setVisibility(View.GONE);
                    Log.e("--------- :", "连接关闭");
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
    
        }
    
        /**
         * 蓝牙通信管理
         */
        private class ConnetThread extends Thread {
            public void run() {
                try {
                    InputStream inputStream = btSocket.getInputStream();
                    byte[] data = new byte[1024];
                    int len = 0;
                    String result = "";
    
                    while (len != -1) {
                        if (inputStream.available() > 0 == false) {//inputStream接收的数据是一段段的,如果不先
                            continue;
                        } else {
                            try {
                                Thread.sleep(500);//等待0.5秒,让数据接收完整
                                len = inputStream.read(data);
                                result = URLDecoder.decode(new String(data, "utf-8"));
    //                          Log.e("----result:----- :", ">>>" + result);
                                Message msg = new Message();
                                msg.what = MESSAGE_READ;
                                msg.obj = result;
                                handler.sendMessage(msg);
    
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                    inputStream.close();//关不了,也好像不能关
                    Log.e("--------- :", "关闭inputStream");
                    if (btSocket != null) {
                        btSocket.close();
                    }
                } catch (IOException e) {
                    Log.e("TAG", e.toString());
                }
            }
    
        }


    7.用Handler处理Message

    private Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case MESSAGE_READ:
                        String result = (String) msg.obj;
                        String data = result.split("\\r\\n")[0];
                        Log.e("----data:----- :", ">>>" + data);
                        if (i < 6) {
                            Editable text = (Editable) btAllData.getText();
                            text.append(data);
                            btAllData.setText(text + "\r\n");
                            i++;
                        } else {
                            btAllData.setText(data + "\r\n");
                            i = 0;
                        }
                        break;
                }
            }
        };
    
        @Override
        protected void onDestroy() {
            unregisterReceiver(receiver);
            super.onDestroy();
        }




    8.1布局文件(尚未优化)

    <LinearLayout 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:background="#000000"
        android:orientation="vertical"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        tools:context=".MainActivity">
    
        <TextView
            android:layout_width="match_parent"
            android:layout_height="60dp"
            android:background="#000000"
            android:gravity="center"
            android:paddingLeft="20dp"
            android:text="@string/pipeline"
            android:textColor="#ffffff"
            android:textSize="20sp" />
    
        <LinearLayout
            android:visibility="gone"
            android:id="@+id/bt_content_llt"
            android:layout_width="match_parent"
            android:layout_height="1dp"
            android:layout_weight="1"
            android:background="#ffffff"
            android:orientation="vertical">
    
            <LinearLayout style="@style/bt_llt_style"
                android:layout_weight="3">
    
                <TextView
                    style="@style/btTV_style"
                    android:gravity="left"
                    android:layout_weight="1"
                    android:paddingTop="20dp"
                    android:text="@string/all_data" />
    
                <TextView
                    android:id="@+id/all_data"
                    style="@style/btTV_style"
                    android:gravity="left"
                    android:paddingLeft="2dp"
                    android:paddingTop="20dp"
                    android:textSize="16sp"
                    android:layout_weight="2" />
    
            </LinearLayout>
    
        </LinearLayout>
    
        <ListView
            android:id="@+id/list"
            android:layout_width="match_parent"
            android:layout_height="1dp"
            android:layout_weight="1"
            android:background="#f0f0f0"
            android:divider="#c0c0c0"
            android:dividerHeight="1dp" />
    
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="40dp"
            android:layout_gravity="center"
            android:layout_marginTop="10dp"
            android:orientation="horizontal">
    
            <Button
                android:id="@+id/open_btn"
                style="@style/bt_button_style"
                android:text="@string/open_bluetooth" />
    
            <Button
                android:id="@+id/search_btn"
                style="@style/bt_button_style"
                android:text="@string/search_bluetooth" />
        </LinearLayout>
    
    </LinearLayout>
    


    8.2 item布局

    <?xml version="1.0" encoding="utf-8"?>
    <TextView xmlns:android="http://schemas.android.com/apk/res/android"
        android:id="@+id/device_name_tv"
        android:layout_width="match_parent"
        android:layout_height="50dp"
        android:paddingLeft="15dp"
        android:gravity="center|left"
        android:textColor="#000000"
        android:background="@drawable/list_item_selector"
        android:textSize="18sp">
    
    </TextView>
    

    8.3 资源文件strings.xml

    <resources>
        <string name="app_name">bluetooth</string>
    
        <string name="hello_world">Hello world!</string>
        <string name="action_settings">Settings</string>
      
        <string name="pipeline">管道检测仪</string>
        <string name="open_bluetooth">开启蓝牙</string>
        <string name="close_bluetooth">关闭蓝牙</string>
        <string name="search_bluetooth">搜索蓝牙</string>
        <string name="all_data">全部数据:</string>
        <color name="item_default">#F0F0F0</color>
        <color name="item_press">#A5D8F5</color>
    </resources>
    

    8.4 style

    <resources>
    
        <!-- Base application theme. -->
        <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
            <!-- Customize your theme here. -->
        </style>
    
        <style name="btTV_style">
            <item name="android:background">#ffffff</item>
            <item name="android:gravity">left|center</item>
            <item name="android:paddingLeft">10dp</item>
            <item name="android:paddingRight">10dp</item>
            <item name="android:textSize">20sp</item>
            <item name="android:layout_width">1dp</item>
            <item name="android:layout_height">match_parent</item>
        </style>
    
        <style name="bt_llt_style">
            <item name="android:layout_width">match_parent</item>
            <item name="android:layout_height">1dp</item>
            <item name="android:layout_weight">1</item>
            <item name="android:orientation">horizontal</item>
        </style>
    
        <style name="bt_button_style">
            <item name="android:layout_width">1dp</item>
            <item name="android:layout_height">match_parent</item>
            <item name="android:layout_marginLeft">20dp</item>
            <item name="android:layout_marginRight">20dp</item>
            <item name="android:layout_weight">1</item>
            <item name="android:background">#5CB85C</item>
        </style>
    
    </resources>
    


    8.5  listview的item选择器

    <?xml version="1.0" encoding="utf-8"?>
    <selector xmlns:android="http://schemas.android.com/apk/res/android">
    
        <!-- 选中 -->
        <item android:state_pressed="true" android:drawable="@color/item_press" />
        <!-- 默认 -->
        <item android:drawable="@color/item_default"/>
    
    </selector>








    展开全文
  • 就是手机收到其他设备发来的一个消息,然后手机就可以播放铃声,也就是事件触发
  •  手机端打开编写的蓝牙通信软件,与单片机端蓝牙串口模块连接,而后,手机通过蓝牙发送读数据命令到单片机单片机开始读取传感器信息,将采集到得传感器信息通过蓝牙发送到手机端,手机端软件接收到后,显示。...

            概述:

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

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

           整体图:

            

           

          焊接板图:

         



            本项目涉及四个部分。

       一、手机端软件

       二、单片机端编程

       三、外设电路设计

       四、手机与单片机通信

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

      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端程序,连接布线等。



    展开全文
  • 前言 本篇文章将围绕App与单片机的蓝牙通信来说说lz最近...单片机Android App的通信方案 环境 单片机 单片机:STC89C52 c语言 编写环境:Keil uVision4 烧录:stc-isp-15xx-v6.82 Android android sdk 16+

    源码传送门

    前言

    本篇文章将围绕App与单片机的蓝牙通信来说说lz最近进行开发的一些方案与思考
    此文分为三部分:

    • 单片机的PWM与串口通信
    • Android的蓝牙开发
    • 单片机与Android App的通信方案

    预览

    这里写图片描述
    这里写图片描述

    视频观看:

    http://v.youku.com/v_show/id_XMjQ5MTgyMTAwMA==.html

    环境

    单片机

    • 单片机:STC89C52
    • c语言
    • 编写环境:Keil uVision4
    • 烧录:stc-isp-15xx-v6.82

    Android

    • android sdk 16+
    • Android studio 1.0+

    单片机的PWM与串口通信

    PWM

    我相信PWM的概念大家都应该,如果还很模糊也可以去查查,可以看看这篇文章

    http://www.eepw.com.cn/article/275890.htm

    那么我们这里要说的,就是怎么通过程序去模拟pwm信号(有些单片机自带pwm处理,就无需写程序),从程序的方面讲,我们要模拟PWM,就是让高电平持续一小段时间,然后再让低电平持续一段时间,也就是改变占空比。
    那么再单片机中,这种关于频率的事情一般都是通过定时器来实现的,那么我的方案是这样的:
    设置一个全局变量t,PWM_T,每当定时器中断的时候使t自增1,当t等于100的时候,使之高电平,并让t等于0,当t等于PWM_T的时候,使之低电平,这样,我们就可以通过改变PWM_T的值来改变占空比,从而实现通过目标的电压,使之达到调节的效果(例如调节led灯的亮度,调节电机的速度等)

    /****************************************************
                   定时器0中断模拟PWM
                   调节led的亮度
    ****************************************************/
    int t = 0;
    int PWM_T = 0;   //占空比控制变
    void main()
    {
    	TMOD = 0x22;   //定时器0,工作模式2,8位定时模式
    	TH0=210;     //写入预置初值(取值1-255,数越大PWM频率越高)
    	TL0=210;     //写入预置值 (取值1-255,数越大PWM频率越高)
    	TR0=1;       //启动定时器
    	ET0=1;       //允许定时器0中断
    	EA=1;        //允许总中断
    	P1=0xff; 	 //初始化P1,输出端口
    	PWM_T=30;
    	while(1)      
    	{   	
    		if(!up)   //当up按键按下的时候
    		{
    			if(PWM_T<100)
    			{
    				PWM_T+=1;
    			}
    			delay_1ms(20);
    		}
    		if(!down)  //当down按键按下的时候
    		{
    			if(PWM_T>0)
    			{
    				PWM_T-=1;
    			}
    			delay_1ms(20);
    		}
    	 }  
    }
    
    timer0() interrupt 1  
    { 
    	t++;    //每次定时器溢出加1
    	if(t==100)   //PWM周期 100个单位
    	{
    		t=0;  //使t=0,开始新的PWM周期
    		P1=0x00;  //输出端口,使之低电平
    	} 
    	if(PWM_T==t)  //按照当前占空比切换输出为高电平
    	{  
    		P1=0xff;    //输出端口,使之高电平    
    	}
    }
    

    串口通信

    上面我们说了PWM调速,那么要达到app实时显示速度,就必须要单片机把速度传输给手机(在这里先用占空比模拟实时速度,道理是一样的,春节快递停了,测速模块还没到),那么我的首选方案肯定是单片机通过蓝牙串口发送给app,app接收并进行显示,这里我的蓝牙模块是hc-06。串口通信很容易,但在这个过程中我发现难的地方是数据格式的定义和数据的解析,也就是说要统一使用16进制,还是10进制,数据的头节点和尾节点的定义,或者说数据每一位所代表的参数,在这里先埋个伏笔,文章的后面会对我自己的方案进行介绍.

    Android蓝牙开发

    那么android为我们提供的关于蓝牙的api其实已经很强大了,通常的步骤为:

    1. 打开蓝牙
    2. 搜索蓝牙设备
    3. 进行配对
    4. 连接
    5. 数据的发送与接收

    开启蓝牙

    private BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
    /**
    * 打开蓝牙
    */
    public static void openBluetooth(@NonNull Activity activity) {
    	if (INSTANCE.bluetoothAdapter == null) {
                // 设备不支持蓝牙
                Toast.makeText(INSTANCE.context.getApplicationContext(), "您的设备似乎不支持蓝牙", Toast.LENGTH_SHORT).show();
                return;
    	}
    	Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
    	activity.startActivityForResult(enableBtIntent, 6);
    }
    
    /**
    * 关闭蓝牙
    */
    public static void closeBluetooth() {
    	if (INSTANCE.bluetoothAdapter != null) {
    		INSTANCE.bluetoothAdapter.disable();
    	}
    }
    
    /**
    * 判断蓝牙是否打开
    * @return boolean 蓝牙是否打开
    */
    public static boolean isBluetoothOpen() {
    	return INSTANCE.bluetoothAdapter != null && INSTANCE.bluetoothAdapter.isEnabled();
    }
    

    搜索附近的蓝牙设备

    那么搜索蓝牙设备当然也是调用系统的api即可,然后系统通过广播接收者的方式告诉你,我找到设备了,下面po出代码

    /**
    * 搜索蓝牙设备
    */
    public static void searchDevices() {
    	INSTANCE.bluetoothDevices.clear();
    	if (INSTANCE.bluetoothAdapter != null) {
    		// 寻找蓝牙设备,android会将查找到的设备以广播形式发出去
    		INSTANCE.bluetoothAdapter.startDiscovery();
    	}
    }
    

    下面是所要接收的广播

    
        /**
         * 初始化过滤器
         */
        private void initIntentFilter() {
            // 设置广播信息过滤
            IntentFilter intentFilter = new IntentFilter();
            //搜索到设备
            intentFilter.addAction(BluetoothDevice.ACTION_FOUND);
            intentFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_STARTED);
            intentFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
            //蓝牙状态改变
            intentFilter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
            //绑定状态改变
            intentFilter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
            // 注册广播接收器,接收并处理搜索结果
            registerReceiver(receiver, intentFilter);
        }
    

    那么当接收到广播的时候,只需调用BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)就可以取出对应的搜索的蓝牙设备

    蓝牙配对

     /**
         * 绑定设备
         *
         * @param device BluetoothDevice对象
         * @return 是否绑定成功
         */
        public static boolean bondDevice(BluetoothDevice device) {
            if (INSTANCE.bluetoothAdapter == null) {
                return false;
            }
            // 取消蓝牙设备搜索
            INSTANCE.bluetoothAdapter.cancelDiscovery();
            try {
                if (device.getBondState() == BluetoothDevice.BOND_NONE) {
                    // 设备未配对,进行配对操作
                    Method method = BluetoothDevice.class.getMethod("createBond");
                    method.invoke(device);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return false;
        }
    

    蓝牙连接

    	BluetoothSocket socket;
    	//获取一个uuid值
    	UUID uuid = uuidCandidates.get(candidate++);
    	//根据android不同sdk调用不同的api
    	if (secure) {
    		socket= device.createRfcommSocketToServiceRecord(uuid);
    	} else {
    		socket= device.createInsecureRfcommSocketToServiceRecord(uuid);
    	}
    

    数据的发送与接收

    参考了网上很多关于蓝牙数据通信的做法,好多都是每发送一次数据都关闭socket,但是那样我觉得并不好,因为socket的开启与关闭都是比较耗费资源的,那么我的方案是开启一个线程保持socket连接进行蓝牙数据的接收与发送。

    public class TouchMsgThread extends Thread {
        private  BluetoothSocket socket;
        private  InputStream inputStream;
        private  OutputStream outputStream;
        private  Handler handler;
        public TouchMsgThread(BluetoothSocket socket, Handler handler) {
            this.socket = socket;
            InputStream input = null;
            OutputStream output = null;
            this.handler = handler;
            try {
                input = socket.getInputStream();
                output = socket.getOutputStream();
            } catch (IOException e) {
                e.printStackTrace();
            }
            this.inputStream = input;
            this.outputStream = output;
        }
        public void run() {
            while (true) {
                try {
                    int count = 5;
                    byte[] bytes = new byte[count];
                    int readCount = 0; // 已经成功读取的字节的个数
    	              while (readCount < count) {
                        readCount += inputStream.read(bytes, readCount, count - readCount);
                   }
                    int s = BinaryToHexString(bytes);
                    Message message=handler.obtainMessage();
                    message.what = 333;
                    message.obj=s;
                    handler.sendMessage(message);
                } catch (Exception e) {
                    e.printStackTrace();
                    break;
                }
            }
        }
        public void write(byte[] bytes) {
            try {
                byte[] b = {-1,1,2,3,-1};
                outputStream.write(b);
                outputStream.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        public void cancel() {
            try {
                if(outputStream!=null){
                    outputStream.close();
                    outputStream = null;
                }
                if(inputStream!=null){
                    inputStream.close();
                    inputStream = null;
                }
                //socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //数据的检验,这里暂时先忽略
        public static int BinaryToHexString(byte[] bytes) {
            int result = 0;
            String temp = "";
            for(int i=0;i<5;i++){
                byte b = bytes[i];
                if(i==2){
                    temp = Integer.toHexString((b & 0xff));
                }
                if(i==3){
                    String hex = Integer.toHexString((b & 0xff));
                    result = Integer.parseInt(temp+hex, 16);
                }
            }
            return result;
        }
    }
    

    单片机与Android的通信方案

    制定协议

    那么上面我们已经讲了单片机与Android怎么样通过蓝牙进行信息交互了,但是在实际应用中,二者之间传递的信息类型太多了,比如实时速度,电量,还有车子灯光打开,或者修改车子密码等等信息,那么单片机或者app要怎么去判断传递过来的是哪种信息呢?那么我们就必须去制定一套数据协议,这里看看我的方案,协议规定:

    包头 类型位 数据位 数据位 结束位
    0xFF 0x** 0x** 0x** 0xFF

    那么我们的数据位可以分别代表高二位和低二位,那么通常情况下这种方案就可以满足我们的需求了。举个例子:

    类型位 数据位 数据位 功能
    0X00 0X02 0X00 前进
    0X00 0X01 0X00 后退
    0X00 0X03 0X00 左转
    0X00 0X04 0X00 右转
    0X00 0X00 0X00 停止
    0X02 0x00 0X01 车灯亮
    0X02 0x00 0X02 车灯灭
    0X03 雷达数据高位 雷达数据低位 发送雷达数据

    协议的解析

    未完待续

    展开全文
  • 先简单说说情景:软件需要给硬件设备的单片机发送一串byte数组,用于打开软件与硬件设备之间的通讯通道,软件命令发送完,接着就打开一个线程用于接收从硬件设备回传的数据,然后开始做其他的一些操作。但是现在出现...
  • 最近辛辛苦苦的终于把落下了七八个月的Android蓝牙开发搞完了,其中的痛苦不堪回首啊。感谢那些帮了大忙的老师和同学们!辛苦归辛苦,收获总是有的,...而单片机上的蓝牙模块与手机蓝牙连接有点不同,它的UUID号需要
  • Android手机wifi连接控制单片机发送数据简单测试demo(Socket通信简单应用测试)。
  • Android app实现与单片机的TCP通信 一、main activity layout layout 截图如上 二、main activity.java (一)需要用到的相关知识 1、socket 2、handler 3、onClickListener 4、Thread (二)主要代码实现 ...
  • 手机是安卓系统的,蓝牙模块采用hc-06,单片机用msp430f149.具体要求是手机发数据能通过蓝牙模块传给单片机然后做出相应的反应(如控制LED的亮灭等)。
  • STC89C52通过HC-06蓝牙模块与Android手机通信   如需转载请标明出处:http://blog.csdn.net/itas109  QQ技术交流群:129518033  2017-11-04补充 注意问题: 1.确保上位机波特率为9600 2.确保下位机的波特...
  • 1.单片机发的是ASCII码,手机这边收的是
  • 3、单片机TxD RxD+蓝牙模块RxD TxD与手机蓝牙 只能收不能发 电路查了又查,单片机和app的程序改了又改,在第三点里连最简单的一个字符都收不到,前面两点进行长字符串传输毫无问题。现在求大神给个思路。 补充一下...
  • android 使用串口Modbus协议和单片机进行通信  我所使用的232串口,使用485串口的请慎重,这232串口和485还是不一样的,这里所说的是232串口通信。 首先你需要导入架包和一些必要文件,在最后会附上图片和源码,...
  • 《安卓与单片机进行usb hid通信》https://blog.csdn.net/Alone_1314/article/details/70242396 百度经验里的: 《android如何支持hid设备》https://jingyan.baidu.com/article/6b182309f19265ba58e159b7.html .....
1 2 3 4 5 ... 20
收藏数 2,670
精华内容 1,068
关键字:

单片机通信 手机android