1,简介
2,传输过程
3,代码实现 (我们是使用 android 设备USB 和主板通讯,当然串口也可以.基础知识自行百度)

Xmodem 协议简介:

  在串口通信中广泛使用的异步文件传输协议有Xmodem,Ymodem,Zmodem.本文只介绍 Xmodem,其他两种,未用过,没研究.Xmodem协议分为两种,一种是标准的 Xmode和Xmodem-1k 两个版本.
  Xmodem内容固定长度为 128 个字节,格式如下:

  Xmodem-1k内容固定长度为 1024个字节,格式如下:

控制符定义:

数据包序号:
  据包序号下标是从0x01开始向上递增的，累加到0XFF后将循环反复. (0~255)
数据包序号补码:
  数据包序号按位取反,即 ~数据包序号
校验和的方式有CRC校验和 CheckSum校验:
  使用不同的校验方式,占的字节数不一样哦~
  CRC校验:
    占 2 个字节,,CRC多项式公式为X16+X12+X5+1然后取低16位数据.(网上说的,我也不理解,没研究)

    @JvmStatic
    fun calc16(bytes: ByteArray): ByteArray? {
        var crc = 0x0000.toChar()
        for (b in bytes) {
            crc = (crc.toInt() shl 8 xor crctable[crc.toInt() shr 8 xor b.toInt() and 0x00ff].toInt()).toChar()
        }
        return intToByteArray(crc.toInt() and 0x00ffff)
    }

    @JvmStatic
    fun intToByteArray(i: Int): ByteArray? {
        val result = ByteArray(2)
        result[0] = (i shr 8 and 0xFF).toByte()
        result[1] = (i and 0xFF).toByte()
        return result
    }

  CheckSum校验:
    占1 个字节,对传输的数据进行累加和,然后转成16 进制,用两个字节的来表示,取第 1 位.

    @JvmStatic
    fun getCheckSum(bytes: ByteArray): Byte {
        var checkSum = 0
        for (aByte in bytes) {
            checkSum += aByte.toInt()
        }
        val bytes1 = intToByteArray(checkSum.toLong())
        return bytes1!![1]
    }

    //将 int 转成 byte 数组,文件大小,用两个字节表示
    @JvmStatic
    fun intToByteArray(i: Int): ByteArray? {
        val result = ByteArray(2)
        result[0] = (i shr 8 and 0xFF).toByte()
        result[1] = (i and 0xFF).toByte()
        return result
    }

Xmodem 传输过程:

1、当主板给 Android 设备发送的C或者NAK后，android设备则知道主板已开启 Xmodem 协议传输，然后开始发送数据:SOH/STX+0x01+0xFE+Data[0-127]/Data[0-1024]+数据校验
2、主板接收到数据后,对数据进行校验,数据正确则回复ACK确认字节，android 设备接收到ACK确认后，就认为数据包被接收方正确接收了，接着发送下一包数据.
3、如果android设备NAK字节，则表示需要重新传输刚才的数据包；如果android 设备收到的CAN字节，则表示无条件停止传输。
4、传输完毕后,等待主板唤醒 android 设备,判断固件是否更新成功.(这部分跟主板开发进行协商吧~~)

Xmodem 代码实现:

随意写写,可自行进行封装~~~

public class Xmodem2 {

    public static int checkType = 1;   //校验类型 1是csc/2是check-sum,由主板回复值,判断赋值
    public static int transType = 2;   //传输类型 Xmodem/1K-Xmodem ,android 设备主动触发
    public static final byte SOH = 0x01;    // 开始 Xmodem数据头
    public static final byte STX = 0x02;    // 开始 1K-Xmodem数据头
    public static final byte EOT = 0x04;    // 结束
    public static final byte ACK = 0x06;    // 应答
    public static final byte NAK = 0x15;    // 重传
    public static final byte CAN = 0x18;     // 无条件结束
    public static final byte C = 0x43;      // csc校验
    public static int SECTOR_SIZE = 0;// 以128字节块的形式传输数据
    public static final int MAX_ERRORS = 10; // 最大错误（无应答）包数
    public static UsbSerialPort port;   //写入数据
    public static String filePath;    //文件路径
    public static byte responseACK; //由主板是否回复 ACK,由主板回复值,判断赋值
    public static boolean finishAck = false;  //数据传输结束ACK
    private final ExecutorService executor = Executors.newFixedThreadPool(5);

    public Xmodem2(String path, UsbSerialPort usbSerialPort) {
        filePath = path;
        port = usbSerialPort;
        if (transType == 1)
            SECTOR_SIZE = 128;
        else
            SECTOR_SIZE = 1024;

    }

    public void send() {
        executor.submit(() -> {
            try {
                int errorCount;// 错误包数
                byte blockNumber = 0x01;// 包序号
                int nbytes; // 读取到缓冲区的字节数量
                byte[] sector = new byte[SECTOR_SIZE];  // 初始化数据缓冲区
                // 读取文件初始化
                DataInputStream inputStream = new DataInputStream(new FileInputStream(filePath));
                while ((nbytes = inputStream.read(sector)) > 0) {
                    // 如果最后一包数据小于128个字节，以0xff补齐
                    if (nbytes < SECTOR_SIZE) {
                        for (int i = nbytes; i < SECTOR_SIZE; i++) {
                            sector[i] = (byte) 0X1A;
                        }
                    }

                    // 同一包数据最多发送10次
                    errorCount = 0;
                    while (errorCount < MAX_ERRORS) {
                        // 组包
                        // 控制字符1 + 包序号1 + 包序号的反码1 + 数据128 + 校验 1->crc/2-> check-sum
                        byte[] sendData = new byte[SECTOR_SIZE + (checkType == 1 ? 5 : 4)];
                        sendData[0] = SECTOR_SIZE == 128 ? SOH : STX;
                        sendData[1] = blockNumber;
                        sendData[2] = (byte) ~blockNumber;
                        System.arraycopy(sector, 0, sendData, 3, sector.length);
                        if (checkType == 1) {   //CRC
                            byte[] crc16 = CRC16.calc16(sector);
                            if (transType == 1) { 
                                System.arraycopy(crc16, 0, sendData, 131, crc16.length);    //C+128+ CRC
                            } else {
                                System.arraycopy(crc16, 0, sendData, 1027, crc16.length); //C+1014+ CRC
                            }
                        } else {  // checkSum
                            if (transType == 1) {
                                sendData[131] = CRC16.getCheckSum(sector);         //15+128+ Check-Sum
                            } else {
                                sendData[1027] = CRC16.getCheckSum(sector);    //15+1014+ Check-Sum
                            }
                        }

                        //==============================================
                        String s = Utils.INSTANCE.toHexString(sendData);
                        Log.e("11111", "传输的数据: " + s);
                        //===============================================
                        port.write(sendData, 5000);
                        // 获取应答数据
                        // 如果收到应答数据则跳出循环，发送下一包数据
                        // 未收到应答，错误包数+1，继续重发
                        Thread.sleep(50);
                        if (responseACK == ACK) {
                            responseACK = 0;
                            break;
                        } else {
                            errorCount++;
                        }
                    }
                    // 包序号自增
                    blockNumber = (byte) ((++blockNumber) % 256);
                }
                // 所有数据发送完成后，发送结束标识
                errorCount = 0;
                while (errorCount < MAX_ERRORS) {
                    Log.e("11111", "发送结束标志啦");
                    port.write(new byte[]{EOT}, 5000);
                    Thread.sleep(50);
                    if (responseACK == ACK) {
                        finishAck = true;
                        break;
                    } else {
                        errorCount++;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }
}

使用:

  Xmodem2(path, UsbHelper.INSTANCE.port).send()

---------------------------END-------------------------