精华内容
下载资源
问答
  • hex文件解析

    2020-03-28 16:38:10
    hex(hexadecimal),十六进制的英文缩写,*.hex为后缀的文件为称之为hex文件,主要用于保 存单片机固件,可直接下载到单片机中,故又称为可执行文件 1、 hex文件内容 打开任意一个hex文件,内容如下(为了内容展示...

    hex(hexadecimal),十六进制的英文缩写,*.hex为后缀的文件为称之为hex文件,主要用于保
    存单片机固件,可直接下载到单片机中,故又称为可执行文件

    1、 hex文件内容

    • 打开任意一个hex文件,内容如下(为了内容展示方便,已删除中奖部分内容):

    • 整个文件以行为单位,每行以冒号开头,内容全部为16进制码(以ASCII码形式显示), 2个ASCII码字符表示1个Hex字节。

    2、 hex文件解析

    hex文件的内容都是有规律的编码,我们可以对它进行解析,以第一行 :020000040800F2 为例:

    1) 每一行都以 :(0x3A)开头

    2) 第1个字节0x02 ,表示数据区的字节个数,用ASCII表示就是4个ASCII字符

    3) 第2、3字节0x00, 0x00 ,表示偏移地址或无用填0

    4) 第4个字节0x04, 表示本行记录的数据类型

    • ‘00’ Data Record :用来记录数据, HEX文件的大部分记录都是数据记录
    • ‘01’ End of File Record :用来标识文件结束,放在文件的最后,标识HEX文件的结尾
    • ‘02’ Extended Segment Address Record :用来标识扩展段地址的记录
    • ‘03’ Start Segment Address Record :段地址 STM32不用
    • ‘04’ Extended Linear Address Record :用来标识扩展线性地址
    • ‘05’ Start Linear Address Record :程序启动运行的地址

    5) 第5、6个字节0x08, 0x00即是数据

    6) 第7个字节0xF2是校验字节,校验和的算法为:计算从0x3A 以后(不包括0x3A)的所有各字节的和模256的余。即各字节二进制算术和,不计超过256的溢出值,然后用0x100减去这个算数累加和,得出得值就是此行得校验和。

    7) 每条数据最后还有<0x0d> (回车键)、 <0x0a>(换行键)

    总结:hex文件的数据行可按如下方式解析:

    • 注意:由于每行标识数据地址的只有2Byte,所以最大只能到64K,为了可以保存高地址的数据,就有了Extended Linear Address Record。如果这行的数据类型是0x04,那么,这行的数据就是随后数据的基地址。例如:
    :020000040004F6
    :1000000018F09FE518F09FE518F09FE518F09FE5C0
    :1000100018F09FE5805F20B9F0FF1FE518F09FE51D
    
    • 第一行,是Extended Linear Address Record,里面的数据,也就是基地址是0x0004,
    • 第二行是Data Record,里面的地址值是0x0000。那么数据18F09FE518F09FE518F09FE518F09FE5要写入FLASH中的地址为 (0x0004 << 16) | 0x0000,也就是写入FLASH的0x40000这个地址。
    • 第三行的数据的写入地址为0x40010。当一个HEX文件的数据超过7k的时候,文件中就会出现多个Extended Linear Address Record。

    3、 分析示例:

    • :020000040800F2 -----首行给出烧录的目标地址的高16位 : 0x0800

    • :100000003807002029020008B90300086F03000820 ----烧写到0x0800 0000 处的数据

    • :10001000B5030008D10200084706000800000000F0 ----烧写到0x0800 0010 处的数据

    • :040000050800018965 ----05类型的行对于烧写程序无用

    • :00000001FF ----HEX文件结束行

                                                              --- 完 ---
      

    本文参考安富莱STM32开发板软件参考手册,笔者知识有限,如果发现本文有错误的地方欢迎批评、指正!

    展开全文
  • HEX文件解析

    2021-04-02 15:13:46
    每行从“:”(0x3a)开始,这从文件内容可以看出。以回车键结束(0x0d,0x0a),每行以换行结束。回车换行的十六进制不会显示。 现在开始解析:第一句 后面的数据位数 数据起始地址 数据类型或叫功能码 ...

    开头数据:

    :020000041004E6
    :1000000000800020119B0510AD8D0510A98F0410F4

    每行从“:”(0x3a)开始,这从文件内容可以看出。以回车键结束(0x0d,0x0a),每行以换行结束。回车换行的十六进制不会显示。

    现在开始解析:第一句

     

    后面的数据位数 数据起始地址 数据类型或叫功能码 数据 校验位
    0x02 0x00 0x00 0x04 0x10 0x04 0xE6

    数据类型共有:

    '00'Data Rrecord:用来记录数据,HEX文件的大部分记录都是数据记录

    '01'文件结束记录:用来标识文件结束,放在文件的最后,标识HEX文件的结尾

    '02'扩展段地址记录:用来标识扩展段地址的记录

    '03'开始段地址记录:开始段地址记录

    '04'扩展线性地址记录:用来标识扩展线性地址的记录

    '05'开始线性地址记录:开始线性地址记录

    在文件中主要是0x00。

    现在的0x04,即该行记录的是一个拓展地址(0x10 0x04 是地址信息,用法是将该地址(0x1004<<16) 后作为基地址。并且表示在下一个04类型行出现之前都要使用该地址.也就是下一句的地址0x00 0x00,起始地址就是从0x10040000开始。

    第二句:

    后面的数据位数 数据起始地址 数据类型或叫功能码 数据 校验位
    0x10 0x00 0x00 0x00 00800020119B0510AD8D0510A98F0410(十六进制) 0xF4

     

    后面数据16位,起止地址为0x10040000,类型记录数据

    结尾数据:

    :04000005100400C122
    :00000001FF

    后面的数据位数 数据起始地址 数据类型或叫功能码 数据 校验位
    0x04 0x00 0x00 0x05 100400C1 0x22

     

    数据类型0x05,开始线性地址记录,就是函数入口地址

    在map文件可以看到    __main                                   0x100400c1   Thumb Code     8  __main.o(!!!main)

    数据对应着地址。

    后面的数据位数 数据起始地址 数据类型或叫功能码 数据 校验位
    0x00 0x00 0x00 0x01   FF

     

    数据类型为0x01,表示结束。

    最后一个教校验计算:0xF4 = 0xff & ( 0x100- (0x10+4*(0x00)+0x80+0x00+...+0x04+0x10) ) 

    在nodepad++中,如果校验和不是绿色,则表示校验和错误

     

    展开全文
  • Hex文件解析

    千次阅读 2016-09-18 11:13:07
    Hex文件是MCU的执行文件,需要烧录到MCU中。接下来大概解析一下这个Hex文件的基本内容格式。 每行以冒号开头,内容全部为16进制码(以ASCII码形式显示)。

    Hex文件是MCU的执行文件,需要烧录到MCU中。接下来大概解析一下这个Hex文件的基本内容格式。
    每行以冒号开头,内容全部为16进制码(以ASCII码形式显示)。
    文件格式为:
    这里写图片描述

    例子: :1000C000 FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 40
    :表示一行的开始
    10:表示这一行包含的数据长度,一个字节
    00C0:表示存储的地址,两个字节,这里是在flash的地址0x000000c0.
    00:表示数据类型,一个字节,
    ‘00’ Data Rrecord:用来记录数据,HEX文件的大部分记录都是数据记录
    ‘01’ End of File Record: 用来标识文件结束,放在文件的最后,标识HEX文件的结尾
    ‘02’ Extended Segment Address Record: 用来标识扩展段地址的记录
    ‘03’ Start Segment Address Record:开始段地址记录
    ‘04’ Extended Linear Address Record: 用来标识扩展线性地址的记录
    ‘05’ Start Linear Address Record:开始线性地址记录

    FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:代表具体的数据,这里数据都是FF,16个字节。数据的存储是高位地址在前,低位地址在后。
    40:表示校验码,一个字节。校验码是0x100-这一行数据总和的低字节,然后取低一个字节。

    展开全文
  • 2进制HEX文件解析源码

    2014-04-13 23:01:57
    2进制HEX文件 解析源码
  • 针对蓝牙硬件里的软件程序包HEX文件解析和升级 1、思路 选择手机中的HEX升级包文件,比如(/Download下的 update.hex), 然后通过java读取文件每一行获取每一行的数据,然后根据HEX文件数据的规则来解析, ...

    针对蓝牙硬件里的软件程序包HEX文件解析和升级

    1、思路
        
        选择手机中的HEX升级包文件,比如(/Download下的 update.hex),
        然后通过java读取文件每一行获取每一行的数据,然后根据HEX文件数据的规则来解析,
        
        hex文件数据:
            
            1
        
        hex文件规则:https://blog.csdn.net/a1037488611/article/details/43340055
                     https://www.cnblogs.com/blogzhangwei/p/8781183.html
                     https://blog.csdn.net/artmcu/article/details/8151581?utm_source=blogxgwz1
                     
    2、hex文件中数据要注意的有:
        
        比如:
        
            :020000040800F2
            :04BFF00003000156F3
            :020000040800F2
            :10C00000806B002039C1000869F200083DE5000896
            :10C0100065F20008B9DA0008F91F01080000000005
            :106B20003C2910191729102988E9782A543CF100CA
            :040000050800C12509
            :00000001FF
            
        格式:
            
            :020000040800F2 , 其实就是字节串: 0x02 0x00 0x00 0x04 0x08 0x00 0xF2
            
            第一个 0x02 为数据长度。
          紧跟着后面的0x00 0x00 为地址。
          再后面的0x04为数据类型,类型共分以下几类:
          '00' Data Record
          '01' End of File Record
          '02' Extended Segment Address Record
          '03' Start Segment Address Record
          '04' Extended Linear Address Record
          '05' Start Linear Address Record
          然后,接着0x04后面的两个 0x00 0x00就是数据。最后一个0xFA是校验码。
        
        
        解析:也就是说每一行的数据格式是:[数据长度1Byte]、[数据地址2Byte]、[数据类型1Byte]、[数据nByte]、[校验1Byte]
        
            原数据【:020000040800F2】
            解析:【02  0000  04 0800 F2】  04是段地址数据行
            
            原数据【:04BFF00003000156F3】
            解析:【04  BFF0  00  03000156 F3】 00是有效数据,取的是00后面的4个字节03000156
            
            原数据【:020000040800F2】
            解析:【02  0000  04 0800 F2】  04是段地址数据行
            
            原数据【:10C00000806B002039C1000869F200083DE5000896】
            解析:【10  C000  00 806B002039C1000869F200083DE50008 96】 
                   C000是偏移地址,00是有效数据,取的是00后面的16(10转16进制)个字节806B002039C1000869F200083DE50008
            
            原数据【:10C0100065F20008B9DA0008F91F01080000000005】
            解析:【10  C010  00 65F20008B9DA0008F91F010800000000 05】  
                   C010是偏移地址,00是有效数据,取的是00后面的16(10转16进制)个字节65F20008B9DA0008F91F010800000000
            
            原数据【:106B20003C2910191729102988E9782A543CF100CA】
            解析:【10  6B20  00 3C2910191729102988E9782A543CF100 CA】  
                   6B20是偏移地址,00是有效数据,取的是00后面的16(10转16进制)个字节3C2910191729102988E9782A543CF100
            
            原数据【:040000050800C12509】
            解析:【04  0000  05 0800C125 09】  05是开始行地址记录,一般不会对05数据处理
            
            原数据【:00000001FF】
            解析:【00  0000  01 FF】  01是文件结束标志行

            
    3、文件解析的android端代码:(解析部分重点)

         /**
         * 解析HEX文件,读取每行并拆解成数据对象(包括第一行段地址)
         * @param filePath      String
         * @return              List<FileStruct>
         */
        private static List<FileStruct> analysisFile(String filePath) {
            File tempFile = new File(filePath);
            List<FileStruct> fileStructList = new ArrayList<>();
            InputStream inputStream = null;
            BufferedReader bufferedReader = null;
            try {
                inputStream = new FileInputStream(tempFile);
                //转成 reader 以 行 为单位读取文件
                bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
                //当前行字符串
                String hexLineStr;
                while ((hexLineStr = bufferedReader.readLine()) != null) {
                    if (!hexLineStr.startsWith(":", 0)) {
                        return null;
                    }
                    FileStruct hex = new FileStruct();
                    if (hexLineStr.length() >= 11) {
                        hex.setStart(":");
                        byte[] data = hexString2ByteArray(hexLineStr.substring(1));//判断数据的正确是是不是0—F
                        if (data == null) return null;
                        //解析数据
                        hex.setLength(Integer.parseInt(hexLineStr.substring(1, 3), 16));
                        hex.setOffset(Integer.parseInt(hexLineStr.substring(3, 7), 16));
                        hex.setType(Integer.parseInt(hexLineStr.substring(7, 9), 16));

                        if (0x05 == hex.getType()|| 0x01 == hex.getType()) {//不处理05类型的数据,和01的结尾数据
                            continue;
                        }
                        if (hex.getLength() > 0) {
                            hex.setData(hexLineStr.substring(9, 9 + hex.getLength() * 2));
                        }
                    }
                    if (!checkValue(hexLineStr)) return null;
                    //判断数据类型是否合法,只处理00有效数据
                    fileStructList.add(hex);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    if (inputStream != null) {
                        inputStream.close();
                    }
                    if (bufferedReader != null) {
                        bufferedReader.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return fileStructList;
        }
         这里只是给出读取每一行数据的解析过程,
        具体数据List看自己需要,也可以跟我扯扯,
        交流一下:扫码关注公众号回复(HEX解析),获取微信号加我。

                          2
    4、解析HEX的数据组合成自己对接硬件要求的数据格式,转成字节数组传输写入。
        
        硬件要求的数据格式,比如:段地址+偏移地址+长度+有效数据+校验和
        
    5、写入蓝牙硬件,一般在android端对接蓝牙硬件设备的时候,设备厂商都会给出对应的读写SDK,
        所以集成好SDK(SDK的集成简单,只要注意一些权限即可),然后通过字节流数据写入即可。

        当然没有对应的SDK,自己也可以对蓝牙通信部分配合硬件去调试,也是通过字节写入,调通即可。
        
    6、在解析HEX的过程中会用到16进制10进制的转换、高低位替换、字节流和字符串的转换等等,
        这里给出我写的对应转换方法的工具类。

        

    /**
     * Description: 解析Hex文件工具类
     * Author: BAI
     * Date: 2020/6/19 14:33
     * Email : baiyingbin5@163.com
     **/
    public class HexUtil {
    
        /**
         * 获取Hex文件里的00类型的所有有效数据的字节字符串
         * @param filePath  String 文件地址
         * @return          String 字节字符串  【用做有效00数据的校验和】
         */
        public static String getHexFile00ValidData(String filePath) {
            List<FileStruct> totalList= analysisFile(filePath);
            if(totalList==null){
                return null;
            }
    
            List<List<FileStruct>> partSplitList = getPartSplitList(totalList);
            StringBuilder stringBuilder = new StringBuilder();
    
            //第一段数据默认是版本号信息,所以   不做返回
            for(int partIndex=1;partIndex<partSplitList.size();partIndex++){
                //第一个段地址
                for(int i=1;i<partSplitList.get(partIndex).size();i++){
                    stringBuilder.append(partSplitList.get(partIndex).get(i).getData());
                }
            }
            return stringBuilder.toString();
        }
    
        /**
         * 将16进制字符串转换为byte[]
         *
         * @param hexString String
         * @return          byte[]
         */
        public static byte[] hexString2ByteArray(String hexString) {
            try {
                if (hexString == null || hexString.equals("")) {
                    return null;
                }
                hexString = hexString.toUpperCase();
                int length = hexString.length() / 2;
                char[] hexChars = hexString.toCharArray();
                byte[] d = new byte[length];
                for (int i = 0; i < length; i++) {
                    int pos = i * 2;
                    d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
                }
                return d;
            } catch (Exception e) {
                return null;
            }
        }
    
        /**
         * 字节转成HEX字符串
         * @param src   byte[]
         * @return  String
         */
        public static String bytesToHexString(byte[] src){
            StringBuilder stringBuilder = new StringBuilder();
            if (src == null || src.length <= 0) {
                return null;
            }
            for (byte aSrc : src) {
                int v = aSrc & 0xFF;
                String hv = Integer.toHexString(v).toUpperCase();
                if (hv.length() < 2) {
                    stringBuilder.append(0);
                }
                stringBuilder.append(hv);
            }
            return stringBuilder.toString();
        }
    
        /**
         * Convert char to byte
         *
         * @param c char
         * @return byte
         */
        private static byte charToByte(char c) {
            return (byte) "0123456789ABCDEF".indexOf(c);
        }
    
        /**
         * 校验和必然是256的整数倍,如果有余数则认为校验和失败
         *
         * @return false 校验失败 反正成功
         */
        private static boolean checkValue(String hexLineStr) {
            byte[] buf = hexString2ByteArray(hexLineStr.substring(1));
            if(buf==null){
                return false;
            }
            byte temp = 0;
            for (byte aBuf : buf) {
                temp += aBuf;
            }
            return temp % 0xFF == 0;
        }
    
        /**
         * 字符串(命令、长度、数据)按位异或
         * @param hexString String  Eg: 05 0300 0800 05
         * @return          String
         */
        private static String toXorString(String hexString) {
            hexString = change(hexString);
            String[] b = hexString.split(" ");
            int a = 0;
            for (String aB : b) {
                a = a ^ Integer.parseInt(aB, 16);
            }
            if(a<10){
                return "0" + a;
            }
            return String.format("%02X", a);
        }
    
        /**
         * 按照2字符一组分割成字符串
         * @param content   String
         * @return          String
         */
        private static String change(String content) {
            StringBuilder str = new StringBuilder();
            for (int i = 0; i < content.length(); i++) {
                if (i % 2 == 0) {
                    str.append(" ").append(content.substring(i, i + 1));
                } else {
                    str.append(content.substring(i, i + 1));
                }
            }
            return str.toString().trim();
        }
    
        /**
         * 16进制转10进制
         * @param content String
         * @return        int
         */
        public static int covert16to10(String content){
            int number=0;
            String [] HighLetter = {"A","B","C","D","E","F"};
            Map<String,Integer> map = new HashMap<>();
            for(int i = 0;i <= 9;i++){
                map.put(i+"",i);
            }
            for(int j= 10;j<HighLetter.length+10;j++){
                map.put(HighLetter[j-10],j);
            }
            String[]str = new String[content.length()];
            for(int i = 0; i < str.length; i++){
                str[i] = content.substring(i,i+1);
            }
            for(int i = 0; i < str.length; i++){
                number += map.get(str[i])*Math.pow(16,str.length-1-i);
            }
            return number;
        }
    
        /**
         * 字符串字节进行高低位转换
         * @param hex   String 原字节字符串
         * @return      String 结果字节字符串
         */
        public static String reverseHex(String hex) {
            char[] charArray = hex.toCharArray();
            int length = charArray.length;
            int times = length / 2;
            for (int c1i = 0; c1i < times; c1i += 2) {
                int c2i = c1i + 1;
                char c1 = charArray[c1i];
                char c2 = charArray[c2i];
                int c3i = length - c1i - 2;
                int c4i = length - c1i - 1;
                charArray[c1i] = charArray[c3i];
                charArray[c2i] = charArray[c4i];
                charArray[c3i] = c1;
                charArray[c4i] = c2;
            }
            return new String(charArray);
        }
    
        /**
         * 拆分byte数组
         *
         * @param bytes
         *            要拆分的数组
         * @param size
         *            要按几个组成一份
         * @return byte[][]
         */
        private static List<byte[]> splitBytes(byte[] bytes, int size) {
            double splitLength = Double.parseDouble(size + "");
            int arrayLength = (int) Math.ceil(bytes.length / splitLength);
    
            List<byte[]> resultList = new ArrayList<>();
            int from, to;
            for (int i = 0; i < arrayLength; i++) {
                from = (int) (i * splitLength);
                to = (int) (from + splitLength);
                if (to > bytes.length)
                    to = bytes.length;
                resultList.add(Arrays.copyOfRange(bytes, from, to));
            }
            return resultList;
        }
    
    }
    


        
    7、对数据CRC16Check的算法校验,这个每个硬件的要求都不同,不过都差不多,硬件那边给出的C文件,可以在这个基础上修改。
        

    /**
     * Description: 对HEX文件的00类型的纯数据进行CRC16校验
     * Author: BAI
     * Date: 2020/6/23 17:33
     * Email : baiyingbin5@163.com
     **/
    public class CRC16CheckUtil {
    
        /**
         * 查表法计算CRC16校验
         *
         * @param data 需要计算的字节数组
         */
        public static String getCRC16(byte[] data) {
            byte[] crc16_h = {
                    (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40,
                    (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
                    (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
                    (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40,
                    (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
                    (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40,
                    (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40,
                    (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
                    (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
                    (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40,
                    (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40,
                    (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
                    (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40,
                    (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
                    (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
                    (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40
            };
    
            byte[] crc16_l = {
                    (byte) 0x00, (byte) 0xC0, (byte) 0xC1, (byte) 0x01, (byte) 0xC3, (byte) 0x03, (byte) 0x02, (byte) 0xC2, (byte) 0xC6, (byte) 0x06, (byte) 0x07, (byte) 0xC7, (byte) 0x05, (byte) 0xC5, (byte) 0xC4, (byte) 0x04,
                    (byte) 0xCC, (byte) 0x0C, (byte) 0x0D, (byte) 0xCD, (byte) 0x0F, (byte) 0xCF, (byte) 0xCE, (byte) 0x0E, (byte) 0x0A, (byte) 0xCA, (byte) 0xCB, (byte) 0x0B, (byte) 0xC9, (byte) 0x09, (byte) 0x08, (byte) 0xC8,
                    (byte) 0xD8, (byte) 0x18, (byte) 0x19, (byte) 0xD9, (byte) 0x1B, (byte) 0xDB, (byte) 0xDA, (byte) 0x1A, (byte) 0x1E, (byte) 0xDE, (byte) 0xDF, (byte) 0x1F, (byte) 0xDD, (byte) 0x1D, (byte) 0x1C, (byte) 0xDC,
                    (byte) 0x14, (byte) 0xD4, (byte) 0xD5, (byte) 0x15, (byte) 0xD7, (byte) 0x17, (byte) 0x16, (byte) 0xD6, (byte) 0xD2, (byte) 0x12, (byte) 0x13, (byte) 0xD3, (byte) 0x11, (byte) 0xD1, (byte) 0xD0, (byte) 0x10,
                    (byte) 0xF0, (byte) 0x30, (byte) 0x31, (byte) 0xF1, (byte) 0x33, (byte) 0xF3, (byte) 0xF2, (byte) 0x32, (byte) 0x36, (byte) 0xF6, (byte) 0xF7, (byte) 0x37, (byte) 0xF5, (byte) 0x35, (byte) 0x34, (byte) 0xF4,
                    (byte) 0x3C, (byte) 0xFC, (byte) 0xFD, (byte) 0x3D, (byte) 0xFF, (byte) 0x3F, (byte) 0x3E, (byte) 0xFE, (byte) 0xFA, (byte) 0x3A, (byte) 0x3B, (byte) 0xFB, (byte) 0x39, (byte) 0xF9, (byte) 0xF8, (byte) 0x38,
                    (byte) 0x28, (byte) 0xE8, (byte) 0xE9, (byte) 0x29, (byte) 0xEB, (byte) 0x2B, (byte) 0x2A, (byte) 0xEA, (byte) 0xEE, (byte) 0x2E, (byte) 0x2F, (byte) 0xEF, (byte) 0x2D, (byte) 0xED, (byte) 0xEC, (byte) 0x2C,
                    (byte) 0xE4, (byte) 0x24, (byte) 0x25, (byte) 0xE5, (byte) 0x27, (byte) 0xE7, (byte) 0xE6, (byte) 0x26, (byte) 0x22, (byte) 0xE2, (byte) 0xE3, (byte) 0x23, (byte) 0xE1, (byte) 0x21, (byte) 0x20, (byte) 0xE0,
                    (byte) 0xA0, (byte) 0x60, (byte) 0x61, (byte) 0xA1, (byte) 0x63, (byte) 0xA3, (byte) 0xA2, (byte) 0x62, (byte) 0x66, (byte) 0xA6, (byte) 0xA7, (byte) 0x67, (byte) 0xA5, (byte) 0x65, (byte) 0x64, (byte) 0xA4,
                    (byte) 0x6C, (byte) 0xAC, (byte) 0xAD, (byte) 0x6D, (byte) 0xAF, (byte) 0x6F, (byte) 0x6E, (byte) 0xAE, (byte) 0xAA, (byte) 0x6A, (byte) 0x6B, (byte) 0xAB, (byte) 0x69, (byte) 0xA9, (byte) 0xA8, (byte) 0x68,
                    (byte) 0x78, (byte) 0xB8, (byte) 0xB9, (byte) 0x79, (byte) 0xBB, (byte) 0x7B, (byte) 0x7A, (byte) 0xBA, (byte) 0xBE, (byte) 0x7E, (byte) 0x7F, (byte) 0xBF, (byte) 0x7D, (byte) 0xBD, (byte) 0xBC, (byte) 0x7C,
                    (byte) 0xB4, (byte) 0x74, (byte) 0x75, (byte) 0xB5, (byte) 0x77, (byte) 0xB7, (byte) 0xB6, (byte) 0x76, (byte) 0x72, (byte) 0xB2, (byte) 0xB3, (byte) 0x73, (byte) 0xB1, (byte) 0x71, (byte) 0x70, (byte) 0xB0,
                    (byte) 0x50, (byte) 0x90, (byte) 0x91, (byte) 0x51, (byte) 0x93, (byte) 0x53, (byte) 0x52, (byte) 0x92, (byte) 0x96, (byte) 0x56, (byte) 0x57, (byte) 0x97, (byte) 0x55, (byte) 0x95, (byte) 0x94, (byte) 0x54,
                    (byte) 0x9C, (byte) 0x5C, (byte) 0x5D, (byte) 0x9D, (byte) 0x5F, (byte) 0x9F, (byte) 0x9E, (byte) 0x5E, (byte) 0x5A, (byte) 0x9A, (byte) 0x9B, (byte) 0x5B, (byte) 0x99, (byte) 0x59, (byte) 0x58, (byte) 0x98,
                    (byte) 0x88, (byte) 0x48, (byte) 0x49, (byte) 0x89, (byte) 0x4B, (byte) 0x8B, (byte) 0x8A, (byte) 0x4A, (byte) 0x4E, (byte) 0x8E, (byte) 0x8F, (byte) 0x4F, (byte) 0x8D, (byte) 0x4D, (byte) 0x4C, (byte) 0x8C,
                    (byte) 0x44, (byte) 0x84, (byte) 0x85, (byte) 0x45, (byte) 0x87, (byte) 0x47, (byte) 0x46, (byte) 0x86, (byte) 0x82, (byte) 0x42, (byte) 0x43, (byte) 0x83, (byte) 0x41, (byte) 0x81, (byte) 0x80, (byte) 0x40
            };
    
            int crc;
            int ucCRCHi = 0x00ff;
            int ucCRCLo = 0x00ff;
            int iIndex;
            for (byte aData : data) {
                iIndex = (ucCRCLo ^ aData) & 0x00ff;
                ucCRCLo = ucCRCHi ^ crc16_h[iIndex];
                ucCRCHi = crc16_l[iIndex];
            }
    
            crc = ((ucCRCHi & 0x00ff) << 8) | (ucCRCLo & 0x00ff) & 0xffff;
            //高低位互换,输出符合相关工具对Modbus CRC16的运算
            crc = ( (crc & 0xFF00) >> 8) | ( (crc & 0x00FF ) << 8);
            return String.format("%04X", crc);
        }
    
    }

    8、具体hex解析逻辑可以具体沟通。
        

     

    展开全文
  • CC2530 Hex文件解析

    千次阅读 2015-01-28 17:22:31
    介绍了CC2530的Hex文件解析
  • Intel Hex文件解析

    2019-07-17 10:54:27
    ccs属性设置可以生成hex文件,hex是...和校验和,下边是用vs对hex文件进行读取和解析,得到地址和内容。 include"stdio.h" #include"MCU_header.h" /* void writeExcel(void) { FILE *fp = NULL; float t;...
  • hex文件解析实现代码

    千次阅读 2018-07-05 14:09:23
    Hex文件格式介绍(介绍部分转载地址:http://www.forwhat.cn/post-240.html)Hex文件是可以烧录到MCU中,被MCU执行的...Hex文件可以按照如下的方式进行拆分来分析其中的内容:例如 “:1000080080318B1E0828092820280...
  • HEX文件解析C语言源代码

    千次阅读 2019-04-04 13:39:44
    下面是Hex升级文件解析方法,上位机调试用,能够将Hex的各个Block进行分组,每个块的起始地址和大小,总字节数等信息提取. void ReadHexFileToStruct(char *FileName, HEX_FEIL_T *HexFile) { FILE *fp; ssize_t ...
  • 2.CC2530-hex文件解析

    2020-08-11 17:56:21
    需要用到程序升级,所以需要简单了解一下单片机生成的hex文件。 通常hex文件打开如上图所示:冒号+一堆十六进制数据; 各部分含义如下 数据长度1Byte+偏移地址2Byte+指令类型1Byte+数据nByte+校验值1Byte 指令类型...
  • 简单的Hex文件解析

    2016-09-01 09:36:57
    最近在做一个 Bootload,需要用到Hex文件 Hex的格式如下,网上也很多 第一个字节 0x10表示本行数据的长度; 第二、三字节 0x00 0x08表示本行数据的起始地址; 第四字节 0x00表示数据类型,数据类型有:...
  • Intel HEX由任意数量的十六进制记录组成。每个记录包含5个域,它们按以下格式排列: :(冒号)每个Intel HEX记录都由冒号开头; LL是数据长度域,它代表记录当中...01 – 文件结束记录(End of FileRecord) 0...
  • Intel HEX文件解析

    2017-07-22 21:49:00
    Intel Hex文件解析器V1.0 Hex文件的格式例如以下: RecordMark RecordLength LoadOffset RecordType Data Checksum 在Intel Hex文件里,RecordMark规定为“:” */ #pragma warning(disable:4996) #define MAX_BUFFER...
  • 1、hex文件以ascii形式,按照行来记录数据 2、每一行从:开始,每至少2个字符表示一组16进制数据,格式为 :BBAAAATTHHHH....HHHCC  BB -- 16进制,表示此行数据长度字节数,表示HH的数目  AAAA -- 16进制,表示数据...
  • 00 关于HexHex文件格式(本文讲的是Intel Hex)是好多好多年以前定义的格式,解析这文件的工具网上...话说回来,常用的解析Hex文件的工具有:IntelHex(Python),bincopy(Python)以及SRecordizer(C++),当然还有其他的...
  • 1. 程序的功能 可解析大于64KB的HEX文件。限于时间条件,笔者只测试了两个样例,数据域大小分别为8332B和1.61MB 将解析得到的结果打印出来,包括: - 起始地址 ...HEX文件解析,相关函数:hex2bin() 考虑到H
  • HEX文件格式文档(用于解析HEX文件)
  • 1. 程序的功能可解析大于64KB的HEX文件。限于时间条件,笔者只测试了两个样例,... 程序解读HEX文件解析,相关函数:hex2bin()考虑到HEX文件通常不会很大,所以一次性读取全部内容,每1行为1个list,然后逐行分析...
  • Hex文件格式解析

    2018-03-28 17:36:05
    Hex文件是可以烧写到单片机中,被单片机执行的一种文件格式,生成Hex文件的方式由很多种,可以通过不同的编译器将C程序或者汇编程序编译生成hex。 Hex文件如果用特殊的程序来查看(一般记事本就可以实现)。打开后...
  • 前言最近在研究STM32的IAP升级功能,发现大多数的IAP...只能全部重新烧写,为此研究了一下IAP升级时使用hex格式文件hex格式文件每行数据都包含烧写的地址信息,可确保出错后可以方便定位到哪一段地址烧写错误。hex...
  • hex文件、s19文件解析

    2020-10-12 14:01:15
    s19文件:https://www.cnblogs.com/-XZH-/p/13734410.html hex文件:https://www.cnblogs.com/-XZH-/p/13780352.html

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 259
精华内容 103
关键字:

hex文件解析