helloyifa/iB86
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

增加心电图数据接收功能，串口缓冲区增加到4K

Browse Source
This commit is contained in:
peng 2025-07-10 10:55:20 +08:00
parent 0692046420
commit ab3f86d9d9
4 changed files with 267 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

119
app/src/main/java/com/ismart/ib86/app/MainActivity.java
View File

@ -147,26 +147,20 @@ public class MainActivity extends AppCompatActivity {
});
// 设置设备控制回调
deviceManager.setDeviceControlListener(new ASR5515DeviceManager.DeviceControlListener() {
@Override
public void onDeviceRestartResponse(boolean success) {
if (success) {
LogManager.d(TAG, "设备重启成功");
} else {
LogManager.e(TAG, "设备重启失败");
}
deviceManager.setDeviceControlListener(success -> {
if (success) {
LogManager.d(TAG, "设备重启成功");
} else {
LogManager.e(TAG, "设备重启失败");
}
});
// 设置日志控制回调
deviceManager.setLogControlListener(new ASR5515DeviceManager.LogControlListener() {
@Override
public void onLogControlResponse(boolean success) {
if (success) {
LogManager.d(TAG, "日志控制设置成功");
} else {
LogManager.e(TAG, "日志控制设置失败");
}
deviceManager.setLogControlListener(success -> {
if (success) {
LogManager.d(TAG, "日志控制设置成功");
} else {
LogManager.e(TAG, "日志控制设置失败");
}
});
@ -185,40 +179,15 @@ public class MainActivity extends AppCompatActivity {
);
// 设置主机状态回调
deviceManager.setHostStatusListener(new ASR5515DeviceManager.HostStatusListener() {
@Override
public void onHostStatusResponse(ASR5515Protocol.HostStatusResponse response) {
LogManager.d(TAG, "主机状态: " + response.status);
}
});
deviceManager.setBootBinCheckListener(new ASR5515DeviceManager.BootBinCheckListener() {
@Override
public void onBootBinCheckResponse(ASR5515Protocol.BootBinCheckResponse response) {
LogManager.d(TAG, "Boot bin检查: " + response.toString());
}
});
deviceManager.setCollectFreqSetListener(new ASR5515DeviceManager.CollectFreqSetListener() {
@Override
public void onCollectFreqSetResponse(ASR5515Protocol.CollectFreqSetResponse response) {
LogManager.d(TAG, "采集频率设置: " + response.toString());
}
});
deviceManager.setHostStatusListener(response -> LogManager.d(TAG, "主机状态: " + response.status));
deviceManager.setBootBinCheckListener(response -> LogManager.d(TAG, "Boot bin检查: " + response.toString()));
deviceManager.setCollectFreqSetListener(response -> LogManager.d(TAG, "采集频率设置: " + response.toString()));
// 设置心率血压血氧自动测量回调
deviceManager.setHrBpBoAutoMeasureListener(new ASR5515DeviceManager.HrBpBoAutoMeasureListener() {
@Override
public void onHrBpBoAutoMeasureResponse(ASR5515Protocol.HrBpBoAutoMeasureResponse response) {
LogManager.d(TAG, "HrBpBo自动测量: " + response.toString());
}
});
deviceManager.setHrBpBoAutoMeasureListener(response -> LogManager.d(TAG, "HrBpBo自动测量: " + response.toString()));
// 设置心率血压血氧手动测量回调
deviceManager.setHrBpBoManualMeasureListener(new ASR5515DeviceManager.HrBpBoManualMeasureListener() {
@Override
public void onHrBpBoManualMeasureResponse(ASR5515Protocol.HrBpBoManualMeasureResponse response) {
LogManager.d(TAG, "HrBpBo手动测量: " + response.toString());
}
});
deviceManager.setHrBpBoManualMeasureListener(response -> LogManager.d(TAG, "HrBpBo手动测量: " + response.toString()));
// 设置动态测量回调
deviceManager.setDynamicMeasureListener(response ->
@ -231,24 +200,32 @@ public class MainActivity extends AppCompatActivity {
);
// 设置算法结果回调
deviceManager.setAlgoResultListener(new ASR5515DeviceManager.AlgoResultListener() {
@Override
public void onAlgoResultReceived(ASR5515Protocol.AlgoResultResponse response) {
LogManager.d(TAG, "算法结果: " + response.toString());
// 在后台线程处理算法结果
new Thread(() -> {
// 根据类型处理不同的算法结果
if (response.type == ASR5515Protocol.AlgoResultResponse.TYPE_HEART_RATE) {
// 简化日志输出
LogManager.d(TAG, "HR: " + response.getHeartRate() +
" Conf: " + response.getConfidence() + "%");
} else if (response.type == ASR5515Protocol.AlgoResultResponse.TYPE_SPO2 &&
response.getSpo2() > 0) {
LogManager.d(TAG, "SpO2: " + response.getSpo2() + "%");
}
}).start();
deviceManager.setAlgoResultListener(response -> {
LogManager.d(TAG, "算法结果: " + response.toString());
// 在后台线程处理算法结果
new Thread(() -> {
// 根据类型处理不同的算法结果
if (response.type == ASR5515Protocol.AlgoResultResponse.TYPE_HEART_RATE) {
// 简化日志输出
LogManager.d(TAG, "HR: " + response.getHeartRate() +
" Conf: " + response.getConfidence() + "%");
} else if (response.type == ASR5515Protocol.AlgoResultResponse.TYPE_SPO2 &&
response.getSpo2() > 0) {
LogManager.d(TAG, "SpO2: " + response.getSpo2() + "%");
}
}).start();
});
//设置lead状态回调
deviceManager.setLeadStatusListener(response -> {
LogManager.d(TAG, "lead 状态: " + response.status);
if(response.status == 1)
{
deviceManager.switchEcgDataReport((byte) 0x01);
deviceManager.startGH3220Measure(ASR5515Protocol.GH3220MeasureType.ECG);
}
});
}
@ -271,19 +248,19 @@ public class MainActivity extends AppCompatActivity {
// }, 2000);
// deviceManager.startGH3220Measure(ASR5515Protocol.GH3220MeasureType.ADT);
deviceManager.startGH3220Measure(ASR5515Protocol.GH3220MeasureType.ADT);
deviceManager.startGH3220Measure(ASR5515Protocol.GH3220MeasureType.LEAD);
// deviceManager.switchEcgDataReport((byte) 0x01);
// deviceManager.switchEcgDataReport((byte) 0x01);
// deviceManager.stopGH3220Measure(ASR5515Protocol.GH3220MeasureType.HR);
// deviceManager.stopGH3220Measure(ASR5515Protocol.GH3220MeasureType.SPO2);
// deviceManager.startGH3220Measure(ASR5515Protocol.GH3220MeasureType.ECG);
// handler.postDelayed(new Runnable() {
// @Override
// public void run() {
// deviceManager.startGH3220Measure(ASR5515Protocol.GH3220MeasureType.HR);
// }
// }, 1000);
handler.postDelayed(new Runnable() {
@Override
public void run() {
// deviceManager.startGH3220Measure(ASR5515Protocol.GH3220MeasureType.LEAD);
}
}, 2000);
// deviceManager.sendWearDetectionRequest();
// handler.postDelayed(wearDetectionRunnable, 1000);
}

198
app/src/main/java/com/ismart/ib86/feature/serial/SerialPort/ASR5515DeviceManager.java
View File

@ -69,6 +69,7 @@ public class ASR5515DeviceManager {
private WearDetectionListener wearDetectionListener;
private GH3220MeasureListener gh3220MeasureListener;
private AlgoResultListener algoResultListener;
private LeadStatusListener leadStatusListener;
// 细分回调接口
public interface DeviceCheckListener {
@ -132,6 +133,17 @@ public class ASR5515DeviceManager {
void onAlgoResultReceived(ASR5515Protocol.AlgoResultResponse response);
}
/**
* LEAD状态监听器
*/
public interface LeadStatusListener {
/**
* 接收到LEAD状态报告
* @param response LEAD状态响应
*/
void onLeadStatusReport(ASR5515Protocol.LeadStatusResponse response);
}
public interface GH3220MeasureListener {
void onGH3220MeasureStartResponse(ASR5515Protocol.GH3220MeasureResponse response);
void onGH3220MeasureStopResponse(ASR5515Protocol.GH3220MeasureResponse response);
@ -175,116 +187,80 @@ public class ASR5515DeviceManager {
}
// 设置设备状态回调
serialPortHelper.setDeviceCheckCallback(new SerialPortHelper.DeviceCheckCallback() {
@Override
public void onDeviceCheckResponse(final ASR5515Protocol.DeviceInfo deviceInfo) {
if (deviceCheckListener != null) {
mainHandler.post(() -> deviceCheckListener.onDeviceCheckResponse(deviceInfo));
}
serialPortHelper.setDeviceCheckCallback(deviceInfo -> {
if (deviceCheckListener != null) {
mainHandler.post(() -> deviceCheckListener.onDeviceCheckResponse(deviceInfo));
}
});
serialPortHelper.setDeviceControlCallback(new SerialPortHelper.DeviceControlCallback() {
@Override
public void onDeviceRestartResponse(final boolean success) {
if (deviceControlListener != null) {
mainHandler.post(() -> deviceControlListener.onDeviceRestartResponse(success));
}
serialPortHelper.setDeviceControlCallback(success -> {
if (deviceControlListener != null) {
mainHandler.post(() -> deviceControlListener.onDeviceRestartResponse(success));
}
});
serialPortHelper.setLogControlCallback(new SerialPortHelper.LogControlCallback() {
@Override
public void onLogControlResponse(final boolean success) {
if (logControlListener != null) {
mainHandler.post(() -> logControlListener.onLogControlResponse(success));
}
serialPortHelper.setLogControlCallback(success -> {
if (logControlListener != null) {
mainHandler.post(() -> logControlListener.onLogControlResponse(success));
}
});
serialPortHelper.setBtVersionCallback(new SerialPortHelper.BtVersionCallback() {
@Override
public void onBtVersionResponse(final String version) {
if (btVersionListener != null) {
mainHandler.post(() -> btVersionListener.onBtVersionResponse(version));
}
serialPortHelper.setBtVersionCallback(version -> {
if (btVersionListener != null) {
mainHandler.post(() -> btVersionListener.onBtVersionResponse(version));
}
});
serialPortHelper.setBtUpgradeCallback(new SerialPortHelper.BtUpgradeCallback() {
@Override
public void onBtUpgradeResponse(final ASR5515Protocol.BtUpgradeResponse response) {
if (btUpgradeListener != null) {
mainHandler.post(() -> btUpgradeListener.onBtUpgradeResponse(response));
}
serialPortHelper.setBtUpgradeCallback(response -> {
if (btUpgradeListener != null) {
mainHandler.post(() -> btUpgradeListener.onBtUpgradeResponse(response));
}
});
serialPortHelper.setHostStatusCallback(new SerialPortHelper.HostStatusCallback() {
@Override
public void onHostStatusResponse(final ASR5515Protocol.HostStatusResponse response) {
if (hostStatusListener != null) {
mainHandler.post(() -> hostStatusListener.onHostStatusResponse(response));
}
serialPortHelper.setHostStatusCallback(response -> {
if (hostStatusListener != null) {
mainHandler.post(() -> hostStatusListener.onHostStatusResponse(response));
}
});
serialPortHelper.setBootBinCheckCallback(new SerialPortHelper.BootBinCheckCallback() {
@Override
public void onBootBinCheckResponse(final ASR5515Protocol.BootBinCheckResponse response) {
if (bootBinCheckListener != null) {
mainHandler.post(() -> bootBinCheckListener.onBootBinCheckResponse(response));
}
serialPortHelper.setBootBinCheckCallback(response -> {
if (bootBinCheckListener != null) {
mainHandler.post(() -> bootBinCheckListener.onBootBinCheckResponse(response));
}
});
serialPortHelper.setCollectFreqSetCallback(new SerialPortHelper.CollectFreqSetCallback() {
@Override
public void onCollectFreqSetResponse(final ASR5515Protocol.CollectFreqSetResponse response) {
if (collectFreqSetListener != null) {
mainHandler.post(() -> collectFreqSetListener.onCollectFreqSetResponse(response));
}
serialPortHelper.setCollectFreqSetCallback(response -> {
if (collectFreqSetListener != null) {
mainHandler.post(() -> collectFreqSetListener.onCollectFreqSetResponse(response));
}
});
serialPortHelper.setHrBpBoAutoMeasureCallback(new SerialPortHelper.HrBpBoAutoMeasureCallback() {
@Override
public void onHrBpBoAutoMeasureResponse(ASR5515Protocol.HrBpBoAutoMeasureResponse response) {
if (hrBpBoAutoMeasureListener != null) {
mainHandler.post(() -> hrBpBoAutoMeasureListener.onHrBpBoAutoMeasureResponse(response));
}
serialPortHelper.setHrBpBoAutoMeasureCallback(response -> {
if (hrBpBoAutoMeasureListener != null) {
mainHandler.post(() -> hrBpBoAutoMeasureListener.onHrBpBoAutoMeasureResponse(response));
}
});
serialPortHelper.setHrBpBoManualMeasureCallback(new SerialPortHelper.HrBpBoManualMeasureCallback() {
@Override
public void onHrBpBoManualMeasureResponse(ASR5515Protocol.HrBpBoManualMeasureResponse response) {
if (hrBpBoManualMeasureListener != null) {
mainHandler.post(() -> hrBpBoManualMeasureListener.onHrBpBoManualMeasureResponse(response));
}
serialPortHelper.setHrBpBoManualMeasureCallback(response -> {
if (hrBpBoManualMeasureListener != null) {
mainHandler.post(() -> hrBpBoManualMeasureListener.onHrBpBoManualMeasureResponse(response));
}
});
serialPortHelper.setDynamicMeasureCallback(new SerialPortHelper.DynamicMeasureCallback() {
@Override
public void onDynamicMeasureResponse(ASR5515Protocol.DynamicMeasureResponse response) {
if (dynamicMeasureListener != null) {
mainHandler.post(() -> dynamicMeasureListener.onDynamicMeasureResponse(response));
}
serialPortHelper.setDynamicMeasureCallback(response -> {
if (dynamicMeasureListener != null) {
mainHandler.post(() -> dynamicMeasureListener.onDynamicMeasureResponse(response));
}
});
serialPortHelper.setWearDetectionCallback(new SerialPortHelper.WearDetectionCallback() {
@Override
public void onWearDetectionResponse(ASR5515Protocol.WearDetectionResponse response) {
if (wearDetectionListener != null) {
mainHandler.post(() -> {
// 发送佩戴检测接收确认
onWearDetectionResponseReceived(response.sn);
// 调用佩戴检测监听器
wearDetectionListener.onWearDetectionResponse(response);
});
}
serialPortHelper.setWearDetectionCallback(response -> {
if (wearDetectionListener != null) {
mainHandler.post(() -> {
// 发送佩戴检测接收确认
onWearDetectionResponseReceived(response.sn);
// 调用佩戴检测监听器
wearDetectionListener.onWearDetectionResponse(response);
});
}
});
@ -304,22 +280,30 @@ public class ASR5515DeviceManager {
}
});
serialPortHelper.setAlgoResultCallback(new SerialPortHelper.AlgoResultCallback() {
@Override
public void onAlgoResultReceived(final ASR5515Protocol.AlgoResultResponse response) {
if (algoResultListener != null) {
mainHandler.post(() -> {
// 根据算法结果类型发送接收确认
if (response.type == ASR5515Protocol.AlgoResultResponse.TYPE_HEART_RATE) {
// 发送心率接收确认
onHeartRateDataReceived(response.sn);
} else if (response.type == ASR5515Protocol.AlgoResultResponse.TYPE_SPO2) {
// 发送血氧接收确认
onSpO2DataReceived(response.sn);
}
algoResultListener.onAlgoResultReceived(response);
});
}
serialPortHelper.setAlgoResultCallback(response -> {
if (algoResultListener != null) {
mainHandler.post(() -> {
// 根据算法结果类型发送接收确认
if (response.type == ASR5515Protocol.AlgoResultResponse.TYPE_HEART_RATE) {
// 发送心率接收确认
onHeartRateDataReceived(response.sn);
} else if (response.type == ASR5515Protocol.AlgoResultResponse.TYPE_SPO2) {
// 发送血氧接收确认
onSpO2DataReceived(response.sn);
}
algoResultListener.onAlgoResultReceived(response);
});
}
});
serialPortHelper.setLeadStatusCallback(response -> {
if (leadStatusListener != null) {
mainHandler.post(() -> {
// 发送LEAD状态接收确认
onLeadStatusResponseReceived(response.sn);
// 调用LEAD状态监听器
leadStatusListener.onLeadStatusReport(response);
});
}
});
}
@ -402,6 +386,14 @@ public class ASR5515DeviceManager {
this.algoResultListener = listener;
}
/**
* 设置LEAD状态监听器
* @param listener LEAD状态监听器
*/
public void setLeadStatusListener(LeadStatusListener listener) {
this.leadStatusListener = listener;
}
/**
* 设置Boot Bin检查监听器
*/
@ -657,6 +649,26 @@ public class ASR5515DeviceManager {
LogManager.e(TAG, "发送血氧接收确认失败: " + e.getMessage());
}
}
/**
* 发送LEAD状态接收确认
*
* @param sn 序列号
*/
public void onLeadStatusResponseReceived(short sn) {
if (!isDeviceReady()) {
LogManager.e(TAG, "设备未就绪，无法发送LEAD状态接收确认");
return;
}
try {
wakeupDevice();
byte[] request = ASR5515Protocol.createLeadStatusReceivedRequest(sn);
safeSendData(request);
} catch (Exception e) {
LogManager.e(TAG, "发送LEAD状态接收确认失败: " + e.getMessage());
}
}
public void switchEcgDataReport(byte type)
{

105
app/src/main/java/com/ismart/ib86/feature/serial/SerialPort/ASR5515Protocol.java
View File

@ -14,61 +14,6 @@ import java.util.HexFormat;
public class ASR5515Protocol {
private static final String TAG = "ASR5515Protocol";
// 设备检查回调接口
public interface DeviceCheckCallback {
void onDeviceCheckResponse(DeviceInfo deviceInfo);
}
// 设备控制回调接口
public interface DeviceControlCallback {
void onDeviceRestartResponse(boolean success);
void onLogControlResponse(boolean success);
}
// 蓝牙版本回调接口
public interface BtVersionCallback {
void onBtVersionResponse(String version);
}
// 蓝牙升级回调接口
public interface BtUpgradeCallback {
void onBtUpgradeResponse(BtUpgradeResponse response);
}
// 主机状态回调接口
public interface HostStatusCallback {
void onHostStatusResponse(HostStatusResponse response);
}
// Boot Bin检查回调接口
public interface BootBinCheckCallback {
void onBootBinCheckResponse(BootBinCheckResponse response);
}
// 采集频率设置回调接口
public interface CollectFreqSetCallback {
void onCollectFreqSetResponse(CollectFreqSetResponse response);
}
// HrBpBo自动测量回调接口
public interface HrBpBoAutoMeasureCallback {
void onHrBpBoAutoMeasureResponse(HrBpBoAutoMeasureResponse response);
}
// HrBpBo手动测量回调接口
public interface HrBpBoManualMeasureCallback {
void onHrBpBoManualMeasureResponse(HrBpBoManualMeasureResponse response);
}
// 动态测量回调接口
public interface DynamicMeasureCallback {
void onDynamicMeasureResponse(DynamicMeasureResponse response);
}
// 佩戴检测回调接口
public interface WearDetectionCallback {
void onWearDetectionResponse(WearDetectionResponse response);
}
private static final byte FRAME_START = (byte) '[';
private static final byte FRAME_END = (byte) ']';
@ -220,6 +165,8 @@ public class ASR5515Protocol {
public static final short CMD_SPO2_RESULT = 0x0200; // 主动上报算法结果（血氧） [512 sn len AlgoResult]
public static final short CMD_SPO2_RECEIVED = 0x0201; // 血氧接收确认 [513 sn 0]
public static final short CMD_ECG_DATA_REPORT = 0x020D; // 切换ECG数据上报类型 [525 sn len type]
public static final short CMD_LEAD_STATUS_REPORT = 0x0208; // 主动上报LEAD状态 [520 sn len stat]
public static final short CMD_LEAD_STATUS_RECEIVED = 0x0209; // LEAD状态接收确认 [521 sn 0]
}
public static class Frame {
@ -801,6 +748,54 @@ public class ASR5515Protocol {
}
}
// LEAD状态响应类
public static class LeadStatusResponse {
public short sn; // 序列号
public byte status; // LEAD状态：0-未触摸，1-触摸
public LeadStatusResponse(short sn, byte status) {
this.sn = sn;
this.status = status;
}
public boolean isTouching() {
return status == 1;
}
public short getSn() {
return sn;
}
@Override
public String toString() {
return "LeadStatusResponse{" +
"sn=" + sn +
", status=" + status +
", isTouching=" + isTouching() +
'}';
}
}
// 解析LEAD状态响应帧 [520 sn len stat]
public static LeadStatusResponse parseLeadStatusResponse(Frame frame) {
if (frame == null || frame.command != Commands.CMD_LEAD_STATUS_REPORT || frame.data.length < 1) {
return null;
}
try {
byte status = frame.data[0];
return new LeadStatusResponse(frame.sn, status);
} catch (Exception e) {
LogManager.e(TAG, "Parse lead status error: " + e.getMessage());
return null;
}
}
// 创建LEAD状态接收确认请求帧 [521 sn 0]
public static byte[] createLeadStatusReceivedRequest(short sn) {
return createFrame(Commands.CMD_LEAD_STATUS_RECEIVED, sn, new byte[]{});
}
// 解析算法结果响应帧 [updateFlag resultNum resultBit(2byte) value(4) confidence(4) signalQuality(4) confidenceLevel(4)]
public static AlgoResultResponse parseAlgoResultResponse(Frame frame) {
if (frame == null || frame.data.length < 4) {

70
app/src/main/java/com/ismart/ib86/feature/serial/SerialPort/SerialPortHelper.java
View File

@ -40,9 +40,11 @@ public class SerialPortHelper {
private WearDetectionCallback wearDetectionCallback;
private GH3220MeasureCallback gh3220MeasureCallback;
private AlgoResultCallback algoResultCallback;
private LeadStatusCallback leadStatusCallback;
private boolean isSimulationMode = false;
private Boolean lastWearStatus = null;
private final ByteBuffer frameBuffer = ByteBuffer.allocate(1024);
// 增加帧缓冲区大小，以处理大型心电图数据
private final ByteBuffer frameBuffer = ByteBuffer.allocate(4096); // 4KB
public interface SendCallback {
void onSendSuccess(byte[] data);
@ -121,6 +123,17 @@ public class SerialPortHelper {
*/
void onAlgoResultReceived(ASR5515Protocol.AlgoResultResponse response);
}
/**
* LEAD状态回调接口
*/
public interface LeadStatusCallback {
/**
* 接收到LEAD状态上报
* @param response LEAD状态响应，可以通过response.isTouching()判断是否触摸
*/
void onLeadStatusReport(ASR5515Protocol.LeadStatusResponse response);
}
public SerialPortHelper(String portName, int baudRate) {
this.mPortName = portName;
@ -201,6 +214,10 @@ public class SerialPortHelper {
this.algoResultCallback = callback;
}
public void setLeadStatusCallback(LeadStatusCallback callback) {
this.leadStatusCallback = callback;
}
public void checkDevice() {
byte[] data = ASR5515Protocol.createDeviceCheckRequest();
sendData(data, null);
@ -479,7 +496,8 @@ public class SerialPortHelper {
private void startReceiveThread() {
if (receiveThread == null) {
receiveThread = new Thread(() -> {
byte[] buffer = new byte[1024];
// 增加接收缓冲区大小，以处理大型心电图数据
byte[] buffer = new byte[4096]; // 4KB
while (isRunning) {
if (mSerialPort != null) {
try {
@ -548,12 +566,46 @@ public class SerialPortHelper {
private void handleReceivedData(byte[] data) {
// 将新数据添加到帧缓冲区
if (frameBuffer.position() + data.length > frameBuffer.capacity()) {
// 缓冲区溢出，清空缓冲区
// 缓冲区溢出，尝试处理已有数据后再添加新数据
LogManager.w(TAG, "Frame buffer near overflow, processing existing data first. Buffer position: "
+ frameBuffer.position() + ", New data length: " + data.length
+ ", Buffer capacity: " + frameBuffer.capacity());
// 处理当前缓冲区中的数据
frameBuffer.flip();
byte[] existingData = new byte[frameBuffer.remaining()];
frameBuffer.get(existingData);
frameBuffer.clear();
LogManager.e(TAG, "Frame buffer overflow, cleared");
return;
// 尝试解析现有数据
ASR5515Protocol.Frame frame = ASR5515Protocol.parseFrame(existingData);
if (frame != null) {
processFrame(frame);
// 如果有剩余数据，放回缓冲区
if (frame.remainingData != null && frame.remainingData.length > 0) {
frameBuffer.put(frame.remainingData);
}
} else {
// 如果无法解析，丢弃一半的数据以腾出空间
int halfLength = existingData.length / 2;
LogManager.w(TAG, "Unable to parse frame, discarding first half of buffer data: " + halfLength + " bytes");
frameBuffer.put(existingData, halfLength, existingData.length - halfLength);
}
// 检查是否有足够空间添加新数据
if (frameBuffer.position() + data.length > frameBuffer.capacity()) {
// 仍然溢出，只保留新数据的一部分
int availableSpace = frameBuffer.capacity() - frameBuffer.position();
LogManager.e(TAG, "Frame buffer still overflowing, keeping only " + availableSpace + " bytes of new data");
frameBuffer.put(data, 0, Math.min(availableSpace, data.length));
} else {
// 有足够空间，添加所有新数据
frameBuffer.put(data);
}
} else {
// 正常情况，直接添加数据
frameBuffer.put(data);
}
frameBuffer.put(data);
// 尝试解析完整的帧
while (frameBuffer.position() > 0) {
@ -694,6 +746,12 @@ public class SerialPortHelper {
algoResultCallback.onAlgoResultReceived(algoResultResponse);
}
break;
case ASR5515Protocol.Commands.CMD_LEAD_STATUS_REPORT:
ASR5515Protocol.LeadStatusResponse leadStatusResponse = ASR5515Protocol.parseLeadStatusResponse(frame);
if (leadStatusResponse != null && leadStatusCallback != null) {
leadStatusCallback.onLeadStatusReport(leadStatusResponse);
}
break;
}
}
}