关于OrangePI 串口通讯解决方案
Posted jiang-tao
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了关于OrangePI 串口通讯解决方案相关的知识，希望对你有一定的参考价值。
前段时间因为需要做一个物联网项目，需要使用到OrangePi, 定下里的方案是使用gpio通讯，但是发现香橙派没有通用的gpio驱动，所以只得这种选择串口通信。网上找了一波，使用RS232+USB通信是最便宜的解决方案，驱动的话使用开源库UsbSerial。也有之前Google 维护的库，但我觉着不好用。所以在这里献丑写上一篇博客。
导入
添加jitpack仓库到你的build.gradle文件
allprojects {
repositories {
jcenter()
maven { url "https://jitpack.io" }
}
}添加依赖到你的app中
compile ‘com.github.felHR85:UsbSerial:4.5.2‘设备支持
CP210X devices Default: 9600,8,1,None,flow off
CDC devices Default 115200,8,1,None,flow off
FTDI devices Default: 9600,8,1,None,flow off
PL2303 devices Default 9600,8,1,None,flow off
CH34x devices Default 9600,8,1,None,flow off
使用
- 新建Service
public class UsbService extends Service {
public static final String ACTION_USB_READY = "com.felhr.connectivityservices.USB_READY";
public static final String ACTION_USB_ATTACHED = "android.hardware.usb.action.USB_DEVICE_ATTACHED";
public static final String ACTION_USB_DETACHED = "android.hardware.usb.action.USB_DEVICE_DETACHED";
public static final String ACTION_USB_NOT_SUPPORTED = "com.felhr.usbservice.USB_NOT_SUPPORTED";
public static final String ACTION_NO_USB = "com.felhr.usbservice.NO_USB";
public static final String ACTION_USB_PERMISSION_GRANTED = "com.felhr.usbservice.USB_PERMISSION_GRANTED";
public static final String ACTION_USB_PERMISSION_NOT_GRANTED = "com.felhr.usbservice.USB_PERMISSION_NOT_GRANTED";
public static final String ACTION_USB_DISCONNECTED = "com.felhr.usbservice.USB_DISCONNECTED";
public static final String ACTION_CDC_DRIVER_NOT_WORKING = "com.felhr.connectivityservices.ACTION_CDC_DRIVER_NOT_WORKING";
public static final String ACTION_USB_DEVICE_NOT_WORKING = "com.felhr.connectivityservices.ACTION_USB_DEVICE_NOT_WORKING";
public static final int MESSAGE_FROM_SERIAL_PORT = 0;
public static final int CTS_CHANGE = 1;
public static final int DSR_CHANGE = 2;
public static final int SYNC_READ = 3;
public static final String ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION";
private static final int BAUD_RATE = 9600; // BaudRate. Change this value if you need
public static boolean SERVICE_CONNECTED = false;
private IBinder binder = new UsbBinder();
private Context context;
private Handler mHandler;
private UsbManager usbManager;
private UsbDevice device;
private UsbDeviceConnection connection;
private UsbSerialDevice serialPort;
private boolean serialPortConnected;
/*
* Data received from serial port will be received here.
* byte stream is converted to String and send to UI thread to
* be treated there.
*/
private UsbSerialInterface.UsbReadCallback mCallback = new UsbSerialInterface.UsbReadCallback() {
@Override
public void onReceivedData(byte[] arg0) {
Timber.e(arg0 + "-------接收数据");
try {
String data = new String(arg0, "UTF-8");
// 上传数据到服务器
if (mHandler != null)
mHandler.obtainMessage(MESSAGE_FROM_SERIAL_PORT, data).sendToTarget();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
};
/*
* State changes in the CTS line will be received here
* 电梯主板发送数据请求
*/
private UsbSerialInterface.UsbCTSCallback ctsCallback = new UsbSerialInterface.UsbCTSCallback() {
@Override
public void onCTSChanged(boolean state) {
if (mHandler != null)
mHandler.obtainMessage(CTS_CHANGE).sendToTarget();
}
};
/*
* State changes in the DSR line will be received here
* 发送请求命令到香橙派
*/
private UsbSerialInterface.UsbDSRCallback dsrCallback = new UsbSerialInterface.UsbDSRCallback() {
@Override
public void onDSRChanged(boolean state) {
if (mHandler != null)
mHandler.obtainMessage(DSR_CHANGE).sendToTarget();
}
};
/*
* Different notifications from OS will be received here (USB attached, detached, permission responses...)
* About BroadcastReceiver: http://developer.android.com/reference/android/content/BroadcastReceiver.html
*/
private final BroadcastReceiver usbReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context arg0, Intent arg1) {
switch (Objects.requireNonNull(arg1.getAction())) {
case ACTION_USB_PERMISSION:
boolean granted = Objects.requireNonNull(arg1.getExtras()).getBoolean(UsbManager.EXTRA_PERMISSION_GRANTED);
if (granted) // User accepted our USB connection. Try to open the device as a serial port
{
Intent intent = new Intent(ACTION_USB_PERMISSION_GRANTED);
arg0.sendBroadcast(intent);
connection = usbManager.openDevice(device);
new ConnectionThread().start();
} else // User not accepted our USB connection. Send an Intent to the Main Activity
{
Intent intent = new Intent(ACTION_USB_PERMISSION_NOT_GRANTED);
arg0.sendBroadcast(intent);
}
break;
case ACTION_USB_ATTACHED:
if (!serialPortConnected)
findSerialPortDevice(); // A USB device has been attached. Try to open it as a Serial port
break;
case ACTION_USB_DETACHED:
// Usb device was disconnected. send an intent to the Main Activity
Intent intent = new Intent(ACTION_USB_DISCONNECTED);
arg0.sendBroadcast(intent);
if (serialPortConnected) {
serialPort.syncClose();
}
serialPortConnected = false;
break;
}
}
};
/*
* onCreate will be executed when service is started. It configures an IntentFilter to listen for
* incoming Intents (USB ATTACHED, USB DETACHED...) and it tries to open a serial port.
*/
@Override
public void onCreate() {
this.context = this;
serialPortConnected = false;
UsbService.SERVICE_CONNECTED = true;
setFilter();
usbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
findSerialPortDevice();
EventBus.getDefault().register(this);
}
/* MUST READ about services
* http://developer.android.com/guide/components/services.html
* http://developer.android.com/guide/components/bound-services.html
*/
@Override
public IBinder onBind(Intent intent) {
return binder;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
return Service.START_NOT_STICKY;
}
@Override
public void onDestroy() {
super.onDestroy();
UsbService.SERVICE_CONNECTED = false;
EventBus.getDefault().unregister(this);
}
/*
* 写数据到电梯主板
*/
public void write(byte[] data, int timeout) {
if (serialPort != null) {
serialPort.syncWrite(data,timeout);
}
}
/*
* 改变波特率
*/
public void changeBaudRate(int baudRate) {
if (serialPort != null)
serialPort.setBaudRate(baudRate);
}
public void setHandler(Handler mHandler) {
this.mHandler = mHandler;
}
private void findSerialPortDevice() {
// This snippet will try to open the first encountered usb device connected, excluding usb root hubs
HashMap<String, UsbDevice> usbDevices = usbManager.getDeviceList();
if (!usbDevices.isEmpty()) {
boolean keep = true;
for (Map.Entry<String, UsbDevice> entry : usbDevices.entrySet()) {
device = entry.getValue();
int deviceVID = device.getVendorId();
int devicePID = device.getProductId();
Timber.e("VendorId: " + deviceVID + "-----devicePID: " + devicePID);
if (deviceVID != 0x1d6b && (devicePID != 0x0001 && devicePID != 0x0002 && devicePID != 0x0003)) {
// There is a device connected to our Android device. Try to open it as a Serial Port.
Timber.e("请求权限...");
requestUserPermission();
keep = false;
} else {
Timber.e("取消挂载设备...");
connection = null;
device = null;
}
if (!keep)
break;
}
if (!keep) {
// There is no USB devices connected (but usb host were listed). Send an intent to MainActivity.
Intent intent = new Intent(ACTION_NO_USB);
sendBroadcast(intent);
}
} else {
// There is no USB devices connected. Send an intent to MainActivity
Intent intent = new Intent(ACTION_NO_USB);
sendBroadcast(intent);
}
}
private void setFilter() {
IntentFilter filter = new IntentFilter();
filter.addAction(ACTION_USB_PERMISSION);
filter.addAction(ACTION_USB_DETACHED);
filter.addAction(ACTION_USB_ATTACHED);
registerReceiver(usbReceiver, filter);
}
/*
* 请求权限
*/
private void requestUserPermission() {
PendingIntent
mPendingIntent = PendingIntent.getBroadcast(this, 0, new Intent(ACTION_USB_PERMISSION), 0);
usbManager.requestPermission(device, mPendingIntent);
}
public class UsbBinder extends Binder {
public UsbService getService() {
return UsbService.this;
}
}
/*
* 单线程打开usb串口
* Although it should be a fast operation. moving usb operations away from UI thread is a good thing.
*/
private class ConnectionThread extends Thread {
@Override
public void run() {
Timber.e("准备打开端口...");
serialPort = UsbSerialDevice.createUsbSerialDevice(device, connection);
if (serialPort != null) {
Timber.e("serialPort获取成功...");
if (serialPort.syncOpen()) {
Timber.e("serialPort打开成功...");
serialPortConnected = true;
serialPort.setBaudRate(BAUD_RATE);
serialPort.setDataBits(UsbSerialInterface.DATA_BITS_8);
serialPort.setStopBits(UsbSerialInterface.STOP_BITS_1);
serialPort.setParity(UsbSerialInterface.PARITY_NONE);
/**
* Current flow control Options:
* UsbSerialInterface.FLOW_CONTROL_OFF
* UsbSerialInterface.FLOW_CONTROL_RTS_CTS only for CP2102 and FT232
* UsbSerialInterface.FLOW_CONTROL_DSR_DTR only for CP2102 and FT232
*/
serialPort.setFlowControl(UsbSerialInterface.FLOW_CONTROL_OFF);
serialPort.read(mCallback);
serialPort.getCTS(ctsCallback);
serialPort.getDSR(dsrCallback);
// new ReadThread().start();
Intent intent = new Intent(ACTION_USB_READY);
context.sendBroadcast(intent);
} else {
// Serial port could not be opened, maybe an I/O error or if CDC driver was chosen, it does not really fit
// Send an Intent to Main Activity
if (serialPort instanceof CDCSerialDevice) {
Intent intent = new Intent(ACTION_CDC_DRIVER_NOT_WORKING);
context.sendBroadcast(intent);
} else {
Intent intent = new Intent(ACTION_USB_DEVICE_NOT_WORKING);
context.sendBroadcast(intent);
}
}
} else {
// No driver for given device, even generic CDC driver could not be loaded
Intent intent = new Intent(ACTION_USB_NOT_SUPPORTED);
context.sendBroadcast(intent);
}
}
}
/**
* 开线程读取数据
*/
private class ReadThread extends Thread {
@Override
public void run() {
while (true) {
byte[] buffer = new byte[100];
int n = serialPort.syncRead(buffer, 0);
if (n > 0) {
byte[] received = new byte[n];
System.arraycopy(buffer, 0, received, 0, n);
Timber.e("妈的智障--------" + Arrays.toString(received));
String receivedStr = new String(received);
Bundle bundle = new Bundle();
bundle.putByteArray("bytes", received);
if (mHandler != null) {
Message message = mHandler.obtainMessage(SYNC_READ, receivedStr);
message.setData(bundle);
message.sendToTarget();
}
}
}
}
}
}
- 开启服务并进行通信
private UsbService usbService;
private MyHandler mHandler;
private String mStatus = Command.STATUS_INIT;
private Disposable mLoginDispose;
private Disposable m111Dispose;
private final ServiceConnection usbConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName arg0, IBinder arg1) {
usbService = ((UsbService.UsbBinder) arg1).getService();
usbService.setHandler(mHandler);
usbService.changeBaudRate(9600);
}
@Override
public void onServiceDisconnected(ComponentName arg0) {
usbService = null;
}
};
/*
* 当前USB状态...
*/
private final BroadcastReceiver mUsbReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
Timber.d("USB连接过程数据: " + intent.getDataString());
switch (Objects.requireNonNull(intent.getAction())) {
// USB PERMISSION GRANTED
case UsbService.ACTION_USB_PERMISSION_GRANTED:
Timber.d("USB准备完成....");
Toast.makeText(context, "USB Ready", Toast.LENGTH_SHORT).show();
//登录
mStatus = Command.STATUS_INIT;
mLoginDispose = null;
m111Dispose = null;
EventBus.getDefault().post(new CycleReadEvent());
break;
case UsbService.ACTION_USB_PERMISSION_NOT_GRANTED:
Timber.d("USB没有授权....");
Toast.makeText(context, "USB Permission not granted", Toast.LENGTH_SHORT).show();
break;
case UsbService.ACTION_NO_USB:
Timber.d("没有USB连接....");
Toast.makeText(context, "No USB connected", Toast.LENGTH_SHORT).show();
break;
case UsbService.ACTION_USB_DISCONNECTED:
Timber.d("USB断开连接.....");
Toast.makeText(context, "USB disconnected", Toast.LENGTH_SHORT).show();
break;
case UsbService.ACTION_USB_NOT_SUPPORTED:
Timber.d("USB设备不支持.....");
Toast.makeText(context, "USB device not supported", Toast.LENGTH_SHORT).show();
break;
}
}
};
/*
* 从USB中拿到的数据
* 在此处读数据
*/
public class MyHandler extends Handler {
private final WeakReference<CallActivity> mActivity;
MyHandler(CallActivity activity) {
mActivity = new WeakReference<>(activity);
}
@Override
public void handleMessage(android.os.Message msg) {
switch (msg.what) {
case UsbService.MESSAGE_FROM_SERIAL_PORT:
byte[] data = (byte[]) msg.obj;
Timber.e("MESSAGE_FROM_SERIAL_PORT-接收到数据：" + Arrays.toString(data));
break;
case UsbService.CTS_CHANGE:
Toast.makeText(mActivity.get(), "CTS_CHANGE", Toast.LENGTH_LONG).show();
break;
case UsbService.DSR_CHANGE:
Toast.makeText(mActivity.get(), "DSR_CHANGE", Toast.LENGTH_LONG).show();
break;
case UsbService.SYNC_READ:
byte[] buffer1 = msg.getData().getByteArray("bytes");
Timber.e("SYNC_READ-接收到数据：" + Arrays.toString(buffer1));
Timber.e("SYNC_READ-接收到数据：" + msg.obj);
dealReadData(buffer1);
break;
}
}
}
};
private void startService(Class<?> service, ServiceConnection serviceConnection, Bundle extras) {
if (!UsbService.SERVICE_CONNECTED) {
Intent startService = new Intent(this, service);
if (extras != null && !extras.isEmpty()) {
Set<String> keys = extras.keySet();
for (String key : keys) {
String extra = extras.getString(key);
startService.putExtra(key, extra);
}
}
startService(startService);
}
Intent bindingIntent = new Intent(this, service);
bindService(bindingIntent, serviceConnection, Context.BIND_AUTO_CREATE);
}
private void setFilters() {
IntentFilter filter = new IntentFilter();
filter.addAction(UsbService.ACTION_USB_PERMISSION_GRANTED);
filter.addAction(UsbService.ACTION_NO_USB);
filter.addAction(UsbService.ACTION_USB_DISCONNECTED);
filter.addAction(UsbService.ACTION_USB_NOT_SUPPORTED);
filter.addAction(UsbService.ACTION_USB_PERMISSION_NOT_GRANTED);
registerReceiver(mUsbReceiver, filter);
}
@Override
protected void onResume() {
super.onResume();
setFilters();
startService(UsbService.class, usbConnection, null);
}总结
大概使用教程就是这样，今天来的有点晚。如果有不懂的可以关注我的公众号留言咨询。后面还是折腾gpio通信。如果有一起玩的可以联系我一起交流。
欢迎长按下图 -> 识别图中二维码或者微信扫一扫关注我的公众号
以上是关于关于OrangePI 串口通讯解决方案的主要内容，如果未能解决你的问题，请参考以下文章