android UART串口开发7941D双拼读卡模块

int stopBit, int flags) throws SecurityException, IOException {

/* Check access permission */

//检查访问权限，如果没有读写权限，进行文件操作，修改文件访问权限

if (!device.canRead() || !device.canWrite()) {

try {

/* Missing read/write permission, trying to chmod the file */

Process su;

su = Runtime.getRuntime().exec(“/system/bin/su”);

String cmd = "chmod 777 " + device.getAbsolutePath() + “\n”

• “exit\n”;

su.getOutputStream().write(cmd.getBytes());

if ((su.waitFor() != 0) || !device.canRead()

|| !device.canWrite()) {

throw new SecurityException();

}

} catch (Exception e) {

e.printStackTrace();

throw new SecurityException();

}

}

mFd = open(device.getAbsolutePath(), baudRate, parity, dataBits, stopBit, flags);

if (mFd == null) {

Log.e(TAG, “native open returns null”);

throw new IOException();

}

mFileInputStream = new FileInputStream(mFd);

mFileOutputStream = new FileOutputStream(mFd);

}

// Getters and setters

public InputStream getInputStream() {

return mFileInputStream;

}

public OutputStream getOutputStream() {

return mFileOutputStream;

}

// JNI(调用java本地接口，实现串口的打开和关闭)

/**

• 串口有五个重要的参数：串口设备名，波特率，检验位，数据位，停止位

• 其中检验位一般默认位NONE,数据位一般默认为8，停止位默认为1

*/

/**

• @param path 串口设备的绝对路径

• @param baudrate 波特率

• @param flags 校验位

*/

private native static FileDescriptor open(String path, int baudrate, int flags);

/**

• 打开串口

• @param path 串口设备文件

• @param baudRate 波特率

• @param parity 奇偶校验，0 None（默认）； 1 Odd； 2 Even

• @param dataBits 数据位，5 ~ 8 （默认8）

• @param stopBit 停止位，1 或 2 （默认 1）

• @param flags 标记 0（默认）

• @throws SecurityException

• @throws IOException

*/

private native static FileDescriptor open(String path, int baudRate, int parity, int dataBits,

int stopBit, int flags);

public native void close();

static {

System.loadLibrary(“serial_port”);

}

}

• 操作类

import cn.yumakeji.lib_serialportapi.SerialPort;

import cn.yumakeji.lib_serialportapi.callback.SerialCallBack;

import cn.yumakeji.lib_serialportapi.utils.ByteUtil;

import cn.yumakeji.lib_serialportapi.utils.LogUtil;

/**

• 数据操作封装

*/

public class SerialPortUtil {

public static String TAG = “serial_port”;

/**

• 标记当前串口状态(true:打开,false:关闭)

**/

public boolean isFlagSerial = false;

public SerialPort serialPort = null;

public InputStream inputStream = null;

public OutputStream outputStream = null;

public Thread receiveThread = null;

private SerialPortUtil() {

}

public static SerialPortUtil getInstance() {

return SingletonHolder.sInstance;

}

//静态内部类

private static class SingletonHolder {

private static final SerialPortUtil sInstance = new SerialPortUtil();

}

/**

• 打开串口

• 串口有五个重要的参数：串口设备名，波特率，检验位，数据位，停止位

• 其中检验位一般默认位NONE,数据位一般默认为8，停止位默认为1

• @param device 串口设备的绝对路径

• @param baudrate 波特率

• @param flags 校验位

• @return

*/

public boolean open(File device, int baudrate, int flags) {

boolean isopen = false;

if (isFlagSerial) {

LogUtil.e(TAG, “串口已经打开,打开失败”);

return false;

}

try {

serialPort = new SerialPort(device, baudrate, flags);

inputStream = serialPort.getInputStream();

outputStream = serialPort.getOutputStream();

receive();

isopen = true;

isFlagSerial = true;

} catch (Exception e) {

e.printStackTrace();

isopen = false;

}

return isopen;

}

/**

• 打开串口

• @param device 串口设备文件

• @param baudRate 波特率

• @param parity 奇偶校验，0 None（默认）； 1 Odd； 2 Even

• @param dataBits 数据位，5 ~ 8 （默认8）

• @param stopBit 停止位，1 或 2 （默认 1）

• @param flags 标记 0（默认）

• @return

*/

public boolean open(File device, int baudRate, int parity, int dataBits,

int stopBit, int flags) {

boolean isopen = false;

if (isFlagSerial) {

LogUtil.e(TAG, “串口已经打开,打开失败”);

return false;

}

try {

serialPort = new SerialPort(device, baudRate, parity, dataBits, stopBit, flags);

inputStream = serialPort.getInputStream();

outputStream = serialPort.getOutputStream();

receive();

isopen = true;

isFlagSerial = true;

} catch (Exception e) {

e.printStackTrace();

isopen = false;

}

return isopen;

}

/**

• 关闭串口

*/

public boolean close() {

if (!isFlagSerial) {

LogUtil.e(TAG, “串口关闭失败”);

return false;

}

boolean isClose = false;

LogUtil.e(TAG, “关闭串口”);

try {

if (inputStream != null) {

inputStream.close();

}

if (outputStream != null) {

outputStream.close();

}

if (serialPort != null) {

serialPort.close();

}

isClose = true;

isFlagSerial = false;//关闭串口时，连接状态标记为false

} catch (IOException e) {

e.printStackTrace();

isClose = false;

}

return isClose;

}

/**

• 发送16进制，串口指令

*/

public void sendHexString(String data) {

if (!isFlagSerial) {

LogUtil.e(TAG, “串口未打开,发送失败” + data);

return;

}

try {

outputStream.write(ByteUtil.hex2byte(data));

outputStream.flush();

LogUtil.e(TAG, “sendSerialData:” + data);

} catch (IOException e) {

e.printStackTrace();

LogUtil.e(TAG, “发送指令出现异常”);

}

}

/**

• 发送ASCII，串口指令

*/

public void sendAsciiString(String data) {

if (!isFlagSerial) {

LogUtil.e(TAG, “串口未打开,发送失败” + data);

return;

}

try {

outputStream.write(data.getBytes(“gbk”));

outputStream.flush();

LogUtil.e(TAG, “sendSerialData:” + data);

} catch (IOException e) {

e.printStackTrace();

LogUtil.e(TAG, “发送指令出现异常”);

}

}

/**

• 接收串口数据的方法

*/

public void receive() {

if (receiveThread != null && !isFlagSerial) {

return;

}

receiveThread = new Thread() {

@Override

public void run() {

while (isFlagSerial) {

try {

byte[] readData = new byte[256];

if (inputStream == null) {

return;

}

int size = inputStream.read(readData);

if (size > 0 && isFlagSerial) {

// strData = ByteUtil.byteToStr(readData, size);

if (onDataReceiveListener != null) {

onDataReceiveListener.onSerialPortData(readData, size);

}

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

};

receiveThread.start();

}

private SerialCallBack onDataReceiveListener;

public void setOnDataReceiveListener(SerialCallBack onDataReceiveListener) {

this.onDataReceiveListener = onDataReceiveListener;

}

}

• 具体调用如下：

package cn.yumakeji.hserialportapi;

import android.Manifest;

import android.os.Bundle;

import android.text.TextUtils;

import android.view.View;

import android.widget.CheckBox;

import android.widget.CompoundButton;

import android.widget.EditText;

import android.widget.TextView;

import android.widget.Toast;

import androidx.annotation.NonNull;

import androidx.appcompat.app.AppCompatActivity;

import java.io.File;

import java.io.UnsupportedEncodingException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import cn.yumakeji.lib_serialportapi.SerialPortFinder;

import cn.yumakeji.lib_serialportapi.callback.SerialCallBack;

import cn.yumakeji.lib_serialportapi.port.SerialPortUtil;

import cn.yumakeji.lib_serialportapi.utils.AppGlobals;

import cn.yumakeji.lib_serialportapi.utils.ByteUtil;

import cn.yumakeji.lib_serialportapi.utils.LogUtil;

import tsou.cn.lib_primissions.HxgPermissionFail;

import tsou.cn.lib_primissions.HxgPermissionHelper;

import tsou.cn.lib_primissions.HxgPermissionSuccess;

import utils.AppUtils;

public class MainActivity extends AppCompatActivity implements SerialCallBack {

private static final int REQUESE_CODE = 0xFFA;

private CheckBox mCbHex;

private CheckBox mCbAscii;

@Override

public void onDetachedFromWindow() {

super.onDetachedFromWindow();

SerialPortUtil.getInstance().close();

}

@Override

public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {

super.onRequestPermissionsResult(requestCode, permissions, grantResults);

HxgPermissionHelper.requestPermissionsResult(this, requestCode, permissions);

}

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

mCbHex = findViewById(R.id.cb_hex);

mCbAscii = findViewById(R.id.cb_ascii);

mCbHex.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {

@Override

public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {

if (isChecked) {

mCbAscii.setChecked(false);

} else {

mCbAscii.setChecked(true);

}

}

});

mCbAscii.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {

@Override

public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {

if (isChecked) {

mCbHex.setChecked(false);

} else {

mCbHex.setChecked(true);

}

}

});

}

@Override

public void onAttachedToWindow() {

super.onAttachedToWindow();

HxgPermissionHelper.with(this)

.requestCode(REQUESE_CODE)

.requestPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE,

Manifest.permission.READ_EXTERNAL_STORAGE)

.request();

SerialPortUtil.getInstance().setOnDataReceiveListener(this);

}

@HxgPermissionSuccess(requestCode = REQUESE_CODE)

private void success() {

Toast.makeText(this, “权限获取成功”, Toast.LENGTH_SHORT).show();

LogUtil.d(“是否root：” + AppUtils.isRooted() + “”);

}

@HxgPermissionFail(requestCode = REQUESE_CODE)

private void fail() {

Toast.makeText(this, “权限获取失败”, Toast.LENGTH_SHORT).show();

}

/**

• 打开串口

• @param view

*/

public void onOpenClick(View view) {

// boolean open = SerialPortUtil.getInstance().open(new File(“/dev/ttyS0”), 38400, 0);

boolean open = SerialPortUtil.getInstance().open(new File(“/dev/ttyS1”), 9600, 0);

if (open) {

LogUtil.d(“串口已经打开”);

} else {

LogUtil.d(“串口打开失败”);

}

}

/**

• 发送数据

• @param view

*/

public void onSendClick(View view) {

String trim = ((EditText) findViewById(R.id.et_input)).getText().toString().trim();

if (TextUtils.isEmpty(trim)) {

Toast.makeText(AppGlobals.getApplication().getApplicationContext(), “请输入发送内容”, Toast.LENGTH_LONG).show();

return;

}

if (!mCbHex.isChecked() && !mCbAscii.isChecked()) {

Toast.makeText(AppGlobals.getApplication().getApplicationContext(), “请选择数据类型”, Toast.LENGTH_LONG).show();

return;

}

if (mCbHex.isChecked()) {

SerialPortUtil.getInstance().sendHexString(trim);

}

if (mCbAscii.isChecked()) {

SerialPortUtil.getInstance().sendAsciiString(trim);

}

}

/**

• 关闭串口

• @param view

*/

public void onCloseClick(View view) {

boolean close = SerialPortUtil.getInstance().close();

if (close) {

LogUtil.d(“串口已经关闭”);

}

}

/**

• 获取串口数据

• @param view

*/

public void onInfoClick(View view) {

SerialPortFinder spf = new SerialPortFinder();

if (spf.getAllDevices() != null && spf.getAllDevices().length > 0) {

LogUtil.e(String.valueOf(Arrays.asList(spf.getAllDevices())));

}

if (spf.getAllDevicesPath() != null && spf.getAllDevicesPath().length > 0) {

LogUtil.e(String.valueOf(Arrays.asList(spf.getAllDevicesPath())));

}

}

/**

• 接收数据

• @param buffer

• @param size

*/

@Override

public void onSerialPortData(final byte[] buffer, final int size) {

runOnUiThread(new Runnable() {

@Override

文末

当你打算跳槽的时候，应该把“跳槽成功后，我能学到什么东西？对我的未来发展有什么好处”放在第一位。这些东西才是真正引导你的关键。在跳槽之前尽量“物尽其用”，把手头上的工作做好，最好是完成了某个项目或是得到提升之后再走。跳槽不是目的，而是为了达到最终职业目标的手段

最后祝大家工作升职加薪，面试拿到心仪Offer

LogUtil.d(“串口已经关闭”);

}

}

/**

• 获取串口数据

• @param view

*/

public void onInfoClick(View view) {

SerialPortFinder spf = new SerialPortFinder();

if (spf.getAllDevices() != null && spf.getAllDevices().length > 0) {

LogUtil.e(String.valueOf(Arrays.asList(spf.getAllDevices())));

}

if (spf.getAllDevicesPath() != null && spf.getAllDevicesPath().length > 0) {

LogUtil.e(String.valueOf(Arrays.asList(spf.getAllDevicesPath())));

}

}

/**

• 接收数据

• @param buffer

• @param size

*/

@Override

public void onSerialPortData(final byte[] buffer, final int size) {

runOnUiThread(new Runnable() {

@Override

文末

当你打算跳槽的时候，应该把“跳槽成功后，我能学到什么东西？对我的未来发展有什么好处”放在第一位。这些东西才是真正引导你的关键。在跳槽之前尽量“物尽其用”，把手头上的工作做好，最好是完成了某个项目或是得到提升之后再走。跳槽不是目的，而是为了达到最终职业目标的手段

最后祝大家工作升职加薪，面试拿到心仪Offer

[外链图片转存中…(img-T3YuWdbw-1723537974624)]
[外链图片转存中…(img-tngkjZNH-1723537974624)]