Android BLE蓝牙智能设备固件升级之Bin文件升级方式

已于 2024-02-22 14:57:33 修改
阅读量642 收藏 11
点赞数 6
文章标签： android
于 2023-12-27 20:01:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43866045/article/details/135254405
版权

OTA固件升级文件为.bin类型的升级解说:
这边主要分享升级的一个大致实现思路, 细节方面还需和嵌入式工程师沟通具体的协议内容, 下文涉及的协议仅供参考。欢迎交流哈！！！指令发送和回复解析对照看，基本都是一发一收。

1. 解析.bin升级文件

class BinFileParseUtils {
    companion object {
        fun parseBinFile(inputStream: InputStream?): ArrayList<ByteArray> {
            val mBinBytes = ArrayList<ByteArray>()
            var bufferedInputStream: BufferedInputStream? = null
            var byteArrayOutputStream: ByteArrayOutputStream? = null
            try {
                bufferedInputStream = BufferedInputStream(inputStream)
                byteArrayOutputStream = ByteArrayOutputStream()
                // 操作（分段读取）
                val flush = ByteArray(1024) // 缓冲容器
                var len: Int // 接收长度
                while (bufferedInputStream.read(flush).also { len = it } != -1) {
                    byteArrayOutputStream.write(flush, 0, len)
                }
                byteArrayOutputStream.flush()
                // 获取数据
                val binArray: ByteArray = byteArrayOutputStream.toByteArray()
                if (binArray != null && binArray.isEmpty()) {
                    return mBinBytes
                }
                val totalLength = ceil(binArray.size / 128.0).toInt()
                var blockNumber = 1
                for (i in 0 until totalLength) {
                    val arr = ByteArray(136)
                    if (i == totalLength - 1) {
                        val temp: Int = binArray.size % 128
                        if (temp != 0) {
                            Arrays.fill(arr, 0xff.toByte())
                            // 128 个字节位数补齐
                            System.arraycopy(binArray, 128 * i, arr, 6, temp)
                        } else {
                            System.arraycopy(binArray, 128 * i, arr, 6, 128)
                        }
                    } else {
                        System.arraycopy(binArray, 128 * i, arr, 6, 128)
                    }
                    arr[0] = 0xaa.toByte()
                    arr[1] = 0xab.toByte()
                    arr[2] = 131.toByte()
                    arr[3] = 0x86.toByte()
                    arr[4] = (blockNumber shr 8 and 0xff).toByte() // 高位
                    arr[5] = (blockNumber and 0xff).toByte() // 低位
                    blockNumber++
                    val crcBytes = ByteArray(131)
                    System.arraycopy(arr, 3, crcBytes, 0, 131)
                    val int2Bytes: ByteArray = makeCrc(crcBytes)
                    arr[134] = int2Bytes[0]
                    arr[135] = int2Bytes[1]
                    mBinBytes.add(arr)
                }
            } catch (e: Exception) {
                e.printStackTrace()
            } finally {
                try {
                    inputStream?.close()
                    bufferedInputStream?.close()
                    byteArrayOutputStream?.close()
                } catch (e: Exception) {
                    e.printStackTrace()
                }
            }
            return mBinBytes
        }
    }
}

2. 定义发送指令集

class BinUpdateOrderManager {
    private var mCommandTool: BaseCommand? = null
    private var mCurrentSendOrder: ByteArray? = null
    private val mHandler: Handler by lazy {
        Handler()
    }
    private var mShouldResend = false//是否需要重发当前包

    private val mCheckRunnable: Runnable = Runnable {
        if (mShouldResend) {
            mCommandTool?.write(mCurrentSendOrder)
            MdBleLog.d(HexTypeUpdateUtil.TAG, "重发指令 ${HexUtil.formatHexString(mCurrentSendOrder)}")
            checkReply()
        } else {
            updateFail("指令重发无响应")
        }
    }

    constructor(mCommandTool: BaseCommand) {
        this.mCommandTool = mCommandTool
    }

    /**
     * 升级握手指令
     */
    fun sendHandshake() {
        sendOrder(0xaa, 0xa7, 0x05, 0x81, 0x20, 0x13, 0x01, 0x16)
        MdBleLog.d(BinTypeUpdateUtil.TAG, "升级握手指令 ${mCurrentSendOrder?.bytes2HexString()}")
    }

    /**
     * APP跳转BOOT层指令
     */
    fun sendJump2Boot() {
        sendOrder(0xaa, 0xa7, 0x05, 0x82, 0x20, 0x13, 0x01, 0x16)
        MdBleLog.d(BinTypeUpdateUtil.TAG, "发送APP层跳转Boot层指令 ${mCurrentSendOrder?.bytes2HexString()}")
    }

    /**
     * APP向设备索要种子数据指令
     */
    fun sendGetSeedData() {
        sendOrder(0xaa, 0xa7, 0x05, 0x83, 0x20, 0x13, 0x01, 0x16)
        MdBleLog.d(
            BinTypeUpdateUtil.TAG,
            "发送APP向设备索要种子数据指令 ${mCurrentSendOrder?.bytes2HexString()}"
        )
    }

    /**
     * APP向设备发送秘钥数据指令
     */
    fun sendDecodeKey(dataArray: ByteArray) {
        if (dataArray.isEmpty() || dataArray.size < 4) {
            updateFail("秘钥数据异常")
            return
        }
        val bytes = BinSecretKeyUtils.secretKey(dataArray)
        sendOrder(
            0xaa,
            0xa7,
            0x05,
            0x84,
            bytes[0].toInt(),
            bytes[1].byte2Int(),
            bytes[2].byte2Int(),
            bytes[3].byte2Int()
        )
        MdBleLog.d(BinTypeUpdateUtil.TAG, "APP向设备发送秘钥数据指令 ${mCurrentSendOrder?.bytes2HexString()}")
    }

    /**
     * 擦除FLASH指令
     */
    fun sendClearFlash() {
        sendOrder(0xaa, 0xa7, 0x05, 0x85, 0x20, 0x13, 0x01, 0x16)
        MdBleLog.d(BinTypeUpdateUtil.TAG, "发送擦除FLASH指令 ${mCurrentSendOrder?.bytes2HexString()}")
    }

    /**
     * 发送数据完成指令
     */
    fun sendBinDataComplete() {
        sendOrder(0xaa, 0xa7, 0x05, 0x87, 0x20, 0x13, 0x01, 0x16)
        MdBleLog.d(BinTypeUpdateUtil.TAG, "发送数据完成指令 ${mCurrentSendOrder?.bytes2HexString()}")
    }

    /**
     * 跳转APP指令
     */
    fun sendJump2App() {
        sendOrder(0xaa, 0xa7, 0x05, 0x88, 0x20, 0x13, 0x01, 0x16)
        MdBleLog.d(BinTypeUpdateUtil.TAG, "发送跳转APP指令 ${mCurrentSendOrder?.bytes2HexString()}")
    }

    private fun sendOrder(vararg arr: Int) {
        mCommandTool?.let {
            checkReply(true)
            mCurrentSendOrder = it.connectParams(*arr)
            it.write(mCurrentSendOrder)
        }
    }

    fun sendBin(byteArray: ByteArray) {
        mCommandTool?.let {
            checkReply(true)
            mCurrentSendOrder = byteArray
            it.write(mCurrentSendOrder)
        }
    }

    private fun checkReply(shouldResend: Boolean = false) {
        mShouldResend = shouldResend
        removeDelayCheck()
        mHandler.postDelayed(mCheckRunnable, 6000)
    }

    fun removeDelayCheck() {
        mHandler.removeCallbacks(mCheckRunnable)
    }

    private fun updateFail(desc: String) {
        MdBleLog.d(BinTypeUpdateUtil.TAG, "固件升级失败---UpdateOrderManager: $desc")
        MdBleDataHandler.instance.dispatchEvent(DisPatchEventType.TYPE_UPDATE_FAILURE, desc)
    }
}

3. 解析下位机应答指令

class BinTypeUpdateUtil private constructor() : OnDataHandlerListener {
    private lateinit var mOrderManager: BinUpdateOrderManager
    private var mMaxProgress = 100
    private var mReceiveBackCount = 0
    private var mSendBlockNumber = 0
    private val mDecodeKeys = ByteArray(4)
    private var mBinBytes = ArrayList<ByteArray>() // 升级包byte数组

    companion object {
        val instance = SingletonHolder.holder
        const val TAG = "BinTypeUpdateUtil"
    }

    private object SingletonHolder {
        val holder = BinTypeUpdateUtil()
    }

    fun addDeviceAndStartUpdate(baseBleDevice: BaseBleDevice?, path: String?) {
        if (baseBleDevice?.mCommandTool == null
            || path.isNullOrEmpty()
            || !File(path).exists()
        ) {
            updateFail("addDevice null")
            return
        }
        baseBleDevice.mIsUpDataDevice = true
        MdBleDataHandler.instance.addOnDataHandlerListener(this)
        mOrderManager = BinUpdateOrderManager(baseBleDevice.mCommandTool!!)
        mBinBytes = BinFileParseUtils.parseBinFile(FileInputStream(File(path)))
        mReceiveBackCount = 0
        mSendBlockNumber = 0
        if (mBinBytes.isNotEmpty()) {
            mMaxProgress = 8 + mBinBytes.size
            mOrderManager.sendHandshake()
        } else {
            updateFail("bin文件解析异常")
        }
    }

    override fun onUpdateOtaDataChange(byteArray: ByteArray?) {
        mReceiveBackCount++
        val percent = ceil(mReceiveBackCount * 1.0 / mMaxProgress * 100).toInt()
        MdBleLog.d(TAG, "升级进度 ${percent}%")
        MdBleDataHandler.instance.dispatchEvent(
            DisPatchEventType.TYPE_UPDATE_PROGRESS_PERCENT,
            percent
        )
        byteArray?.let {
            val hexFormatString = it.bytes2HexString()
            when (it[3]) {
                0x81.toByte() -> {
                    MdBleLog.d(TAG, "收到握手指令应答 $hexFormatString")
                    // 01固件工作在APP层；02固件工作在BOOT层；
                    when {
                        byteArray[4] == 0x01.toByte() -> mOrderManager.sendJump2Boot()     // 跳转到BOOT层
                        byteArray[4] == 0x02.toByte() -> mOrderManager.sendGetSeedData()   // APP向设备索要种子数据指令
                        else -> updateFail("握手失败")
                    }
                }
                0x82.toByte() -> {
                    MdBleLog.d(TAG, "收到跳转到BOOT层应答 $hexFormatString")
                    // 跳转到BOOT层成功，APP向设备索要种子数据指令
                    if (byteArray[4] == 0x01.toByte()) {
                        mOrderManager.sendGetSeedData()
                    } else {
                        updateFail("跳转到BOOT层失败")
                    }
                }
                0x83.toByte() -> {
                    MdBleLog.d(TAG, "收到设备回复种子数据 $hexFormatString")
                    mDecodeKeys[0] = it[4]
                    mDecodeKeys[1] = it[5]
                    mDecodeKeys[2] = it[6]
                    mDecodeKeys[3] = it[7]
                    mOrderManager.sendDecodeKey(mDecodeKeys)
                }
                0x84.toByte() -> {
                    MdBleLog.d(TAG, "收到解密应答 $hexFormatString")
                    when (byteArray[4]) {
                        0x01.toByte() -> mOrderManager.sendClearFlash()             // 解密成功
                        0x02.toByte() -> mOrderManager.sendDecodeKey(mDecodeKeys)   // 再次申请解密
                        else -> updateFail("解密失败")
                    }
                }
                0x85.toByte() -> {
                    MdBleLog.d(TAG, "收到flash擦除应答 $hexFormatString")
                    sendBin()  // 开始发送升级包
                }
                0x86.toByte() -> {
                    val receiveBlockNumber: Int =
                        (byteArray[4] and 0xff.toByte()).byte2Int() * 256 + (byteArray[5] and 0xff.toByte()).byte2Int()
                    MdBleLog.d(TAG, "收到发送升级包应答 $receiveBlockNumber -- $hexFormatString")
                    if (receiveBlockNumber > mSendBlockNumber) {
                        mSendBlockNumber = receiveBlockNumber
                        if (mSendBlockNumber < mBinBytes.size) {
                            // 继续发送升级包
                            sendBin()
                        } else {
                            // 发送数据完成指令
                            mOrderManager.sendBinDataComplete()
                        }
                    } else {
                        sendBin()
                    }
                }
                0x87.toByte() -> {
                    MdBleLog.d(TAG, "收到数据完成指令应答 $hexFormatString")
                    if (byteArray[4] == 0x01.toByte()) {
                        //跳转APP指令
                        mOrderManager.sendJump2App()
                    } else {
                        updateFail("接收bin数据错误")
                    }
                }
                0x88.toByte() -> {
                    MdBleLog.d(TAG, "收到跳转APP指令应答 $hexFormatString")
                    if (byteArray[4] == 0x01.toByte()) {
                        //跳转APP指令应答
                        updateSuccess()
                    } else {
                        updateFail("跳转APP失败")
                    }
                }
                0x08.toByte() -> {
                    MdBleLog.d(TAG, "收到升级串口指令错误 $hexFormatString")
                    updateFail("升级串口指令错误")
                }
            }
        }
    }

    private fun sendBin() {
        MdBleLog.d(TAG, "发送bin数据 ${mBinBytes[mSendBlockNumber].bytes2HexString()}")
        mOrderManager.sendBin(mBinBytes[mSendBlockNumber])
    }

    private fun updateSuccess() {
        MdBleLog.d(TAG, "updateSuccess")
        mOrderManager.removeDelayCheck()
        MdBleDataHandler.instance.dispatchEvent(DisPatchEventType.TYPE_UPDATE_SUCCESS)
        MdBleDataHandler.instance.removeDataHandlerListener(this)
    }

    private fun updateFail(exceptionDesc: String) {
        MdBleLog.d(TAG, exceptionDesc)
        MdBleDataHandler.instance.dispatchEvent(DisPatchEventType.TYPE_UPDATE_FAILURE, exceptionDesc)
        MdBleDataHandler.instance.removeDataHandlerListener(this)
    }
}

升级核心步骤如上

伦茨BLE蓝牙ST17H65 OTA升级的遇到的问题
lyltytan的博客
03-31 655
使用>python .\ooo_bin.py .\bleCubeCabinetCode.hex16生成bin文件提示： ModuleNotFoundError: No module named 'intelhex'使用 Python脚本 ‘ ooo_bin.py’把 ‘*.hex16’文件 转换成 ‘*.bin’B>把生成的 “ *.bin”文件放到手机根目录下。A）cmd模式下，cd命令跳到当前目录，C>按如下步骤操作升级。1.SLB升级的"bin"文件生成。0.‘*.hex16’生成。
蓝牙XY-MBD08A串口模块测试及OTA固件升级APP
Newbitinfo的博客
08-31 752
蓝牙透传模块测试APP及OTA固件升级APP（以XY-MBD08A为例） 1、蓝牙模块透传测试APP 新一信息Newbitinfo为开发者提供了iOS/Android透传测试APP，方便开发者前期测试/评估。后续开发者自行开发APP，新一信息可提供测试APP源码给到开发者参考。 APP显示界面如下： ① 模式切换按键(Android测试APP专属),SPP与BLE模式切换 ② 搜索设备后，点击搜...
Android 蓝牙OTA固件升级
Billy_Zuo的博客
03-07 536
只要是通过无线通信方式实现DFU的，都可以叫OTA，比如2G/3G/4G/WiFi/蓝牙/NFC/Zigbee，他们都支持OTA。DFU除了可以通过无线方式（OTA）进行升级，也可以通过有线方式进行升级，比如通过UART，USB或者SPI通信接口来升级设备固件。准确地说，OTA的全称应该是OTA DFU，即通过空中无线方式实现设备固件升级。只不过大家为了方便起见，直接使用OTA来指代固件空中升级（有时候也将OTA称为FOTA，即Firmware OTA）。进行OTA固件升级之前，我们需要先了解几个概念。
OTA升级和Bin包升级
Kslient的博客
03-26 6093
OTA升级－－增量升级 Bin包升级（刷Bin包）－－全部升级/强制升级 OTA是增量升级，在原有基础上下载少量更新文件， OTA 英文全称是Over-the-Air Technology，即空间下载技术的意思。OTA升级是Android系统提供的标准软件升级方式。 完整包就相当于把所有文件重新安装。 强制升级（适用于电视机黑屏，无法正常启动情况） 1、下载强制升级
ST-BlueNrg-lp蓝牙芯片OTA升级过程
浮若于心
02-10 6148
1. “无线”固件升级的概念 “空中下载”(OTA) 固件升级是一种协议，它允许低功耗蓝牙从设备通过空中接收来自低功耗蓝牙主设备的固件映像并将其写入闪存。 为了将事情置于低功耗蓝牙技术的正确环境中，OTA 固件升级框架定义了一项暴露其自身特征的服务，该服务可以与运行在低功耗蓝牙堆栈上的任何给定应用程序使用的其他服务共存。 蓝牙 LE 主控器是由 BlueNRG-LP 开发套件平台通过 USB 连接到 PC 组成的组合系统。 该 BlueNRG-LP 平台由 BlueNRG GUI 驱动。 由于这种选择，
杰里之AC695X SDK0.0.6-P2 以下音箱 SDK 版本出现卡或蓝牙无法升级时需要更换的 ota.bin 文件【篇】
u013820168的博客
12-08 537
对应的 ota.bin 文件在网盘以下路径： 资料“AC695X SDK0.0.6-P2 以下音箱 SDK 出现卡或蓝牙无法升级时需要更换的 OTA.zip”
Android系统Recovery工作原理之使用update.zip升级过程分析（一）---update.zip包的制作
热门推荐
mu0206mu的专栏
03-27 7万+
Android系统Recovery工作原理之使用update.zip升级过程分析（一）---update.zip包的制作          这篇及以后的篇幅将通过分析update.zip包在具体Android系统升级的过程，来理解Android系统中Recovery模式服务的工作原理。我们先从update.zip包的制作开始，然后是Android系统的启动模式分析，Recovery工作原
Android BLE蓝牙智能设备固件升级之DFU升级方式(Nordic芯片)
weixin_43866045的博客
12-27 1174
否则调用升级会有闪退现象，并且启动升级service的时候，需要主动开启通知。应该是常见固件升级方式里最简单的一种，直接使用。及以上，集成版本必须大于等于。创建DfuService。
安卓蓝牙固件升级Demo
11-25
"安卓蓝牙固件升级Demo"是实现这一功能的一个实例项目，通过连接服务器下载更新文件并管理蓝牙设备的升级过程。以下将详细介绍该过程涉及的关键知识点。 1. **蓝牙低功耗（Bluetooth Low Energy, BLE）**：BLE是...
Android BLE中的固件升级与远程控制
BLE固件升级是指通过无线方式对BLE设备的固件进行升级，以修复bug、增加新功能或改进性能。随着技术的不断发展，BLE设备的功能和性能也在不断提升，因此固件升级成为确保设备始终保持最新状态的重要手段。 ## 1.3 ...
nordicDFU升级nordic升级nordic手机开发
03-30
【描述】：Nordic DFU升级是针对Nordic半导体设备的一种便捷升级方式，特别适合手机开发项目。通过这个技术，开发者可以将新的固件通过手机应用程序无线传输到Nordic的硬件设备上，而无需拆卸设备或使用专业工具。这...
android app版本升级（DownloadManager、适配6.0、7.0）
薛定谔的猫
06-20 1万+
说明： 1.本文使用系统DownloadManager在通知栏更新下载进度 2.动态权限使用第三方库EasyPermissions（https://github.com/googlesamples/easypermissions） 3.下载完成的App安装适配7.0 4.提示下载框（AlertDialog）是依附于Activity（UpdateActivity）的,这样做是为了
Android7.1update.zip升级在system/bin下新增可执行文件没有可执行权限问题
LoongEmbedded的专栏
11-21 3382
Android7.1update.zip升级在system/bin下新增可执行文件没有可执行权限问题 外出的设备，只能通过update.zip方式升级，比如要在设备/system/bin目录下增加login，在需要时执行login，升级后发现login文件没有可执行权限msm8937_64:/ # ls -l system/bin/login-rw-r--r-- 1 root root 12564
Android setContentView()源码分析
xiangxiongfly
05-06 413
setContentView() 源码分析
android textview 一个高亮效果
龙之吻T
05-07 248
【代码】android textview 一个高亮效果。
Canal mysql to mysql 增加 online 库同步配置指南
最新发布
qq_35640866的博客
05-07 451
【代码】Canal mysql to mysql 增加 online 库同步配置指南。
android-ndk开发(8): ndk 和 clang 版本对照表
baiyu33的博客
05-06 818
本文给出了查阅 ndk 各个版本 changelog 的方法， 包括 wiki 网站， 和 ndk 源码仓库， 这些 changelog 提供了比较详细的信息。 本文还给出了 ndk 和 clang 版本的对照表， 包括 ndk 字母形式的短版本、 纯数字的版本， 而对应的 clang 版本，则能用于和上游 LLVM 的版本变更做联动的分析。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值