你好，请问一下，你这个怎么在蓝牙BLE做分包传送的？

[liujian19891226]

我看了一下一个数据包200多个字节，但是BLE中单次传输不能超过20字节，你代码里好像没有实现分包，我这边试了一下，你这边数据传不出去，会阻塞。

[jimneylee]

大神，我也遇到这个问题

[ArdWang]

我代码里面实现了分包了吧我有拆包的鸭

[jimneylee]

感谢回复，我这边后来android集成了，ios端我根据你的方式，移植了一份。感谢你的分享，写的很不错。

[ArdWang]

好的没事哈哈

…

------------------&nbsp;原始邮件&nbsp;------------------ 发件人:&nbsp;"notifications"<notifications@github.com&gt;; 发送时间:&nbsp;2020年3月25日(星期三) 晚上6:05 收件人:&nbsp;"ArdWang/YModemBleUpdate"<YModemBleUpdate@noreply.github.com&gt;; 抄送:&nbsp;"许 愿"<278161009@qq.com&gt;;"Comment"<comment@noreply.github.com&gt;; 主题:&nbsp;Re: [ArdWang/YModemBleUpdate] 你好，请问一下，你这个怎么在蓝牙BLE做分包传送的？ (#1) 感谢回复，我这边后来android集成了，ios端我根据你的方式，移植了一份。感谢你的分享，写的很不错。 — You are receiving this because you commented. Reply to this email directly, view it on GitHub, or unsubscribe.

[lianghao777]

代码里硬编码的第一帧，必须是128+5 也就是133个字节，但是蓝牙模块一次只能接收到20个字节。老尴尬
@OverRide
public void onDataReady(byte[] data) {
Log.e(TAG, "下发固件升级数据: " + ByteUtils.bytes2HexStr(data));
if (data.length > 20) {
int count = data.length / 20;
int rem = data.length % 20;
int i = 0;
while (count-- >= 0) {
int addNum = i++;
byte[] temp;
Log.e(TAG, "下发第几组数据: " + addNum);
Log.e(TAG, "参数为 : count = " + count + " 次数为： =" + data.length/20);
if (addNum == data.length / 20) {
temp = new byte[rem];
System.arraycopy(data, addNum * 20, temp, 0, rem);
} else {
temp = new byte[20];
System.arraycopy(data, addNum * 20, temp, 0, 20);
}
Log.e(TAG, "下发的数据长度: " + temp.length);
write(characteristic, null, temp);
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} else {
write(characteristic, null, data);
}
}

目前是这么实现的，但是 不是很稳定。哎

[jimneylee]

不稳定有两方面：
1、在 YModem onDataReady 回调做了蓝牙分包发送延时等待 20ms 耗时操作，间隔等待 140ms（133 / 20 +1 = 7 次 * 20ms），YModem 底层这边的逻辑是 100ms 取一次数据包，会导致上一个大包没有发送成功，又读取下一个大包，数据发送出现混乱。
文件流截取下一个大包 --> 分包给蓝牙逐一发出 --> 蓝牙全部发送成功 --> 文件流再截取下一个大包 ......

            if (!isDataAcknowledged.get()) {
                try {
                    //We need to sleep for a while as the sending 1024 bytes data from ble would take several seconds
                    //In my circumstances, this can be up to 3 seconds.
                    Thread.sleep(100);  // 备注：固件包文件流 间隔 100ms 检测信号读取大包 onDataReady 回调抛出
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                continue;
            }

            // 此处省略底层代码 
            // ............................

            byte[] packige = YModemUtil.getDataPackage(block, dataLength, blockSequence);

            if (listener != null) {
                listener.onDataReady(packige);
            }

            blockSequence++;
            isDataAcknowledged.set(false);  // 库底层线程控制大包读取 onDataReady 回调，这个逻辑一定要读懂 @lianghao777 

参考底层文件流线程读写方法，我写了一个线程控制小包块速度发送线程，思路类似：

    public class BleDataSendThread extends Thread {

        private final static String TAG = "BleDataSendThread";

        private AtomicBoolean isDataAcknowledged = new AtomicBoolean(false);
        private boolean isKeepRunning = false;

        @Override
        public void run() {
            LogExt.d(TAG, "run BleDataSendThread");
            try {
                tryToSendBleData();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        // 线程队列继续发送数据
        public void keepSending() {
            isDataAcknowledged.set(true);
        }

        // 发送蓝牙大包数据主循环函数，通过 bool 线程变量控制启停
        private void tryToSendBleData() {
            isDataAcknowledged.set(true);
            isKeepRunning = true;

            while (isKeepRunning) {

                // 定时检测线程是否需要唤醒继续操作
                if (!isDataAcknowledged.get()) {
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    continue;
                }

                // 复位唤醒标志，执行完本次操作后，等待下次唤醒
                isDataAcknowledged.set(false);

                int hasSentLength = 0;

                // 如果本次待发送的大包数据只有不到一小块数据，不用分包，直接发送
                if (mToSendBlePackageData.length <= mBlockSize) {

                    trySendEachBlockData(mToSendBlePackageData);

                    // 更新已发送数据长度
                    hasSentLength = mToSendBlePackageData.length;

                    LogExt.d(TAG, "block length: " + mToSendBlePackageData.length);
                } else {
                    int totalBlockNum = mToSendBlePackageData.length / mBlockSize + 1;
                    int tailBlockSize = mToSendBlePackageData.length % mBlockSize;

                    byte[] eachBlockData = new byte[mBlockSize];
                    byte[] tailBlockData = new byte[tailBlockSize];

                    for (int i = 0; i < totalBlockNum; i++) {
                        if (i == totalBlockNum - 1) {

                            // 尾包单独处理
                            System.arraycopy(mToSendBlePackageData, i * mBlockSize, tailBlockData, 0, tailBlockData.length);

                            // 异步任务队列发送单个块数据
                            trySendEachBlockData(tailBlockData);

                            // 更新已发送数据长度
                            hasSentLength = hasSentLength + tailBlockData.length;

                            LogExt.d(TAG, "block length: " + mToSendBlePackageData.length
                                    + " block bytes: " + bytesToHexString(mToSendBlePackageData)
                                    + " sent length: " + hasSentLength + " index: " + i);
                        } else {
                            // 截取前面正常的包
                            System.arraycopy(mToSendBlePackageData, i * mBlockSize, eachBlockData, 0, eachBlockData.length);

                            // 异步任务队列发送单个块数据
                            trySendEachBlockData(eachBlockData);

                            // 更新已发送数据长度
                            hasSentLength = hasSentLength + eachBlockData.length;
                        }

//                        LogExt.d(TAG, "block length: " + mToSendBlePackageData.length
//                                + " block bytes: " + bytesToHexString(mToSendBlePackageData)
//                                + " sent length: " + hasSentLength + " index: " + i);
                    }
                }
            }
        }
    }

2、拆包逻辑大概就是你写的这样，但是蓝牙发送20字节小包做失败重传机制，确保每个小包发送成功。
下面是我之前的解决方法，仅供参考：

    // 通过 while 循环确认，确保每块数据都发送成功
    private void trySendEachBlockData(byte[] bytes) {
        LogExt.d(getTag(),
                "this block length: " + bytes.length
                + " block bytes: " + bytesToHexString(bytes));

        boolean success = false;
        while (!success) {

            // 初始拿到发送结果为 false
            mGotSendResult = false;

            // 异步任务队列发送单个块数据
            sendEachBlockData(bytes);

            // 延时等待检测是否拿到蓝牙发送结果
            while (!mGotSendResult) {
                // 隔 5ms 再检测
                try {
                    Thread.sleep(5);
                } catch (Exception e) {

                }
            }

            // 如果发失败，隔 5ms 再发
            if (mSendOk) {
                // 置标志位，结束大循环
                success = true;
            } else {
                try {
                    Thread.sleep(5);
                } catch (Exception e) {

                }
            }
        }
    }

[lianghao777]

@jimneylee 感谢，我看看先

[lianghao777]

@jimneylee
public void onDataReady(byte[] data) {
Log.e(TAG, "下发固件升级数据: " + ByteUtils.bytes2HexStr(data));
if (data.length > 20) {
int count = data.length / 20;
int rem = data.length % 20;
int i = 0;
while (count-- >= 0) {
int addNum = i++;
byte[] temp;
Log.e(TAG, "下发第几组数据: " + addNum);
Log.e(TAG, "参数为 : count = " + count + " 次数为： =" + data.length / 20);
if (addNum == data.length / 20) {
temp = new byte[rem];
System.arraycopy(data, addNum * 20, temp, 0, rem);
Constants.SEND_RESULT = true;
} else {
Constants.SEND_RESULT = false;
temp = new byte[20];
System.arraycopy(data, addNum * 20, temp, 0, 20);
}
Log.e(TAG, "下发的数据长度: " + temp.length);
write(characteristic, null, temp);
try {
Thread.sleep(Constants.PACKAGE_SENDING_TIME_INTERVAL);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} else {
write(characteristic, null, data);
}
}

偷了个懒，定义了一个标识变量， Constants.SEND_RESULT
这里用这个变量去判断是否读取大包数据~
while (Constants.SEND_RESULT) {
if (!isDataAcknowledged.get()) {
try {
//We need to sleep for a while as the sending 1024 bytes data from ble would take several seconds
//In my circumstances, this can be up to 3 seconds.
////我们需要睡眠一段时间，因为从BLE发送1024字节数据需要几秒钟。
//在我的情况下，这可以长达3秒。
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
continue;
}

        if ((dataLength = inputStream.read(block)) == -1) {
            Lg.f("The file data has all been read...");
            if (listener != null) {
                onStop();
                listener.onFinish();
            }
            break;
        }

[jimneylee]

@lianghao777 不建议这样写，会污染底层库代码。临时解决问题，边学边修改完善，一步步来吧。

[lianghao777]

@jimneylee 受教了，万分感谢

[ArdWang]

我过段时间 我要重写一下

[ArdWang]

ios端你们用的没有问题 @jimneylee 还好用吧

[ArdWang]

安卓端 可以 直接发 256个字节 我试过 @jimneylee

[ArdWang]

你看下这个 https://github.com/radianceltd/RilCompany_DFU025_Android

[ArdWang]

修改 mtu 好像可以