精华内容
下载资源
问答
  • 前言上篇文章我们介绍到了开发...而且在6.0运行蓝牙,还需要加上获取到此刻的地理位置的权限,这是谷歌加的~~,所以我们先把运行的权限弄好先,再扫描设备、连接设备双向通讯。权限问题(兼容安卓6.0及以上)很多小伙

    前言


    上篇文章我们介绍到了开发经典蓝牙和单片机通讯的过程,安卓通讯之《蓝牙单片机通讯助手》①集成工作 ,我们这里还要兼容最新的安卓6.0及以上的系统,因为从6.0以后的权限机制和以往的不一样,我们需要在代码中向用户询问权限。而且在6.0运行蓝牙,还需要加上获取到此刻的地理位置的权限,这是谷歌加的~~,所以我们先把运行的权限弄好先,再扫描设备、连接设备和双向通讯。


    权限问题(兼容安卓6.0及以上)


    很多小伙伴问我,为什么你以前写的安卓高版本的蓝牙App现在在高版本的安卓机就不可以获取到附近的蓝牙设备啦?这也是我上面提到的:在6.0运行蓝牙,还需要加上获取到此刻的地理位置的权限。所以我们先把权限弄好。我下面是用郭神封装好的权限代码。你们如有不懂,去CSDN搜索郭霖6.0就有当天的直播权限封装视频解说。


    private void checkpermission() {
            //判断是否APi等于或大于23,即6.0
            if(Build.VERSION.SDK_INT >= 23){
                //所需要的权限加进去
                requestRuntimePermission(new String[]{Manifest.permission.ACCESS_COARSE_LOCATION
                        ,Manifest.permission.ACCESS_FINE_LOCATION
                        ,Manifest.permission.BLUETOOTH
                        ,Manifest.permission.BLUETOOTH_ADMIN}, new PermissionListener() {
    
                    //权限回调
                    @Override
                    public void onGranted() {
                        //全部都授权就跳转下个Activity
                        Log.i("权限全部都同意了","-----=="); 
                                               }
                      //某个没有被授权则强制退出程序
                    @Override
                    public void onDenied(List<String> deniedPermission) {
                        for(String persmission:deniedPermission){
                            Toast.makeText(SplashActivity.this,"基于你的安卓版本大于6.0,未授予该权限导致不能运行,强制退出:"+persmission,Toast.LENGTH_LONG).show();
    
                        } }
                });
            }else {
                //手机在6.0以下,则不需要获取到地理位置权限,直接跳过
           }
        }

    打开蓝牙扫描工作


    打开蓝牙工作,相信大家都会,用户在此打开蓝牙的是否,要用 intent回调。在这里,我们还需要写进一个蓝牙广播接收器,来监听系统发出来的已经搜索到的附近蓝牙设备,并且获取该数据的名字和蓝牙地址。


    代码部分说明:

    我这里用的是一个listVIew控件来展示当前可以连接的蓝牙设备。点击某一项,则把该项的蓝牙名字和id传下去到一个Activity的通讯工作。中间的是一个进度条之类的,自定义控件。


    扫描

    package com.example.xuhong.bluetoothassistant_master;
    
    import android.app.Activity;
    import android.app.ListActivity;
    import android.bluetooth.BluetoothAdapter;
    import android.bluetooth.BluetoothDevice;
    import android.content.BroadcastReceiver;
    import android.content.Context;
    import android.content.Intent;
    import android.content.IntentFilter;
    import android.os.Bundle;
    import android.os.Handler;
    import android.os.Handler.Callback;
    import android.os.Message;
    import android.os.Process;
    import android.util.Log;
    import android.view.View;
    import android.widget.ListView;
    import android.widget.TextView;
    
    import com.example.xuhong.bluetoothassistant_master.adapter.DeviceListAdapter;
    import com.example.xuhong.bluetoothassistant_master.ui.WhorlView;
    
    
    public class DeviceScanActivity extends ListActivity {
    
        private TextView mtv_show;
        // 调试用
        private static final String TAG = "DeviceScanActivity";
    
        // 开启蓝牙请求码
        private static final int REQUEST_ENABLE = 0;
    
        // 停止扫描蓝牙消息头
        private static final int WHAT_CANCEL_DISCOVERY = 1;
    
        // 判断蓝牙列表
        private static final int WHAT_DEVICE_UPDATE = 2;
    
        // 扫描间隔时间
        private static final int SCAN_PERIOD = 30 * 1000;
    
        //实例化Adapter
        private DeviceListAdapter mLeDeviceListAdapter = null;
    
         // 蓝牙适配器
        private BluetoothAdapter mBluetoothAdapter = null;
    
         // 进度条
        private WhorlView mWhorlView = null;
    
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_device_scan);
            init();
        }
    
        @Override
        protected void onStart() {
            super.onStart();
            mLeDeviceListAdapter = new DeviceListAdapter(this);
            // 设置列表适配器,注:调用此方法必须继承ListActivity
            setListAdapter(mLeDeviceListAdapter);
            scanDevice(true);
            mWhorlView.setVisibility(View.VISIBLE);
        }
    
        @Override
        protected void onPause() {
            scanDevice(false);
            super.onPause();
        }
    
        @Override
        protected void onDestroy() {
            unregReceiver();
            super.onDestroy();
        }
    
    
        //回调函数
        @Override
        protected void onActivityResult(int requestCode, int resultCode, Intent data) {
            if ( resultCode == Activity.RESULT_CANCELED) {
                finish();
                Process.killProcess(Process.myPid());
            }
    
            switch (requestCode){
                case REQUEST_ENABLE:
                    if ( mBluetoothAdapter.isEnabled()) {
                        registerReceiver();
                        scanDevice(true);
                    }
    
                    break;
    
            }
        }
    
        @Override
        protected void onListItemClick(ListView l, View v, int position, long id) {
            super.onListItemClick(l, v, position, id);
    
            BluetoothDevice device = mLeDeviceListAdapter.getDevice(position);
    
            if (device == null) {
                return;
            }
    
            Intent intent = new Intent(this, MainActivity.class);
            Bundle bundle = new Bundle();
            bundle.putParcelable("device", device);
            intent.putExtras(bundle);
    
            scanDevice(false);
            startActivity(intent);
            finish();
        }
    
        /**
         * 消息处理者
         */
        private Handler mHandler = new Handler(new Callback() {
    
            @Override
            public boolean handleMessage(Message msg) {
                switch (msg.what) {
    
                case WHAT_DEVICE_UPDATE:
                    mLeDeviceListAdapter.addDevice((BluetoothDevice) msg.obj);
                    // 刷新列表
                    mLeDeviceListAdapter.notifyDataSetChanged();
                    break;
    
                case WHAT_CANCEL_DISCOVERY:
                    mWhorlView.setVisibility(View.GONE);
                    mtv_show.setText("搜索完毕!");
                    break;
                    default:
                    break;
                }
                return false;
            }
        });
    
        /**
         * 初始化
         */
        private void init() {
            mtv_show= (TextView) findViewById(R.id.tv_show);
            mWhorlView = (WhorlView) findViewById(R.id.whorl_view);
            // 开启动画
            mWhorlView.start();
    
            // 初始化本地蓝牙设备
            mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
    
            // 检测蓝牙设备是否开启,如果未开启,发起Intent并回调
            if (mBluetoothAdapter == null || !mBluetoothAdapter.isEnabled()) {
                Intent enableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
                startActivityForResult(enableIntent, REQUEST_ENABLE);
            }
    
            registerReceiver();
        }
    
        /**
         * 是否扫描蓝牙设备
         */
        private void scanDevice(boolean enable) {
            if (enable) {
    
                Log.d(TAG, "[1]--> startDiscovery()");
    
                // 开启扫描
                mBluetoothAdapter.startDiscovery();
    
                // 延时30s后取消扫描动作
                mHandler.postDelayed(new Runnable() {
    
                    @Override
                    public void run() {
                        mBluetoothAdapter.cancelDiscovery();
    
                        Log.d(TAG, "[2]--> cancelDiscovery()");
    
                        // 发送消息
                        mHandler.sendEmptyMessage(WHAT_CANCEL_DISCOVERY);
                    }
                }, SCAN_PERIOD);
            } else {
                Log.d(TAG, "[3]--> cancelDiscovery()");
                // 停止扫描
                mBluetoothAdapter.cancelDiscovery();
            }
        }
    
        /**
         * 注册广播接收器
         */
        private void registerReceiver() {
            registerReceiver(mReceiver, new IntentFilter(BluetoothDevice.ACTION_FOUND));
        }
    
        /**
         * 注销广播接收器
         */
        private void unregReceiver() {
            if (mReceiver != null) {
                unregisterReceiver(mReceiver);
            }
        }
    
        /**
         * 广播接收器接收返回的蓝牙信息
         */
        private BroadcastReceiver mReceiver = new BroadcastReceiver() {
    
            @Override
            public void onReceive(Context context, Intent intent) {
                String action = intent.getAction();
    
                //未配对的设备
                if (BluetoothDevice.ACTION_FOUND == action) {
    
                        BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
    
                    Log.d(TAG, "[4] --> " + device.getName() + "------" + device.getAddress());
    
                    if (device != null) {
                        //发送消息
                        mHandler.sendMessage(mHandler.obtainMessage(WHAT_DEVICE_UPDATE, device));
                    }
                }
            }
        };
    }


    通讯工作


    我这里用的是一个spinner控件和一个button,怎么使用去看看相关博文,我这里只是供用户选择发送到哪一个数据。因为单片机通讯都是基本的 十六进制 0x00格式,所以我这里只是规范下发送的格式,你们也可以完全按照自己的想法设计UI。


    通讯工作


    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.UUID;
    
    import android.app.AlertDialog;
    import android.content.DialogInterface;
    import android.os.Bundle;
    import android.app.Activity;
    import android.bluetooth.BluetoothDevice;
    import android.bluetooth.BluetoothSocket;
    
    import android.os.Handler;
    import android.os.Message;
    import android.util.Log;
    
    import android.view.KeyEvent;
    import android.view.View;
    import android.view.Window;
    import android.view.WindowManager;
    import android.widget.AdapterView;
    import android.widget.ArrayAdapter;
    import android.widget.ImageView;
    import android.widget.ListView;
    import android.widget.Spinner;
    import android.widget.ToggleButton;
    
    import com.example.xuhong.bluetoothassistant_master.adapter.ChatListAdapter;
    import com.example.xuhong.bluetoothassistant_master.data.ChatListData;
    import com.example.xuhong.bluetoothassistant_master.util.Toaster;
    
    // 2016.09.15.   徐宏 编写
    public class MainActivity extends Activity  {
    
    
        private ListView mChatListView;
    
        //列表
        private List<ChatListData> mList = new ArrayList<>();
    
        private ChatListAdapter chatListAdapter;
    
        private static final String TAG = "MainActivity";
        // uuid
        private static final String SPP_UUID = "00001101-0000-1000-8000-00805F9B34FB";
    
        private Spinner mSpinner;
    
        private String[] data = new String[]{"选择 0x01", "选择 0x02", "选择 0x03", "选择       0x04", "选择 0x05", "选择 0x06", "选择 0x07" , "选择 0x08", "选择 0x09"};
    
    
        private Byte sendData = null;
        private String mRecieve =null;
    
        private ArrayAdapter<String>  adapter;
        //获得系统的适配器
        private BluetoothDevice mBluetoothDevice = null;
        //创建socket
        private BluetoothSocket mSocket = null;
        //io流
        private OutputStream mOutS = null;
        private static  final  int CONNECT_SUCCED =10;
        private static final  int  mRecieve_SUCCED = 20;
        private InputStream input  =null;
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            //全屏显示
            requestWindowFeature(Window.FEATURE_NO_TITLE);
            getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
            setContentView(R.layout.activity_main);
            initview();
        }
    
        private void initview() {
            mSpinner = (Spinner) findViewById(R.id.mSpinner);
            mChatListView = (ListView)findViewById(R.id.mChatListView);
    
            chatListAdapter=new ChatListAdapter(MainActivity.this,mList);
            mChatListView.setAdapter(chatListAdapter);
    
    
            adapter= new ArrayAdapter<String>(this,android.R.layout.simple_list_item_1,data);
            mSpinner.setAdapter(adapter);
            mSpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
                @Override
                public void onItemSelected(AdapterView<?> adapterView, View view, int id, long l) {
                    switch (id){
                        case 0:
                            sendData=1;
                            Log.i(TAG,"点击0");
                            break;
                        case 1:
                            sendData=2;
                            Log.i(TAG,"点击1");
                            break;
                        case 2:
                            sendData=3;
                            Log.i(TAG,"点击2");
                            break;
                        case 3:
                            sendData=4;
                            Log.i(TAG,"点击3");
                            break;
                        case 4:
                            sendData=5;
                            Log.i(TAG,"点击4");
                            break;
                        case 5:
                            sendData=6;
                            Log.i(TAG,"点击5");
                            break;
                        case 6:
                            sendData=7;
                            Log.i(TAG,"点击6");
                            break;
                        case 7:
                            sendData=8;
                            Log.i(TAG,"点击7");
                            break;
                        case 8:
                            sendData=9;
                            Log.i(TAG,"点击8");
                            break;
    
                    }
                }
    
                @Override
                public void onNothingSelected(AdapterView<?> adapterView) {
    
                }
            });
        }
    
        //添加右边文本
        private void addRightItem(String text) {
            ChatListData date = new ChatListData();
            date.setType(ChatListAdapter.VALUE_RIGHT_TEXT);
            date.setText(text);
            mList.add(date);
            //通知adapter刷新
            adapter.notifyDataSetChanged();
            //滚动到底部
            mChatListView.setSelection(mChatListView.getBottom());
        }
    
    
        //添加左边文本
        private void addLeftItem(String text) {
            ChatListData date = new ChatListData();
            date.setType(ChatListAdapter.VALUE_LEFT_TEXT);
            date.setText(text);
            mList.add(date);
            //通知adapter刷新
            adapter.notifyDataSetChanged();
            //滚动到底部
            mChatListView.setSelection(mChatListView.getBottom());
        }
    
    
        public void btn_send(View v){
            writeStream(sendData);
            addRightItem(sendData+"");
        }
    
        @Override
        protected void onStart() {
            super.onStart();
            initDevice();
        }
    
    
        @Override
        protected void onStop() {
            close();
            super.onStop();
        }
    
        private void initDevice() {
            Bundle bundle = getIntent().getExtras();
            if (bundle != null) {
                mBluetoothDevice = bundle.getParcelable("device");
                if (mBluetoothDevice != null) {
                    new Thread(mConnRun).start();
                }
            }
        }
    
        private Runnable mConnRun = new Runnable() {
    
            @Override
            public void run() {
                connect();
            }
        };
        private void connect() {
    
            UUID uuid = UUID.fromString(SPP_UUID);
    
            try {
                mSocket = mBluetoothDevice.createRfcommSocketToServiceRecord(uuid);
            } catch (IOException e) {
                if (mSocket != null) {
                    try {
                        mSocket.close();
                    } catch (IOException e1) {
                        Log.e(TAG, e1.getMessage());
                    }
                }
            }
    
            try {
                mSocket.connect();
            } catch (IOException e) {
                if (mSocket != null) {
                    try {
                        mSocket.close();
                    } catch (IOException e1) {
                        Log.e(TAG, e1.getMessage());
                    }
                }
            }
    
            try {
                mOutS = mSocket.getOutputStream();
                input=mSocket.getInputStream();
                handler.sendEmptyMessage(CONNECT_SUCCED);
            } catch (IOException e) {
                if (mOutS != null) {
                    try {
                        mOutS.close();
                    } catch (IOException e1) {
                        Log.e(TAG, e.getMessage());
                    }
                }
    
                if (mSocket != null) {
                    try {
                        mSocket.close();
                    } catch (IOException e1) {
                        Log.e(TAG, e.getMessage());
                    }
                }
            }
        }
    
    
        private void close() {
            if (mOutS != null) {
                try {
                    mOutS.close();
                } catch (IOException e) {
                    Log.e(TAG, e.getMessage());
                }
            }
    
            if (mSocket != null) {
                try {
                    mSocket.close();
                } catch (IOException e) {
                    Log.e(TAG, e.getMessage());
                }
            }
        }
    
    
        private void writeStream(byte data) {
            try {
                if (mOutS != null) {
                    mOutS.write(data);
                    Log.i(TAG,"输出---->>>是:"+data);
                    mOutS.flush();
                }
            } catch (IOException e) {
    
                runOnUiThread(new Runnable() {
    
                    @Override
                    public void run() {
                        Toaster.shortToastShow(MainActivity.this, "连接超时");
                        MainActivity.this.finish();
                    }
                });
            }
        }
    
    
        public Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
    
                switch (msg.what) {
                    case 1:
                        break;
                    case  mRecieve_SUCCED:
                        addLeftItem(mRecieve);
                        break;
                    case CONNECT_SUCCED:
                        Log.i(TAG,"接收成功");
                         new MyThread().start(); //开启下面的线程
                        break;
    
                }
            }
        };
    
    //新开的一个接收的线程
        class MyThread extends Thread{
            @Override
            public void run() {
                while (true){
                try {
                  //获取到的数据
                    int read = input.read();
                    //因为不允许在子线程更新UI所以用handler
                     handler.sendEmptyMessage(mRecieve_SUCCED);
                     Log.i(TAG+"数据是",Integer.toHexString(read));
                    } catch (IOException e) {
                        e.printStackTrace();
                    Log.i(TAG,"异常"+e);
                    }
    
                }}
    
            }
    
    
    
    
        @Override
        public boolean onKeyDown(int keyCode, KeyEvent event) {
    
            if(keyCode== KeyEvent.KEYCODE_BACK){
                AlertDialog.Builder alertDialog=new AlertDialog.Builder(MainActivity.this);
                alertDialog.setTitle("确认!");
                alertDialog.setMessage("        确定退出智能锁控制吗");
                alertDialog.setPositiveButton("否",new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface arg0, int arg1) {
    
                    }
                });
                alertDialog.setNegativeButton("是", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface arg0, int arg1) {
    
                        MainActivity.this.finish();
                    }
                });
                alertDialog.show();
            }
            return false;
        }
    
    }

    运行效果:

    这里写图片描述


    完美通讯~~

    展开全文
  • RS232实现串口双向通讯

    千次阅读 2017-05-17 10:50:42
    之前对接了一个pos机设备设备使用了RS232进行通讯,现在也完成该需求并在线上运行使用当中了,此次对接实现的功能主要是应用程序向POS机设备发送应收金额和收费时间;至此想记录一下开发过程中遇到的问题以及解决...

    之前对接了一个pos机设备,设备使用了RS232进行通讯,现在也完成该需求并在线上运行使用当中了,此次对接实现的功能主要是应用程序向POS机设备发送应收金额和收费时间;至此想记录一下开发过程。

    一、首先,POS机设备一旦上电则会处于接收以及发送数据的状态;下面的代码片段是打开串口并写数据的一个过程:

           //设置参数
            String port=portname;
            String rate = "115200";
            String dataBit = ""+SerialPort.DATABITS_8;
            String stopBit = ""+SerialPort.STOPBITS_1;
            String parity = ""+SerialPort.PARITY_NONE;
            int parityInt = SerialPort.PARITY_NONE;
            params.put( SerialReader.PARAMS_PORT, port ); // 端口名称
            params.put( SerialReader.PARAMS_RATE, rate ); // 波特率
            params.put( SerialReader.PARAMS_DATABITS,dataBit  ); // 数据位
            params.put( SerialReader.PARAMS_STOPBITS, stopBit ); // 停止位
            params.put( SerialReader.PARAMS_PARITY, parityInt ); // 无奇偶校验
            params.put( SerialReader.PARAMS_TIMEOUT,100 ); // 设备超时时间 1秒
            params.put( SerialReader.PARAMS_DELAY, 100 ); // 端口数据准备时间 1秒

            //打开串口通道并加入端口监听事件
            portId = CommPortIdentifier.getPortIdentifier( port );
            serialPort = ( SerialPort ) portId.open( "SerialReader", timeout );
            serialPort.addEventListener( this );
            serialPort.notifyOnDataAvailable( true );
            serialPort.setSerialPortParams( rate, dataBits, stopBits, parity );

            //往串口写数据
            outputStream = serialPort.getOutputStream();
            outputStream.write(bytes3); //往串口发送数据,是双向通讯的。
            outputStream.flush();
            outputStream.close();

    二、下面是端口监听的实现代码片段

     private static byte[] readBuffer = new byte[1024]; // 4k的buffer空间,缓存串口读入的数据
     public void serialEvent( SerialPortEvent event )
        {
            try
            {
                Thread.sleep( delayRead );
            }
            catch ( InterruptedException e )
            {
            	LoggerUtil.error(this.getClass(), e, e.getMessage());
                e.printStackTrace();
            }
            switch ( event.getEventType() )
            {
                case SerialPortEvent.BI: // 10
                case SerialPortEvent.OE: // 7
                case SerialPortEvent.FE: // 9
                case SerialPortEvent.PE: // 8
                case SerialPortEvent.CD: // 6
                case SerialPortEvent.CTS: // 3
                case SerialPortEvent.DSR: // 4
                case SerialPortEvent.RI: // 5
                case SerialPortEvent.OUTPUT_BUFFER_EMPTY: // 2
                    break;
                case SerialPortEvent.DATA_AVAILABLE: // 1
                    try
                    {
                        // 多次读取,将所有数据读入
                         while (inputStream.available() > 0) {
                         numBytes = inputStream.read(readBuffer);
                         }
    
                         //打印接收到的字节数据的ASCII码
                         for(int i=0;i<numBytes;i++){
                        	 System.out.println("msg[" + numBytes + "]: [" +readBuffer[i] + "]:"+(char)readBuffer[i]);
                         }
    //                    numBytes = inputStream.read( readBuffer );
                    }
                    catch ( IOException e )
                    {
                    	LoggerUtil.error(this.getClass(), e, e.getMessage());
                        e.printStackTrace();
                    }
                    break;
            }
        }

    上面一中的writebytes是应用程序往POS机发送的数据;二中的readBuffer是接收POS发送过来的数据;而这些发送和接收的数据都是根据程序与POS机之间的协议而形成的。

    在这里就先不记录pos协议方面的内容了;有需要交流的就在下面留言吧。












    展开全文
  • 命名管道双向通讯linux 命名管道克服了匿名管道的局限性 1)命名管道是在文件系统中作为一个特殊的设备文件而存在的。 2)不同祖先的进程之间可以通过管道共享数据。 3)当共享管道的进程执行完所有的I/O操作...

    命名管道双向通讯linux

    命名管道克服了匿名管道的局限性
    1)命名管道是在文件系统中作为一个特殊的设备文件而存在的。
    2)不同祖先的进程之间可以通过管道共享数据。
    3)当共享管道的进程执行完所有的I/O操作以后,命名管道将继续保存在文件系统中以便以后使用。
    4)管道只能由相关进程使用,它们共同的祖先进程创建了管道。但是,通过FIFO,不相关的进程也能交换数据。

    命名管道用于不相关两个进程进行通讯

    1.process2.c
    在这里插入图片描述判断是否打开管道失败后,进入while循环,写入要打印的内容,并写入管道fd1。再从fd2管道读出内容(另一个进程发送的内容),并打印。在这里插入图片描述
    2.process1.c
    在这里插入图片描述
    以”只读“打开path1,以”只写”打开path2。在这里插入图片描述
    判断是否打开管道失败后,进入while循环,从fd1管道读出内容(另一个进程发送的内容),并打印。写入要打印的内容,并写入管道fd2。

    3. 通过gcc编译,链接,执行两个.c文件
    在这里插入图片描述
    4.执行效果
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 使用匿名管道双向通讯的方式,实现pc端和Android端通讯。 在处理 pc端和Android设备通讯时,经常需要处理一下输入命令和解析输出命令的情况,例如下图所示:实现效果完全类似于 使用cmd和ADB通讯的方式,当然首先...

    使用匿名管道双向通讯的方式,实现pc端和Android端通讯。

    在处理 pc端和Android设备通讯时,经常需要处理一下输入命令和解析输出命令的情况,例如下图所示:实现效果完全类似于

    使用cmd和ADB通讯的方式,当然首先要把ADB和相关文件拷贝到windows 系统的 windows目录下,源码:


    展开全文
  • IGT-SER智能网关模块,支持各种PLC、智能仪表、远程IO与数据库之间双向通讯,既可以读取设备的数据上报到SQL数据库,也可以从数据库查询数据后写入到设备; 网关安装在设备侧,随设备启动、停止,不会错过任何数据...
  • IGT-SER智能网关模块,支持各种PLC、智能仪表、远程IO与数据库之间双向通讯,既可以读取设备的数据上报到SQL数据库,也可以从数据库查询数据后写入到设备; 网关安装在设备侧,随设备启动、停止,不会错过任何数据,...
  • 服务器数据上报查询 SQLServer/MySQL数据库查询(SELECT)/上报(INSERT)...专用协议与主站设备双向数据通讯; PLC数据寄存器地址、数据类型可自由配置,支持有线网口/WIFI/4G通讯,无需二次开发。 PLC串口扩展/转...
  • IGT-DSER智能网关模块,支持各种PLC、智能仪表、远程IO与数据库之间双向通讯,既可以读取设备的数据上报到SQL数据库,也可以从数据库查询数据后写入到设备;数据库软件支持MySQL、SQLServer、PostgreSQL。相关软件和...
  • 智能网关IGT-DSER方便实现PLC与数据库之间的数据通讯,既可以... 以下是通过数据库智能网关IGT-DSER实现S7-1200的PLC与服务器数据库双向通讯,网关支持MySQL和SQLServer,这里选择的是SQLServer。 首先,数据库存...
  • 已把在1,000米内能作双向安全通话的激光通讯器的稳定双筒望远镜系统加以修改以供美帝海军使用。光束与可见图象以光学方法作惰性稳定,而不是用复杂的电子学或庞大的电机设备来稳定。八台光通讯器实验样机已交给海军...
  • 智能网关IGT-DSER方便实现PLC与数据库之间的数据通讯,既可以读取PLC的数据上报到数据库,也可以从数据库查询数据后写入到PLC的... 以下是通过数据库智能网关IGT-DSER实现S7-1200的PLC与服务器数据库双向通讯,网...
  • 智能网关IGT-DSER方便实现PLC与数据库之间的数据通讯,既可以读取PLC的数据上报到数据库,也可以从数据库查询数据后写入到PLC的寄存器;网关安装在设备侧,与设备同时起停,不担心数据丢失;网关也支持多服务器冗余...
  • 许多设备需要通过IO通讯交互数据,怎样才做到速度最快,通讯可靠,所用资源又少呢? 下面介绍一个我编写的通讯协议:  它没有1线,2线那样节省IO资源,但是它的通讯速度绝对最快,无需延时,且不用中断,还可以对等传输....
  • Sybase 提供的 MobiLink 同步服务器,实现了企业系统和远程设备之间进行增量式的、可伸缩的、双向的信息同步。它支持大量远程用户,支持多种后台数据库,各种通讯协议以及各类同步协议。
  • 打开和关闭,并以异步模式完成设备与主机应用程序的双向通讯过程,最后在Wave Panel 对该接口进行了编程实验.实验结果证明该接口的通用性较好,能够较好地实现HID 设备与主机应用程序的通讯功能.  0 引 言  HID...
  • eRPC 的默认的设计模型是简单的主从模式,也就是设备A上运行服务,另一个设备B主动发起请求调用A的服务,但在实际的应用中,我们需要双向的请求,也就是说设备A,设备B互为主从,两台设备上都会运行服务供对方调用。...
  • #科技V计划# 在嵌入式系统中,我们时常会使用到一些通讯。主要的通信方式主要包括以下几种:全双工,半双工,串行与并行通讯方式,同步和异步等。这几种方式也是嵌入式通讯的中需要掌握的几个特点。下面先介绍以下这...
  • IGT-DSER智能网关模块,支持各种PLC、智能仪表、远程IO与数据库之间双向通讯,既可以读取设备的数据上报到SQL数据库,也可以从数据库查询数据后写入到设备;数据库软件支持MySQL、SQLServer、PostgreSQL。相关软件和...
  • 串口服务器设备概述 串口服务器设备的作用是提供串口转以太网的功能,可以将RS232、RS485、RS422串口转换成TCP/IP的网络接口,保持RS232/RS485/RS422串口与TCP/IP网络接口的统计数据双向透明传输的功能。可以让串口...
  • 实现扫码服务器地址通讯中断设备解锁采用signalR双向异步通知中断 创建控制器 ChatController注入集线器上下文IHubContext public IActionResult Index(string name) { name = name ?? "demo1"; HubCon...
  • 串行通讯 一条信息的各位数据被逐位按顺序传送的... 串行通讯中,两个设备之间通过一对信号线进行通讯,其中一根为信号线,另外一根为信号地线,信号电流通过信号线到达目标设备,再经过信号地线返回,构成一个信号回
  • IGT-SER智能网关模块,支持各种PLC、智能仪表、远程IO与数据库之间双向通讯,既可以读取设备的数据上报到SQL数据库,也可以从数据库查询数据后写入到设备; 网关安装在设备侧,随设备启动、停止,不会错过任何数据,...
  • 医疗检验设备:日立7080的通讯接口说明,包括双向通讯说明。
  • RS-485通讯系统半双工通信模式目前安防领域使用率较高的是RS-485通讯系统。RS-485接口支持点对多点通信,半双工通信模式,由于485是半双工通信模式,就必须要解决数据流向问题,就像某条铁路可以双向通车,为了防止...
  • IIC通讯

    2021-04-19 13:31:17
    I2C 通讯协议(Inter-Integrated Circuit)是由Phiilps公司开发的,由于它引脚少,硬件实现简单,可扩展性强,不需要USART、CAN等通讯协议的外部收发设备,现在被广泛地使用在系统内多个集成电路(IC)间的通讯。...
  • I2C总线是一种简单、双向二线制同步串行总线。它只需要两根线即可在连接于总线上的器件之间传送信息。主器件用于启动总线传送数据,并产生时钟以开放传送的器件,此时任何被寻址的器件均被认为是从器件.在总线上主...
  • 串行通讯与并行通讯区别

    万次阅读 2010-12-22 21:46:00
    串行通讯 一条信息的各位数据被逐位按顺序传送的通讯方式称为串行通讯。串行通讯的特点是:数据位传送,传按位顺序进行,最少只需一根传输线即可完成,成本低但... 串行通讯中,两个设备之间通过一对信
  • 以完善的北斗卫星通讯定位系统、GPRS通信网络以及各种搭载传感器设备等技术平台为依托,具有测量风、温、湿、压等气象参数和采集海流、盐度、化学及其它所需的海洋水文参数,目标定位,紧急警情上报,信息发送,统计...
  • j2me手机蓝牙通讯

    2011-04-13 12:03:17
    实现手机与蓝牙设备间的通讯,可以实现双向传输。
  • YES-DE12A模块用于实现串口到以太网数据包的双向透明转发,模块内部完成协议转换,通过该模块,客户可以将物理设备连接到以太网网络上,从而实现物联网的控制与管理。主要功能及特点典型接线示意图:2.4G-DTU...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 458
精华内容 183
关键字:

双向通讯设备