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

app/src/main/java/com/ismart/ib86/app/MainActivity.java

@@ -147,27 +147,21 @@ public class MainActivity extends AppCompatActivity {
         });
 
         // 设置设备控制回调
-        deviceManager.setDeviceControlListener(new ASR5515DeviceManager.DeviceControlListener() {
+        deviceManager.setDeviceControlListener(success -> {
-            @Override
-            public void onDeviceRestartResponse(boolean success) {
             if (success) {
                 LogManager.d(TAG, "设备重启成功");
             } else {
                 LogManager.e(TAG, "设备重启失败");
             }
-            }
         });
 
         // 设置日志控制回调
-        deviceManager.setLogControlListener(new ASR5515DeviceManager.LogControlListener() {
+        deviceManager.setLogControlListener(success -> {
-            @Override
-            public void onLogControlResponse(boolean success) {
             if (success) {
                 LogManager.d(TAG, "日志控制设置成功");
             } else {
                 LogManager.e(TAG, "日志控制设置失败");
             }
-            }
         });
 
         // 设置蓝牙版本回调
@@ -185,40 +179,15 @@ public class MainActivity extends AppCompatActivity {
         );
 
         // 设置主机状态回调
-        deviceManager.setHostStatusListener(new ASR5515DeviceManager.HostStatusListener() {
+        deviceManager.setHostStatusListener(response -> LogManager.d(TAG, "主机状态: " + response.status));
-            @Override
+        deviceManager.setBootBinCheckListener(response -> LogManager.d(TAG, "Boot bin检查: " + response.toString()));
-            public void onHostStatusResponse(ASR5515Protocol.HostStatusResponse response) {
+        deviceManager.setCollectFreqSetListener(response -> LogManager.d(TAG, "采集频率设置: " + response.toString()));
-                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.setHrBpBoAutoMeasureListener(new ASR5515DeviceManager.HrBpBoAutoMeasureListener() {
+        deviceManager.setHrBpBoAutoMeasureListener(response -> LogManager.d(TAG, "HrBpBo自动测量: " + response.toString()));
-            @Override
-            public void onHrBpBoAutoMeasureResponse(ASR5515Protocol.HrBpBoAutoMeasureResponse response) {
-                LogManager.d(TAG, "HrBpBo自动测量: " + response.toString());
-            }
-        });
 
         // 设置心率血压血氧手动测量回调
-        deviceManager.setHrBpBoManualMeasureListener(new ASR5515DeviceManager.HrBpBoManualMeasureListener() {
+        deviceManager.setHrBpBoManualMeasureListener(response -> LogManager.d(TAG, "HrBpBo手动测量: " + response.toString()));
-            @Override
-            public void onHrBpBoManualMeasureResponse(ASR5515Protocol.HrBpBoManualMeasureResponse response) {
-                LogManager.d(TAG, "HrBpBo手动测量: " + response.toString());
-            }
-        });
 
         // 设置动态测量回调
         deviceManager.setDynamicMeasureListener(response -> 
@@ -231,9 +200,7 @@ public class MainActivity extends AppCompatActivity {
         );
 
         // 设置算法结果回调
-        deviceManager.setAlgoResultListener(new ASR5515DeviceManager.AlgoResultListener() {
+        deviceManager.setAlgoResultListener(response -> {
-            @Override
-            public void onAlgoResultReceived(ASR5515Protocol.AlgoResultResponse response) {
             LogManager.d(TAG, "算法结果: " + response.toString());
 
             // 在后台线程处理算法结果
@@ -248,7 +215,17 @@ public class MainActivity extends AppCompatActivity {
                     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.stopGH3220Measure(ASR5515Protocol.GH3220MeasureType.HR);
 //       deviceManager.stopGH3220Measure(ASR5515Protocol.GH3220MeasureType.SPO2);
 //        deviceManager.startGH3220Measure(ASR5515Protocol.GH3220MeasureType.ECG);
 
-//       handler.postDelayed(new Runnable() {
+       handler.postDelayed(new Runnable() {
-//           @Override
+           @Override
-//           public void run() {
+           public void run() {
-//               deviceManager.startGH3220Measure(ASR5515Protocol.GH3220MeasureType.HR);
+//            deviceManager.startGH3220Measure(ASR5515Protocol.GH3220MeasureType.LEAD);
-//           }
+           }
-//       }, 1000);
+       }, 2000);
 //        deviceManager.sendWearDetectionRequest();
 //        handler.postDelayed(wearDetectionRunnable, 1000);
     }

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

@@ -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,108 +187,73 @@ public class ASR5515DeviceManager {
         }
         
         // 设置设备状态回调
-        serialPortHelper.setDeviceCheckCallback(new SerialPortHelper.DeviceCheckCallback() {
+        serialPortHelper.setDeviceCheckCallback(deviceInfo -> {
-            @Override
-            public void onDeviceCheckResponse(final ASR5515Protocol.DeviceInfo deviceInfo) {
             if (deviceCheckListener != null) {
                 mainHandler.post(() -> deviceCheckListener.onDeviceCheckResponse(deviceInfo));
             }
-            }
         });
 
-        serialPortHelper.setDeviceControlCallback(new SerialPortHelper.DeviceControlCallback() {
+        serialPortHelper.setDeviceControlCallback(success -> {
-            @Override
-            public void onDeviceRestartResponse(final boolean success) {
             if (deviceControlListener != null) {
                 mainHandler.post(() -> deviceControlListener.onDeviceRestartResponse(success));
             }
-            }
         });
 
-        serialPortHelper.setLogControlCallback(new SerialPortHelper.LogControlCallback() {
+        serialPortHelper.setLogControlCallback(success -> {
-            @Override
-            public void onLogControlResponse(final boolean success) {
             if (logControlListener != null) {
                 mainHandler.post(() -> logControlListener.onLogControlResponse(success));
             }
-            }
         });
 
-        serialPortHelper.setBtVersionCallback(new SerialPortHelper.BtVersionCallback() {
+        serialPortHelper.setBtVersionCallback(version -> {
-            @Override
-            public void onBtVersionResponse(final String version) {
             if (btVersionListener != null) {
                 mainHandler.post(() -> btVersionListener.onBtVersionResponse(version));
             }
-            }
         });
 
-        serialPortHelper.setBtUpgradeCallback(new SerialPortHelper.BtUpgradeCallback() {
+        serialPortHelper.setBtUpgradeCallback(response -> {
-            @Override
-            public void onBtUpgradeResponse(final ASR5515Protocol.BtUpgradeResponse response) {
             if (btUpgradeListener != null) {
                 mainHandler.post(() -> btUpgradeListener.onBtUpgradeResponse(response));
             }
-            }
         });
 
-        serialPortHelper.setHostStatusCallback(new SerialPortHelper.HostStatusCallback() {
+        serialPortHelper.setHostStatusCallback(response -> {
-            @Override
-            public void onHostStatusResponse(final ASR5515Protocol.HostStatusResponse response) {
             if (hostStatusListener != null) {
                 mainHandler.post(() -> hostStatusListener.onHostStatusResponse(response));
             }
-            }
         });
         
-        serialPortHelper.setBootBinCheckCallback(new SerialPortHelper.BootBinCheckCallback() {
+        serialPortHelper.setBootBinCheckCallback(response -> {
-            @Override
-            public void onBootBinCheckResponse(final ASR5515Protocol.BootBinCheckResponse response) {
             if (bootBinCheckListener != null) {
                 mainHandler.post(() -> bootBinCheckListener.onBootBinCheckResponse(response));
             }
-            }
         });
         
-        serialPortHelper.setCollectFreqSetCallback(new SerialPortHelper.CollectFreqSetCallback() {
+        serialPortHelper.setCollectFreqSetCallback(response -> {
-            @Override
-            public void onCollectFreqSetResponse(final ASR5515Protocol.CollectFreqSetResponse response) {
             if (collectFreqSetListener != null) {
                 mainHandler.post(() -> collectFreqSetListener.onCollectFreqSetResponse(response));
             }
-            }
         });
 
-        serialPortHelper.setHrBpBoAutoMeasureCallback(new SerialPortHelper.HrBpBoAutoMeasureCallback() {
+        serialPortHelper.setHrBpBoAutoMeasureCallback(response -> {
-            @Override
-            public void onHrBpBoAutoMeasureResponse(ASR5515Protocol.HrBpBoAutoMeasureResponse response) {
             if (hrBpBoAutoMeasureListener != null) {
                 mainHandler.post(() -> hrBpBoAutoMeasureListener.onHrBpBoAutoMeasureResponse(response));
             }
-            }
         });
 
-        serialPortHelper.setHrBpBoManualMeasureCallback(new SerialPortHelper.HrBpBoManualMeasureCallback() {
+        serialPortHelper.setHrBpBoManualMeasureCallback(response -> {
-            @Override
-            public void onHrBpBoManualMeasureResponse(ASR5515Protocol.HrBpBoManualMeasureResponse response) {
             if (hrBpBoManualMeasureListener != null) {
                 mainHandler.post(() -> hrBpBoManualMeasureListener.onHrBpBoManualMeasureResponse(response));
             }
-            }
         });
 
-        serialPortHelper.setDynamicMeasureCallback(new SerialPortHelper.DynamicMeasureCallback() {
+        serialPortHelper.setDynamicMeasureCallback(response -> {
-            @Override
-            public void onDynamicMeasureResponse(ASR5515Protocol.DynamicMeasureResponse response) {
             if (dynamicMeasureListener != null) {
                 mainHandler.post(() -> dynamicMeasureListener.onDynamicMeasureResponse(response));
             }
-            }
         });
         
-        serialPortHelper.setWearDetectionCallback(new SerialPortHelper.WearDetectionCallback() {
+        serialPortHelper.setWearDetectionCallback(response -> {
-            @Override
-            public void onWearDetectionResponse(ASR5515Protocol.WearDetectionResponse response) {
             if (wearDetectionListener != null) {
                 mainHandler.post(() -> {
                     // 发送佩戴检测接收确认
@@ -285,7 +262,6 @@ public class ASR5515DeviceManager {
                     wearDetectionListener.onWearDetectionResponse(response);
                 });
             }
-            }
         });
         
         serialPortHelper.setGH3220MeasureCallback(new SerialPortHelper.GH3220MeasureCallback() {
@@ -304,9 +280,7 @@ public class ASR5515DeviceManager {
             }
         });
         
-        serialPortHelper.setAlgoResultCallback(new SerialPortHelper.AlgoResultCallback() {
+        serialPortHelper.setAlgoResultCallback(response -> {
-            @Override
-            public void onAlgoResultReceived(final ASR5515Protocol.AlgoResultResponse response) {
             if (algoResultListener != null) {
                 mainHandler.post(() -> {
                     // 根据算法结果类型发送接收确认
@@ -320,6 +294,16 @@ public class ASR5515DeviceManager {
                     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检查监听器
      */
@@ -658,6 +650,26 @@ public class ASR5515DeviceManager {
         }
     }
     
+    /**
+     * 发送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)
     {
         if (!isDeviceReady()) {

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

@@ -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) {

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

@@ -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);
@@ -122,6 +124,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;
         this.mBaudRate = baudRate;
@@ -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);
+        }
 
         // 尝试解析完整的帧
         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;
         }
     }
 }