精华内容
下载资源
问答
  • // 读取十六进制文件(main.hex),并将其按Hex格式规定,对不同格式域进行划分// 将划分后的格式写入main.txt文件,根据Hex格式,对响应的Flash存储单元赋值// 将Flash存储单元写入main_formated.txt中// 请将main....

    // 读取十六进制文件(main.hex),并将其按Hex格式规定,对不同格式域进行划分

    // 将划分后的格式写入main.txt文件,根据Hex格式,对响应的Flash存储单元赋值

    // 将Flash存储单元写入main_formated.txt中

    // 请将main.hex放在改程序的统一目录下

    // 作者:nuaazdh

    // 时间:2012年3月16日 15:57:52

    #include

    #include

    #define FLASHVOLUM 16 //Flash的容量,以K为单位

    void FormatTran(char *dst,const char *src);

    int HexToDec(char *src);

    void TranHex(char *flashbuffer,char *formatcmd,int flashsize);

    void PrintFlash(char *flashbuffer,int flashsize);

    void WriteFlashToFile(char *flashbuffer,char *filename,int flashsize);

    char *ExtraSubStr(const char *src,int startIndex,int len);

    void main()

    {

    FILE *fp;

    FILE *resultfp;

    int flashsize=2*FLASHVOLUM*1024*sizeof(char);//flash的存储单元个数

    char *buffer=malloc(sizeof(char)*100);//存储hex文件的一行内容

    char *trsbuffer=malloc(sizeof(char)*200);//存储hex文件解析后的内容

    char *flashbuffer=malloc(flashsize);//存储Flash中的内容

    if(buffer==NULL||trsbuffer==NULL||flashbuffer==NULL){//申请空间失败

    printf("Apply for memory failed.!\n");

    exit(0);

    }

    memset(flashbuffer,'F',flashsize);//将Flash初始时全部清1

    fp=fopen("main.hex","r");

    resultfp=fopen("main.txt","w");

    if(resultfp==NULL||fp==NULL){//打开文件失败

    printf("Open file error.\n");

    exit(0);

    }

    while(fscanf(fp,"%s",buffer)!=EOF){//读取文件所有内容

    //HextoBin(trsbuffer,buffer);

    printf("%s\n",buffer);//控制台显示

    FormatTran(trsbuffer,buffer);

    //printf("Length:%d\n",strlen(buffer));//显示字符串长度

    fprintf(resultfp,"%s\n",trsbuffer);//写入文件

    TranHex(flashbuffer,buffer,flashsize);

    }

    PrintFlash(flashbuffer,2*1024);//仅显示前2K的内容

    WriteFlashToFile(flashbuffer,"main_formated.txt",2*1024);//将前2K的内容写入文件"main_formated.txt"中

    //释放内存

    free(buffer);

    free(trsbuffer);

    free(flashbuffer);

    //关闭文件

    fclose(fp);

    fclose(resultfp);

    /* //HexToDex()函数测试代码

    char *src=malloc(sizeof(char)*5);

    int value;

    src[0]='2';src[1]='F';src[2]='1';src[3]='F';src[4]='\0';

    value=HexToDec(src);

    printf("The value of the hex string:%d",value);

    */

    /*

    //ExtraSubStr()函数测试代码

    char *src=":10003000758180121086D2A400000000C2A40000C6";

    char *substr;

    substr=ExtraSubStr(src,1,2);

    printf("SubString:%s\n",substr);

    printf("Change to Number:%d",HexToDec(substr));

    */

    }

    void TranHex(char *flashbuffer,char *formatcmd,int flashsize){

    //按formatcmd字符串描述,以hex文件格式修改flashbuffer中的存储单元

    //如 formatcmd=":03000000020030CB"

    //则将flahsbuffer中以"0000"开始的连续"03"个内存单元,内容为"020030"

    //flashsize:表示flash的存储单元个数

    char *eofstring=":00000001FF";

    int startadd;//formatcmd指示的起始地址

    int count;//formatcmd指示的数据单元个数

    int p,q;//索引指针

    if(strcmp(formatcmd,eofstring)==0){//结束标志

    printf("End of file.\n");

    return;

    }

    if(formatcmd[0]!=':'){//不是以":"开始

    printf("Format wrong!\n");

    return;

    }

    if(strlen(formatcmd)<11){//字符串长度小于11

    printf("Format wrong!\n");

    return;

    }

    count=HexToDec(ExtraSubStr(formatcmd,1,2));//获得数据单元长度

    startadd=2*HexToDec(ExtraSubStr(formatcmd,3,4));//获得起始地址

    if(strlen(formatcmd)<11+count*2){//字符串中数据损坏(丢失)

    printf("File has been damaged!\n");

    return;

    }

    for(p=0;p

    flashbuffer[startadd+p]=formatcmd[9+p];

    }

    }

    void FormatTran(char *dst,const char *src){

    //格式解析,将一行Hex文件字符串src,按Hex文件组织格式

    //划分出不同的块,块之间通过空格隔开

    // ":llaaaatt[dd]cc"

    // ":"行开始标志;"ll"数据长度;"aaaa"起始地址;"tt"数据类型;"dd"数据;"cc"校验

    //解析后为:": ll aaaa tt [dd] cc"

    int srclen=strlen(src);

    //printf("Length of src:%d",srclen);

    int p=0,q=0;//索引,p为src的索引,q为dst索引

    int i;//循环标志

    while(p<=srclen){//循环,对src按格式解析

    if(p==0){

    if(src[p]!=':'){//是否以":"开始

    printf("Format wrong! Please check the format of the file.\n");

    break;

    }

    else{

    dst[q++]=':';dst[q++]=' ';

    p++;continue;

    }

    }

    if(p==1){

    for(i=0;i<2;i++){//提取两位的"ll"

    dst[q++]=src[p++];

    }

    dst[q++]=' ';continue;

    }

    if(p==3){

    for(i=0;i<4;i++){//提取四位的"aaaa"

    dst[q++]=src[p++];

    }

    dst[q++]=' ';continue;

    }

    if(p==7){

    for(i=0;i<2;i++){//提取两位的"tt"

    dst[q++]=src[p++];

    }

    dst[q++]=' ';continue;

    }

    for(i=0;i<2;i++){//将dst的数据位以两个为一组,用空格隔开

    dst[q++]=src[p++];

    }

    dst[q++]=' ';

    }

    dst[q]='\0';//结束标志

    }

    int HexToDec(char *src){

    //将src中的无符号十六进制字符串转为十进制数

    //如src="001A",则返回26

    //字符串src需要以'\0'作为结束标志

    int value=0,srclen=strlen(src);

    int i;

    for(i=0;i

    if(src[i]<='9'&&src[i]>='0'){

    value=value*16+(int)(src[i]-'0');

    }

    else if(src[i]<='f'&&src[i]>='a'){

    value=value*16+(int)(src[i]-'a'+10);

    }else{

    value=value*16+(int)(src[i]-'A'+10);

    }

    }

    return value;//返回转换后的数值

    }

    char *ExtraSubStr(const char *src,int startIndex,int len){

    //提取子串,从src中提取自startIndex开始的连续len个字节,构成子串

    char *substr=malloc(sizeof(char)*(len+1));

    int i=0;

    if(substr==NULL){

    printf("Apply for memory failed.\n");

    return NULL;

    }

    if(strlen(src)

    printf("Index exceeds bounds.\n");

    return NULL;

    }

    for(i=0;i

    substr[i]=src[startIndex+i];

    }

    substr[len]='\0';//添加字符串末尾标志

    return substr;

    }

    void PrintFlash(char *flashbuffer,int flashsize){

    //flashbuffer:内存单元指针;flashsize:flash存储单元个数,即字节数

    //输出Flash中的内容

    int rowlen=16;//每行16个字节

    int i,j;

    printf("Flash:%d\n",flashsize);

    for(i=0;i

    if((i/2)%(rowlen)==0){

    printf("\n%06X\t",i/2);//内存单元地址输出格式:6位十六进制(A~F大写)

    }

    printf("%c%c ",flashbuffer[i],flashbuffer[i+1]);

    }

    }

    void WriteFlashToFile(char *flashbuffer,char *filename,int flashsize){

    //将Flash的内容写入文件中

    //flashbuffer:内存单元指针;filename:要写入的文件文件名;

    //flashsize:写入的长度,以字节计

    FILE *fp;

    int i,rowlen=16;

    if((fp=fopen(filename,"w"))==NULL){

    printf("Open file error.\n");

    exit(0);

    }

    //开始写入

    for(i=0;i

    if((i/2)%(rowlen)==0){

    if(i!=0){//不是第一行,遇到写满16个单元换行

    fprintf(fp,"\n");

    }

    fprintf(fp,"%06X\t",i/2);//内存单元地址输出格式:6位十六进制(A~F大写)

    }

    fprintf(fp,"%c%c ",flashbuffer[i],flashbuffer[i+1]);

    }

    fclose(fp);

    }

    原Hex文件内容:

    0_1331963357ioUU.gif

    去除Hex格式后,得到响应Flash存储单元中的内容:

    0_1331963368ttzj.gif

    展开全文
  • C语言 C语言读取十六进制文件.hex

    千次阅读 2014-08-29 10:50:22
    // 读取十六进制文件(main.hex),并将其按Hex格式规定,对不同格式域进行划分 // 将划分后的格式写入main.txt文件,根据Hex格式,对响应的Flash存储单元赋值 // 将Flash存储单元写入main_formated.txt中 //...
    
    1. // 读取十六进制文件(main.hex),并将其按Hex格式规定,对不同格式域进行划分  
    2. // 将划分后的格式写入main.txt文件,根据Hex格式,对响应的Flash存储单元赋值  
    3. // 将Flash存储单元写入main_formated.txt中  
    4. // 请将main.hex放在改程序的统一目录下  
    5. // 作者:nuaazdh  
    6. // 时间:2012年3月16日 15:57:52  
    7. #include <stdio.h>  
    8. #include <stdlib.h>  
    9. #define FLASHVOLUM 16   //Flash的容量,以K为单位  
    10.   
    11. void FormatTran(char *dst,const char *src);  
    12. int HexToDec(char *src);  
    13. void TranHex(char *flashbuffer,char *formatcmd,int flashsize);  
    14. void PrintFlash(char *flashbuffer,int flashsize);  
    15. void WriteFlashToFile(char *flashbuffer,char *filename,int flashsize);  
    16. char *ExtraSubStr(const char *src,int startIndex,int len);  
    17. void main()  
    18. {  
    19.     FILE *fp;  
    20.     FILE *resultfp;  
    21.     int  flashsize=2*FLASHVOLUM*1024*sizeof(char);//flash的存储单元个数  
    22.     char *buffer=malloc(sizeof(char)*100);//存储hex文件的一行内容  
    23.     char *trsbuffer=malloc(sizeof(char)*200);//存储hex文件解析后的内容  
    24.     char *flashbuffer=malloc(flashsize);//存储Flash中的内容  
    25.     if(buffer==NULL||trsbuffer==NULL||flashbuffer==NULL){//申请空间失败  
    26.         printf("Apply for memory failed.!\n");  
    27.         exit(0);  
    28.     }  
    29.     memset(flashbuffer,'F',flashsize);//将Flash初始时全部清1  
    30.     fp=fopen("main.hex","r");  
    31.     resultfp=fopen("main.txt","w");  
    32.     if(resultfp==NULL||fp==NULL){//打开文件失败  
    33.         printf("Open file error.\n");  
    34.         exit(0);  
    35.     }  
    36.     while(fscanf(fp,"%s",buffer)!=EOF){//读取文件所有内容  
    37.         //HextoBin(trsbuffer,buffer);  
    38.         printf("%s\n",buffer);//控制台显示  
    39.         FormatTran(trsbuffer,buffer);  
    40.         //printf("Length:%d\n",strlen(buffer));//显示字符串长度  
    41.         fprintf(resultfp,"%s\n",trsbuffer);//写入文件  
    42.         TranHex(flashbuffer,buffer,flashsize);  
    43.     }  
    44.     PrintFlash(flashbuffer,2*1024);//仅显示前2K的内容  
    45.     WriteFlashToFile(flashbuffer,"main_formated.txt",2*1024);//将前2K的内容写入文件"main_formated.txt"中  
    46.     //释放内存  
    47.     free(buffer);  
    48.     free(trsbuffer);  
    49.     free(flashbuffer);  
    50.     //关闭文件  
    51.     fclose(fp);  
    52.     fclose(resultfp);  
    53.   
    54.   
    55. /*  //HexToDex()函数测试代码 
    56.     char *src=malloc(sizeof(char)*5); 
    57.     int value; 
    58.     src[0]='2';src[1]='F';src[2]='1';src[3]='F';src[4]='\0'; 
    59.     value=HexToDec(src); 
    60.     printf("The value of the hex string:%d",value); 
    61. */  
    62. /* 
    63.     //ExtraSubStr()函数测试代码 
    64.     char *src=":10003000758180121086D2A400000000C2A40000C6"; 
    65.     char *substr; 
    66.     substr=ExtraSubStr(src,1,2); 
    67.     printf("SubString:%s\n",substr); 
    68.     printf("Change to Number:%d",HexToDec(substr)); 
    69. */  
    70. }  
    71.   
    72. void TranHex(char *flashbuffer,char *formatcmd,int flashsize){  
    73.     //按formatcmd字符串描述,以hex文件格式修改flashbuffer中的存储单元  
    74.     //如 formatcmd=":03000000020030CB"  
    75.     //则将flahsbuffer中以"0000"开始的连续"03"个内存单元,内容为"020030"  
    76.     //flashsize:表示flash的存储单元个数  
    77.     char *eofstring=":00000001FF";  
    78.     int startadd;//formatcmd指示的起始地址  
    79.     int count;//formatcmd指示的数据单元个数  
    80.     int p,q;//索引指针  
    81.     if(strcmp(formatcmd,eofstring)==0){//结束标志  
    82.         printf("End of file.\n");  
    83.         return;  
    84.     }  
    85.     if(formatcmd[0]!=':'){//不是以":"开始  
    86.         printf("Format wrong!\n");  
    87.         return;  
    88.     }  
    89.     if(strlen(formatcmd)<11){//字符串长度小于11  
    90.         printf("Format wrong!\n");  
    91.         return;  
    92.     }  
    93.     count=HexToDec(ExtraSubStr(formatcmd,1,2));//获得数据单元长度  
    94.     startadd=2*HexToDec(ExtraSubStr(formatcmd,3,4));//获得起始地址  
    95.     if(strlen(formatcmd)<11+count*2){//字符串中数据损坏(丢失)  
    96.         printf("File has been damaged!\n");  
    97.         return;  
    98.     }  
    99.     for(p=0;p<count*2;p++){  
    100.         flashbuffer[startadd+p]=formatcmd[9+p];  
    101.     }  
    102. }  
    103.   
    104. void FormatTran(char *dst,const char *src){  
    105.     //格式解析,将一行Hex文件字符串src,按Hex文件组织格式  
    106.     //划分出不同的块,块之间通过空格隔开  
    107.     // ":llaaaatt[dd]cc"  
    108.     // ":"行开始标志;"ll"数据长度;"aaaa"起始地址;"tt"数据类型;"dd"数据;"cc"校验  
    109.     //解析后为:": ll aaaa tt [dd] cc"  
    110.     int srclen=strlen(src);  
    111.     //printf("Length of src:%d",srclen);  
    112.     int p=0,q=0;//索引,p为src的索引,q为dst索引  
    113.     int i;//循环标志  
    114.     while(p<=srclen){//循环,对src按格式解析  
    115.         if(p==0){  
    116.             if(src[p]!=':'){//是否以":"开始  
    117.                 printf("Format wrong! Please check the format of the file.\n");  
    118.                 break;  
    119.             }  
    120.             else{  
    121.                 dst[q++]=':';dst[q++]=' ';  
    122.                 p++;continue;  
    123.             }  
    124.         }  
    125.         if(p==1){  
    126.             for(i=0;i<2;i++){//提取两位的"ll"  
    127.                 dst[q++]=src[p++];  
    128.             }  
    129.             dst[q++]=' ';continue;  
    130.         }  
    131.         if(p==3){  
    132.             for(i=0;i<4;i++){//提取四位的"aaaa"  
    133.                 dst[q++]=src[p++];  
    134.             }  
    135.             dst[q++]=' ';continue;  
    136.         }  
    137.         if(p==7){  
    138.             for(i=0;i<2;i++){//提取两位的"tt"  
    139.                 dst[q++]=src[p++];  
    140.             }  
    141.             dst[q++]=' ';continue;  
    142.         }  
    143.         for(i=0;i<2;i++){//将dst的数据位以两个为一组,用空格隔开  
    144.                 dst[q++]=src[p++];  
    145.         }  
    146.         dst[q++]=' ';  
    147.     }  
    148.     dst[q]='\0';//结束标志  
    149. }  
    150.   
    151. int HexToDec(char *src){  
    152.     //将src中的无符号十六进制字符串转为十进制数  
    153.     //如src="001A",则返回26  
    154.     //字符串src需要以'\0'作为结束标志  
    155.     int value=0,srclen=strlen(src);  
    156.     int i;  
    157.     for(i=0;i<srclen;i++){  
    158.         if(src[i]<='9'&&src[i]>='0'){  
    159.             value=value*16+(int)(src[i]-'0');  
    160.         }  
    161.         else if(src[i]<='f'&&src[i]>='a'){  
    162.             value=value*16+(int)(src[i]-'a'+10);  
    163.         }else{  
    164.             value=value*16+(int)(src[i]-'A'+10);  
    165.         }  
    166.     }  
    167.     return value;//返回转换后的数值  
    168. }  
    169.   
    170. char *ExtraSubStr(const char *src,int startIndex,int len){  
    171.     //提取子串,从src中提取自startIndex开始的连续len个字节,构成子串  
    172.     char *substr=malloc(sizeof(char)*(len+1));  
    173.     int i=0;  
    174.     if(substr==NULL){  
    175.         printf("Apply for memory failed.\n");  
    176.         return NULL;  
    177.     }  
    178.     if(strlen(src)<startIndex+len){  
    179.         printf("Index exceeds bounds.\n");  
    180.         return NULL;  
    181.     }  
    182.     for(i=0;i<len;i++){//提取子串  
    183.         substr[i]=src[startIndex+i];  
    184.     }  
    185.     substr[len]='\0';//添加字符串末尾标志  
    186.     return substr;  
    187. }  
    188.   
    189. void PrintFlash(char *flashbuffer,int flashsize){  
    190.     //flashbuffer:内存单元指针;flashsize:flash存储单元个数,即字节数  
    191.     //输出Flash中的内容  
    192.     int rowlen=16;//每行16个字节  
    193.     int i,j;  
    194.     printf("Flash:%d\n",flashsize);  
    195.     for(i=0;i<flashsize;i+=2){  
    196.         if((i/2)%(rowlen)==0){  
    197.             printf("\n%06X\t",i/2);//内存单元地址输出格式:6位十六进制(A~F大写)  
    198.         }  
    199.         printf("%c%c ",flashbuffer[i],flashbuffer[i+1]);  
    200.     }  
    201. }  
    202.   
    203. void WriteFlashToFile(char *flashbuffer,char *filename,int flashsize){  
    204.     //将Flash的内容写入文件中  
    205.     //flashbuffer:内存单元指针;filename:要写入的文件文件名;  
    206.     //flashsize:写入的长度,以字节计  
    207.     FILE *fp;  
    208.     int i,rowlen=16;  
    209.     if((fp=fopen(filename,"w"))==NULL){  
    210.         printf("Open file error.\n");  
    211.         exit(0);  
    212.     }  
    213.     //开始写入  
    214.     for(i=0;i<flashsize;i+=2){  
    215.         if((i/2)%(rowlen)==0){  
    216.             if(i!=0){//不是第一行,遇到写满16个单元换行  
    217.                 fprintf(fp,"\n");  
    218.             }  
    219.             fprintf(fp,"%06X\t",i/2);//内存单元地址输出格式:6位十六进制(A~F大写)  
    220.         }  
    221.         fprintf(fp,"%c%c ",flashbuffer[i],flashbuffer[i+1]);  
    222.     }  
    223.     fclose(fp);  
    224. }  
    225. // 读取十六进制文件(main.hex),并将其按Hex格式规定,对不同格式域进行划分
      // 将划分后的格式写入main.txt文件,根据Hex格式,对响应的Flash存储单元赋值
      // 将Flash存储单元写入main_formated.txt中
      // 请将main.hex放在改程序的统一目录下
      // 作者:nuaazdh
      // 时间:2012年3月16日 15:57:52
      #include <stdio.h>
      #include <stdlib.h>
      #define FLASHVOLUM 16   //Flash的容量,以K为单位
      
      void FormatTran(char *dst,const char *src);
      int HexToDec(char *src);
      void TranHex(char *flashbuffer,char *formatcmd,int flashsize);
      void PrintFlash(char *flashbuffer,int flashsize);
      void WriteFlashToFile(char *flashbuffer,char *filename,int flashsize);
      char *ExtraSubStr(const char *src,int startIndex,int len);
      void main()
      {
          FILE *fp;
          FILE *resultfp;
          int  flashsize=2*FLASHVOLUM*1024*sizeof(char);//flash的存储单元个数
          char *buffer=malloc(sizeof(char)*100);//存储hex文件的一行内容
          char *trsbuffer=malloc(sizeof(char)*200);//存储hex文件解析后的内容
          char *flashbuffer=malloc(flashsize);//存储Flash中的内容
          if(buffer==NULL||trsbuffer==NULL||flashbuffer==NULL){//申请空间失败
              printf("Apply for memory failed.!\n");
              exit(0);
          }
          memset(flashbuffer,'F',flashsize);//将Flash初始时全部清1
          fp=fopen("main.hex","r");
          resultfp=fopen("main.txt","w");
          if(resultfp==NULL||fp==NULL){//打开文件失败
              printf("Open file error.\n");
              exit(0);
          }
          while(fscanf(fp,"%s",buffer)!=EOF){//读取文件所有内容
              //HextoBin(trsbuffer,buffer);
              printf("%s\n",buffer);//控制台显示
              FormatTran(trsbuffer,buffer);
              //printf("Length:%d\n",strlen(buffer));//显示字符串长度
              fprintf(resultfp,"%s\n",trsbuffer);//写入文件
              TranHex(flashbuffer,buffer,flashsize);
          }
          PrintFlash(flashbuffer,2*1024);//仅显示前2K的内容
          WriteFlashToFile(flashbuffer,"main_formated.txt",2*1024);//将前2K的内容写入文件"main_formated.txt"中
          //释放内存
          free(buffer);
          free(trsbuffer);
          free(flashbuffer);
          //关闭文件
          fclose(fp);
          fclose(resultfp);
      
      
      /*  //HexToDex()函数测试代码
          char *src=malloc(sizeof(char)*5);
          int value;
          src[0]='2';src[1]='F';src[2]='1';src[3]='F';src[4]='\0';
          value=HexToDec(src);
          printf("The value of the hex string:%d",value);
      */
      /*
          //ExtraSubStr()函数测试代码
          char *src=":10003000758180121086D2A400000000C2A40000C6";
          char *substr;
          substr=ExtraSubStr(src,1,2);
          printf("SubString:%s\n",substr);
          printf("Change to Number:%d",HexToDec(substr));
      */
      }
      
      void TranHex(char *flashbuffer,char *formatcmd,int flashsize){
          //按formatcmd字符串描述,以hex文件格式修改flashbuffer中的存储单元
          //如 formatcmd=":03000000020030CB"
          //则将flahsbuffer中以"0000"开始的连续"03"个内存单元,内容为"020030"
          //flashsize:表示flash的存储单元个数
          char *eofstring=":00000001FF";
          int startadd;//formatcmd指示的起始地址
          int count;//formatcmd指示的数据单元个数
          int p,q;//索引指针
          if(strcmp(formatcmd,eofstring)==0){//结束标志
              printf("End of file.\n");
              return;
          }
          if(formatcmd[0]!=':'){//不是以":"开始
              printf("Format wrong!\n");
              return;
          }
          if(strlen(formatcmd)<11){//字符串长度小于11
              printf("Format wrong!\n");
              return;
          }
          count=HexToDec(ExtraSubStr(formatcmd,1,2));//获得数据单元长度
          startadd=2*HexToDec(ExtraSubStr(formatcmd,3,4));//获得起始地址
          if(strlen(formatcmd)<11+count*2){//字符串中数据损坏(丢失)
              printf("File has been damaged!\n");
              return;
          }
          for(p=0;p<count*2;p++){
              flashbuffer[startadd+p]=formatcmd[9+p];
          }
      }
      
      void FormatTran(char *dst,const char *src){
          //格式解析,将一行Hex文件字符串src,按Hex文件组织格式
          //划分出不同的块,块之间通过空格隔开
          // ":llaaaatt[dd]cc"
          // ":"行开始标志;"ll"数据长度;"aaaa"起始地址;"tt"数据类型;"dd"数据;"cc"校验
          //解析后为:": ll aaaa tt [dd] cc"
          int srclen=strlen(src);
          //printf("Length of src:%d",srclen);
          int p=0,q=0;//索引,p为src的索引,q为dst索引
          int i;//循环标志
          while(p<=srclen){//循环,对src按格式解析
              if(p==0){
                  if(src[p]!=':'){//是否以":"开始
                      printf("Format wrong! Please check the format of the file.\n");
                      break;
                  }
                  else{
                      dst[q++]=':';dst[q++]=' ';
                      p++;continue;
                  }
              }
              if(p==1){
                  for(i=0;i<2;i++){//提取两位的"ll"
                      dst[q++]=src[p++];
                  }
                  dst[q++]=' ';continue;
              }
              if(p==3){
                  for(i=0;i<4;i++){//提取四位的"aaaa"
                      dst[q++]=src[p++];
                  }
                  dst[q++]=' ';continue;
              }
              if(p==7){
                  for(i=0;i<2;i++){//提取两位的"tt"
                      dst[q++]=src[p++];
                  }
                  dst[q++]=' ';continue;
              }
              for(i=0;i<2;i++){//将dst的数据位以两个为一组,用空格隔开
                      dst[q++]=src[p++];
              }
              dst[q++]=' ';
          }
          dst[q]='\0';//结束标志
      }
      
      int HexToDec(char *src){
          //将src中的无符号十六进制字符串转为十进制数
          //如src="001A",则返回26
          //字符串src需要以'\0'作为结束标志
          int value=0,srclen=strlen(src);
          int i;
          for(i=0;i<srclen;i++){
              if(src[i]<='9'&&src[i]>='0'){
                  value=value*16+(int)(src[i]-'0');
              }
              else if(src[i]<='f'&&src[i]>='a'){
                  value=value*16+(int)(src[i]-'a'+10);
              }else{
                  value=value*16+(int)(src[i]-'A'+10);
              }
          }
          return value;//返回转换后的数值
      }
      
      char *ExtraSubStr(const char *src,int startIndex,int len){
          //提取子串,从src中提取自startIndex开始的连续len个字节,构成子串
          char *substr=malloc(sizeof(char)*(len+1));
          int i=0;
          if(substr==NULL){
              printf("Apply for memory failed.\n");
              return NULL;
          }
          if(strlen(src)<startIndex+len){
              printf("Index exceeds bounds.\n");
              return NULL;
          }
          for(i=0;i<len;i++){//提取子串
              substr[i]=src[startIndex+i];
          }
          substr[len]='\0';//添加字符串末尾标志
          return substr;
      }
      
      void PrintFlash(char *flashbuffer,int flashsize){
          //flashbuffer:内存单元指针;flashsize:flash存储单元个数,即字节数
          //输出Flash中的内容
          int rowlen=16;//每行16个字节
          int i,j;
          printf("Flash:%d\n",flashsize);
          for(i=0;i<flashsize;i+=2){
              if((i/2)%(rowlen)==0){
                  printf("\n%06X\t",i/2);//内存单元地址输出格式:6位十六进制(A~F大写)
              }
              printf("%c%c ",flashbuffer[i],flashbuffer[i+1]);
          }
      }
      
      void WriteFlashToFile(char *flashbuffer,char *filename,int flashsize){
          //将Flash的内容写入文件中
          //flashbuffer:内存单元指针;filename:要写入的文件文件名;
          //flashsize:写入的长度,以字节计
          FILE *fp;
          int i,rowlen=16;
          if((fp=fopen(filename,"w"))==NULL){
              printf("Open file error.\n");
              exit(0);
          }
          //开始写入
          for(i=0;i<flashsize;i+=2){
              if((i/2)%(rowlen)==0){
                  if(i!=0){//不是第一行,遇到写满16个单元换行
                      fprintf(fp,"\n");
                  }
                  fprintf(fp,"%06X\t",i/2);//内存单元地址输出格式:6位十六进制(A~F大写)
              }
              fprintf(fp,"%c%c ",flashbuffer[i],flashbuffer[i+1]);
          }
          fclose(fp);
      }
      


    原Hex文件内容:



    去除Hex格式后,得到响应Flash存储单元中的内容:

    展开全文
  • 将HEX文件读写成地址加数据的格式,HEX文件格式可以参考 https://blog.csdn.net/a1037488611/article/details/43340055 文档中有关与效验算法方面的有点问题,可以参考本人效验代码 以下是我在Qt上实现的完整...

    将HEX文件读写成地址加数据的格式,HEX文件格式可以参考

    https://blog.csdn.net/a1037488611/article/details/43340055

    文档中有关与效验算法方面的有点问题,可以参考本人效验代码

     

    以下是我在Qt上实现的完整代码

    #include<stdio.h>
    #include<stdlib.h>
    #include<QDebug>
    #include<QString>
    #include<QByteArray>
    #include<QDebug>
    #include<QFile>
    #include<QDataStream>
    
    static char pq=9;  //规范代码
    
    /****16进制的数据类型*****/
    const QString HexTypeTable[6] =
    {
        "00","01","02","03","04","05",
    };
    
    /****配套数据类型使用的枚举变量*****/
    typedef enum __tagHexType
    {
        RECORD_DATA = 0,
        RECORD_END_OF_FILE,
        RECORD_EXTENDED_SEGMENT_ADDRESS,
        RECORD_START_SEGMENT_ADDRESS,
        RECORD_EXTENDED_LINEAR_ADDRESS,
        RECORD_START_LINEAR_ADDRESS,
        RECORD_HEX_MAX,
    }emHexType;
    
    typedef enum Boolsymbol
    {
        DATA_Flase = 0,
        DATA_Ture
    }BoolTureFlase;
    
     //定义字符串的类型格式
    typedef struct StringTypes
    {
        char Firstsymbolis;
        char StringCrcis;
        char StringSizeis;
        char StringResultis;
        char StringType;
        //QString BaseAddress;
    }StringType;
    
    static StringType StringTypeLine={DATA_Ture,DATA_Ture,DATA_Ture,DATA_Ture,RECORD_DATA};   //定义字符串的类型格式
    
    /****函数声明*********/
    QString AnalyseHEX(QByteArray dest);
    int mystrlen(const char *StrDest);
    int HexToDec(char *src);
    QString QStringLeftBit(QString src,int num);
    QString QStringToAdd(QString dest,QString src);
    StringType FormatHexjudge(QByteArray src);
    QString BaseAddjudge(QByteArray src);
    void ReadWrite(QString filenameread,QString filenameWrite);
    
    
    /****计算字符串长度*****/
    int mystrlen(const char *StrDest)
    {
        int i;
        i=0;
        while((*StrDest++)!='\0')
        {
            i++;
        }//这个循环体意思是从字符串第一个字符起计数,只遇到字符串结束标志'\0’才停止计数
        return i;
    }
    
    /****16进制转换10进制*****/
    int HexToDec(char *src)
    {
        //将src中的无符号十六进制字符串转为十进制数
        //如src="001A",则返回26
        //字符串src需要以'\0'作为结束标志
        int value=0,srclen=mystrlen(src);
        int i;
        for(i=0;i<srclen;i++)
        {
            if(src[i]<='9'&&src[i]>='0')
            {
                value=value*16+(int)(src[i]-'0'); //'0'
            }
            else if(src[i]<='f'&&src[i]>='a')
            {
                value=value*16+(int)(src[i]-'a'+10);
            }
            else
            {
                value=value*16+(int)(src[i]-'A'+10);
            }
        }
        return value;//返回转换后的数值
    }
    
    
    /****字符串效验*返回效验的十进制数用来与字符串后两位做比较****/
    QString AnalyseHEX(QByteArray dest)
    {
       unsigned char i=1;
       int tempsum=0;   //必须初始化,否则乱码
       QString stype;
       QString ZERO="0";
       QString Date0x100="100";
       QString result;
       do
       {
           stype = dest.mid(i,2);    //转换成10进制运算后,再转换成十六进制
    
           printf(" %d",HexToDec(stype.toLatin1().data()));
           tempsum+=HexToDec(stype.toLatin1().data());
           i+=2;
       } while (i<(mystrlen(dest)-2));
    
       /***HEX计算公式(0x100-(16进制数据和后两位))再取后两位=字符串后两位*****/
       result=QString::number((HexToDec(Date0x100.toLatin1().data())-HexToDec
                               (QString::number(tempsum,16).right(2).toLatin1().data())),16);
    
       if(result.size()<2)
       {
          int count=2-result.size();
          //printf("count=2-result.right(2).size()=%d\n",count);
           while(count-->0)
           {
             result.insert(0,ZERO);
           }
       }
       //qDebug()<<"result.right(2).toUpper()"<<result.right(2).toUpper();
       return result.right(2).toUpper();
    
    }
    
    
    /***0613*****字符串左移num位*****************/
     QString QStringLeftBit(QString src,int num)  //
     {
         QString zero="0";
         while(num-->0)
         {
             src.insert(src.size()-2,zero);  //末尾位加零
             src.remove(0,1);    //删除起始位
         }
         return src;
     }
    
    
     /***0613*****字符串以十六进制的形式转换成十进制相加,然后转换成十六进制的字符串形式输出*****/
     QString QStringToAdd(QString dest,QString src)
     {
         QString ResultDate;
         QString ZERO="0";
    
         int num1,num2,ans;
         int count;
         bool ok;
         num1=dest.toInt(&ok,16);  //转换成10进制
         num2=src.toInt(&ok,16);
         ans=num1+num2;
         ResultDate=QString::number(ans,16);
    
         /**判断结果字符串与输入的两个字符串的最大差值,用于给结果字符串补零***/
         (dest.size()-ResultDate.size()>src.size()-ResultDate.size())?
                     count=dest.size()-ResultDate.size():count=src.size()-ResultDate.size();
    
         while(count-->0)
         {
             ResultDate.insert(0,ZERO);
         }
    
        return  ResultDate.toUpper();//十进制转换成Qstring的形式输出  toUpper() //转换成大写字母
     }
    
    
    /****文件格式类型判断,有错误打印,返回值为基地址******/
    StringType FormatHexjudge(QByteArray src) //QString *resultBaseAddres
    {
        QByteArray resultString=":00000001FF";
        static uint32_t count_num=0;
        count_num++;
        /******验证一下传入的数据***********/
    
        char *pcdata = src.data();
    
        //printf("Length of src:%d\n",mystrlen(src));   //打印传入数据大小
        while(*pcdata)
        {
            //printf("%c",*pcdata);  //打印原始数据
            ++pcdata;
        }
        //printf("\n");
    
        if(src.left(1)!=":")
        {//不是以":"开始
                StringTypeLine.Firstsymbolis=DATA_Flase;
                printf("Format FirstSymbol wrong!\n");
                system("Pause");
        }
        else
        {
           StringTypeLine.Firstsymbolis=DATA_Ture;
        }
        if(strlen(src)<11)
        {//字符串长度小于11
                printf("Format length wrong!\n");
                system("Pause");
         }
        else
        {
            StringTypeLine.StringSizeis=DATA_Flase;
        }
        if(strcmp(src,resultString)==0)
        {//结束标志
                StringTypeLine.StringResultis=DATA_Ture;
                printf("End of file\n");
    
        }
        else
        {
            StringTypeLine.StringResultis=DATA_Flase;
        }
    
        if(src.right(2)!= AnalyseHEX(src))    //字符效验
        {
            StringTypeLine.StringCrcis=DATA_Flase;  //字符效验失败
            printf("\nSerialcount  is  wrong in  Address=%d\n",count_num);
            printf("XiaoYan_cc:%c%c\n",*src.right(2).data(),*(src.right(2).data()+1));
    
            printf("\nXiaoYan_calcu_int:%d\n",AnalyseHEX(src).toInt());
            printf("XiaoYan_read_int:%d\n",HexToDec(src.right(2).data()));     //读出来的效验值
    
            system("Pause");  //如果效验值错误,暂停界面
        }
        else
        {
            StringTypeLine.StringCrcis=DATA_Ture;    //字符效验正确
            //printf("\nFormat Effect Vaild!!!!!\n");
            while(mystrlen(src)-2>pq)   //打印完所有的数据
            {
              QString st = src.mid(pq,2);
              pq+=2;
    
              printf("%c%c ",*st.toLatin1().data(),*(st.toLatin1().data()+1));
            }
        }
    
         /****判断数据类型****/
    
        QString stringtype = src.mid(7,2);
        //printf("\nstringtype: %c%c\n",*stringtype.toLatin1().data(),*(stringtype.toLatin1().data()+1));
    
        if(stringtype==HexTypeTable[RECORD_DATA])
        {  //00正常数据类型
    
            StringTypeLine.StringType=RECORD_DATA;
    
            QString styadd = src.mid(3,4);
           /****只是分割字符串****/
           // printf("styadd:%c%c%c%c\n",*styadd.toLatin1().data(),*(styadd.toLatin1().data()+1),*(styadd.toLatin1().data()+2),*(styadd.toLatin1().data()+3));
        }
        else if (stringtype==HexTypeTable[RECORD_END_OF_FILE])
        {  //01 用来标识文件结束
           StringTypeLine.StringType=RECORD_END_OF_FILE;
           printf("RECORD_END_OF_FILE\n ");
    
        }
        else if (stringtype==HexTypeTable[RECORD_EXTENDED_LINEAR_ADDRESS])  //TODO:只需要判断一次
        {  //04 扩展线性地址记录
    
            StringTypeLine.StringType=RECORD_EXTENDED_LINEAR_ADDRESS;
            printf("RECORD_EXTENDED_LINEAR_ADDRESS \n");
            QString styadd = src.mid(3,4);
            QString styaddsub = src.mid(9,4);   //字符串拼接
    
            styadd.insert(0,styaddsub);
            //printf("StyaddSub04:%c%c%c%c%c%c%c%c\n",*styadd.toLatin1().data(),*(styadd.toLatin1().data()+1),
            //        *(styadd.toLatin1().data()+2),*(styadd.toLatin1().data()+3),*(styadd.toLatin1().data()+4),*(styadd.toLatin1().data()+5),*(styadd.toLatin1().data()+6),*(styadd.toLatin1().data()+7));
    
           //system("Pause");
        }
        else if(stringtype==HexTypeTable[RECORD_EXTENDED_SEGMENT_ADDRESS])
        {  //02 扩展段地址记录
            StringTypeLine.StringType=RECORD_EXTENDED_SEGMENT_ADDRESS;
            printf("RECORD_EXTENDED_SEGMENT_ADDRESS\n");
    
        }
        else if(stringtype==HexTypeTable[RECORD_START_LINEAR_ADDRESS])
        {  //05 开始线性地址记录
            StringTypeLine.StringType=RECORD_START_LINEAR_ADDRESS;
            printf("RECORD_START_LINEAR_ADDRESS\n");
    
        }
        else if(stringtype==HexTypeTable[RECORD_START_SEGMENT_ADDRESS])
        {  //03 开始段地址记录
           StringTypeLine.StringType=RECORD_START_SEGMENT_ADDRESS;
           printf("RECORD_START_SEGMENT_ADDRESS\n");
    
           system("Pause");    //如果遇到03则暂停,预留处理03的代码  (0613/还未遇到)
        }
        return StringTypeLine;
    }
    
    
    /******判断基地址**如果数据类型为04调用*******/
    QString BaseAddjudge(QByteArray src)
    {
      QString resultBaseAddres;
      QString stringtype = src.mid(7,2);         /****判断数据类型****/
      if (stringtype==HexTypeTable[RECORD_EXTENDED_LINEAR_ADDRESS])  //TODO:只需要判断一次RECORD_EXTENDED_LINEAR_ADDRESS
      {  //04 扩展线性地址记录
          QString styadd = src.mid(3,4);
          QString styaddsub = src.mid(9,4);   //字符串拼接
    
          styadd.insert(0,styaddsub);
          printf("StyaddSub04:%c%c%c%c%c%c%c%c\n",*styadd.toLatin1().data(),*(styadd.toLatin1().data()+1),
                  *(styadd.toLatin1().data()+2),*(styadd.toLatin1().data()+3),*(styadd.toLatin1().data()+4),*(styadd.toLatin1().data()+5),*(styadd.toLatin1().data()+6),*(styadd.toLatin1().data()+7));
    
          return styadd;
    
      }
    
      if (stringtype==HexTypeTable[RECORD_EXTENDED_SEGMENT_ADDRESS])  //TODO:只需要判断一次RECORD_EXTENDED_LINEAR_ADDRESS
      {  //02 扩展段地址记录
    
          QString Basezer0 = "0000";
          QString styaddsub = src.mid(9,4);   //字符串拼接
    
          Basezer0.insert(4,styaddsub);
          Basezer0=QStringLeftBit(Basezer0,1);
    
          printf("StyaddSub02:%c%c%c%c%c%c%c%c\n",*Basezer0.toLatin1().data(),*(Basezer0.toLatin1().data()+1),
                  *(Basezer0.toLatin1().data()+2),*(Basezer0.toLatin1().data()+3),*(Basezer0.toLatin1().data()+4),*(Basezer0.toLatin1().data()+5),*(Basezer0.toLatin1().data()+6),*(Basezer0.toLatin1().data()+7));
    
          return Basezer0; //在02数据类型的方式下需要左移一位
      }
      return resultBaseAddres;
    }
    
    
    /****新字符串拼接*****/
    QString FormatTranQARRYbyte(QByteArray src)
    {
        char count=9;
        char newcount=10;
        QString ResultDate;
        static QString resultBaseAddress="00000000";             //static 修饰只初始化一次 //0x08000000
        QString space=" ";
    
        StringTypeLine=FormatHexjudge(src);
    
        if(StringTypeLine.StringCrcis==DATA_Ture)   //如果效验码正确
        {
            if(StringTypeLine.StringType==RECORD_EXTENDED_LINEAR_ADDRESS)       //如果是扩展性数据类型 04
            {
                    resultBaseAddress=BaseAddjudge(src);            //接收扩展地址
                    qDebug()<<"resultBaseAddress"<<resultBaseAddress;
            }
    
            if(StringTypeLine.StringType==RECORD_EXTENDED_SEGMENT_ADDRESS)       //如果是段数据类型 02
            {
                    resultBaseAddress=BaseAddjudge(src);
                    qDebug()<<"resultBaseAddress"<<resultBaseAddress;
            }
    
            ResultDate=resultBaseAddress; //第一个是地址
            ResultDate=QStringToAdd(ResultDate,src.mid(3,4));  //基地址和绝对地址相加
    
            if(StringTypeLine.Firstsymbolis==DATA_Ture)   //如果字符串的第一个符号是“:”
            {
             ResultDate.insert(8,src.left(1));    //插入符号
             ResultDate.insert(9,space);
            }
    
            while(mystrlen(src)-2>count)   //打印完所有的数据
            {
              ResultDate.insert(newcount,src.mid(count,2));
              newcount=newcount+3;
    
              ResultDate.insert(newcount,space);
              count=count+2;
            }
    
            if(StringTypeLine.StringType==RECORD_DATA)    //当数据类型为00的时候才打印
            {
             printf("\n");
             qDebug()<<"ResultDate  "<<ResultDate<<endl<<endl<<endl;
            }
        }
      return ResultDate;
    }
    
    
    #if 0
    /***按行读取HEX文件并进行处理*****/
    void read(QString filename)
     {
         QFile file(filename);
         if(!file.open(QFile::ReadOnly | QFile::Text))
         {
             qDebug() << " Could not open the file for reading";
             return;
         }
    
         QTextStream in(&file);
         while(!in.atEnd())
         {
         QString myText = in.readLine();
    
         QString str(myText);
         QByteArray bytes = str.toLatin1();   //Qstring 转 QByteArray
         qDebug() << bytes;
    
         FormatTranQARRYbyte(bytes);
    
         printf("\n\n\n");
         }
    
         file.close();
     }
    
    /***按行读取HEX文件并进行处理*****/
    void Write(QString filename)
    {
        QFile file(filename);
        if(!file.open(QFile::WriteOnly | QFile::Text))
        {
            qDebug() << " Could not open the file for reading";
            return;
        }
        //QTextStream stream(&file);
        //stream.seek(file.size());
        QString resultString=":00000001FF\n";
        QString EnterResul="\n";
        QByteArray AER=":10246200464c5549442050524f46494c4500464c33";
    
        file.write(FormatTranQARRYbyte(AER).toUtf8());
        file.write(EnterResul.toUtf8());
        file.write(resultString.toUtf8());
    
       file.close();
       return;
    }
    #endif
    
    /***按行读取HEX文件并进行处理*****/
    void ReadWrite(QString filenameread,QString filenameWrite)
     {
         QString EnterResul="\n";
         QFile fileread(filenameread);
         if(!fileread.open(QFile::ReadOnly | QFile::Text))
         {
             qDebug() << " Could not open the file for reading";
             return;
         }
    
    
         QFile filewrite(filenameWrite);
         if(!filewrite.open(QFile::WriteOnly | QFile::Text))
         {
             qDebug() << " Could not open the file for reading";
             return;
         }
    
         QTextStream in(&fileread);
         while(!in.atEnd())
         {
             QString myText = in.readLine();
    
             QString str(myText);
             QByteArray bytes = str.toLatin1();   //Qstring 转 QByteArray
             qDebug() << bytes;
    
             QString ResultText;
             ResultText=FormatTranQARRYbyte(bytes);
             if(StringTypeLine.StringType==RECORD_DATA)        //只将数据类型为 00 的字符串写入
             {
                 filewrite.write(ResultText.toUtf8());                 //写入数据
                 filewrite.write(EnterResul.toUtf8());                     //写入回车
             }
             printf("\n");
         }
    
         fileread.close();
         filewrite.close();
     }
    
    
    
    /**0613生成成功**/
    int main()
    {
         QString filename = "C:/Users/Administrator/Desktop/HEX2/VCU_S32K14X.hex";
         //QString filename = "C:/Users/Administrator/Desktop/HEX2/Projec.hex";
         QString filewritename = "C:/Users/Administrator/Desktop/HEX2/Pro1.hex";
    
    
        //QByteArray AER=":020000040800F2";
       // QByteArray AER=":105CC00010831C46234618465DF8044B704708B500";
        //FormatTranQARRYbyte(AER);
    
         ReadWrite(filename,filewritename);
    
    }
    

    以下为Notepad++打开的原Hex文件

    经过代码(以上代码C语言)读取生成的文件

    通过软件转换的文件

    展开全文
  • C语言读取十六进制数据

    千次阅读 2009-10-24 01:04:00
    C语言读取十六进制数据1. 预备知识:文件字符读取2. 程序思想:将十六进制数据以自定义的一个数据块的大小为单元读取在fBuffer中,让后将fBuffer中的逐个显示到屏幕上,并打印可显字符。3. 具体实现// ...

     

    C语言读取十六进制数据

    1.         预备知识:文件字符读取

    2.         程序思想:将十六进制数据以自定义的一个数据块的大小为单元读取在fBuffer中,让后将fBuffer中的逐个显示到屏幕上,并打印可显字符。

    3.         具体实现

    // ReadHexData.cpp : read hex file

    //

     

    #include "stdafx.h"

    #include <stdio.h>

    #include <ctype.h>

    #include <String.h>

     

    #define BUFFERSIZE 68

    #define PAGELINES  20

    int main(int argc, char* argv[])

    {

             char chFileName[50];

             unsigned char fBuffer[BUFFERSIZE/4-1];

             FILE *pFile = NULL;

             int lines = 0;

             int num = 0;

             int i = 0;

            

    inagain:

             if(argc == 1)

             {

                       printf("Input a file name: ");

                       gets(chFileName);

             }

             else

             {

                       strcpy(chFileName,argv[1]);

                      

             }

     

             if((pFile = fopen(chFileName,"rb")) == NULL)

             {

                       //fail to open, we can input again

                       printf("Open error/n ");

                       goto inagain;

             }

             //when the file point don't goto the last position

             while(!(feof(pFile)))

             {

                       //read a row data, the length is BUFFERSIZE/4-1

                       while((num < sizeof(fBuffer)) && !(feof(pFile)))

                       {

                                fBuffer[num++] = (unsigned char)fgetc(pFile);

                       }

                      

                       num--;

                      

                       //show the hexadecimal data in the terminal

                       for(i=0; i<num; i++)

                       {

                                printf("%02x ",fBuffer[i]);

                       }

                       printf("| ");

                      

                       //show the visible data in the terminal

                       for(i=0; i<num; i++)

                       {

                                printf("%c",isprint(fBuffer[i])? fBuffer[i]:'.');

                       }

                       printf("/n");

                      

                       num =0;

                       lines++;

                       if(!(lines%PAGELINES))

                       {

                                if(getchar() == 'q')

                                         return 0;

                       }

             }

            

             fclose(pFile);

             return 0;

            

    }

     

    展开全文
  • 2.如何读取16进制文件最近编程用这一问题,网上查了一下,感觉还是自己写吧。16进制数据一般是:text=0x340xb5...,就是0x开头,之后是两个数字十六进制数。如果直接使用sscanf(text,"0x",&num),会把连续的数字...
  • 原理大致是将PE文件中的ASCII转换成HEX输出到文本中。这样做的目的是为了保存病毒样本的时候不会被杀毒软件查杀!然而却是delphi写的,特别想用C语言自己也实现一个,于是从google翻出了此代码。 2、编译后的结果 3...
  • 原理大致是将PE文件中的ASCII转换成HEX输出到文本中。这样做的目的是为了保存病毒样本的时候不会被杀毒软件查杀!然而却是delphi写的,特别想用C语言自己也实现一个,于是从google翻出了此代码。2、编译后的结果3、...
  • #include#includeusingnamespacestd;typedefunsignedcharbyte;/*class PngMsg{private :unsigned... //十进制,相当于16进制89.50.4e.47.0d.0a.1a.0a;char widthloc;char heigtMsgloc;char BitDepthloc;//图像深度c...
  • C语言读取txt里面的图像数据字符串换成十六进制然后保存为bmp格式的图像文件 一、现在因为某种原因,图片的数据是放在image_data.txt文件里面,现在我需要把image_data.txt里面的数据读出来然后换为十六进制,...
  • 即为:十六进制的F1E1D1A0 ②ver:为数据文件的版本号,值为16进制数据, 版本号 说明 0x101 系数矩阵为非压缩格式稀疏矩阵 0x102 系数矩阵为非压缩格式带状矩阵 0x201 系数矩阵为压缩格式稀疏矩阵 0x202 ...
  • 二进制dat格式数据转十六进制输出

    千次阅读 2016-09-10 09:54:00
    对于.dat格式的数据文件可以用C语言读写文件的方式,将.dat的二进制数据转为十六进制存储在一个数组里面,供程序调用。 注意设置使用多字节字符集,以免读取输入文件名时出错。 话不多说,直接放代码,如下: ...
  • 十六进制转SAC编码

    千次阅读 2012-03-20 22:58:42
    今天在项目中遇到了这么一个问题,就是我用JNI调用C语言,打开驱动文件读取数据,由于数据是十六进制,返回数据无法在前台显示,代码如下:  char* fibReadMagcard() {  memset(TrackBuf,0,TRACK_LEN+1); read...
  • 但是我转成十六进制文件后根本就看!不!懂!怎!么!破!啊!! ——————————————————edit—————————————————— 我第一次做的问题是,已知二进制文件中的各个数据名字和类型,...
  • 编写了一个底层读取设备ID 并与到已有的库里面查询这个ID是否存在的测试代码。遇到了一些问题,在次进行分析一下,我的环境是ubuntu和android ndk,测试这段代码,两个有所不同:...//十六进制转换为字符,位转换 ...
  • 我现在可以拿到网络数据以及PID(不知道怎么获取进程名称),就是从以太帧头开始到数据所有的十六进制字符串。 现在把他们都按照pcap文件的格式写进pcap文件,命名方式为Pid_etl.pcap,希望成果是使用wireshark打开,...
  • 本章首先介绍格式化读取下面是格式化读取的转换符说明:格式化输入转换说明符转换说明解释成%c字符%d有符号十进制整数%e %f %g %a浮点数(%a是C99标准)%E %F %G %A浮点数(%A是C99标准)%i有符号十进制整数%o有符号八...
  • 练习题一、用十六进制文本编辑器,打开一个记事本的.exe文件,再打开在内存中的记事本进程,记录下这两个文件的不同. 答:初始代码编号不同,根据编译器的磁盘对其和内存对其的数值不同,大小也不同。 练习题二将...
  • 配合团队内的小伙伴做数据转换,他需要我将保存在.txt文件内的字符数据(十六进制)转换为二进制,也需要我将.Bin文件内的二进制数据转换为字符数据(十六进制)。 下面所贴的程序有很大的优化空间,每次读取数据的...
  • 4、运行main.exe加密后, 密文二进制文件会出现在path同一目录下 , 名字为chipher.txt, 用记事本直接打开可看到全是十六进制大写字符。 5、以二进制方式读取chipher.txt得到的字符串就是加密结果。 其他语言去调用...
  • 串口通信——写串口(C语言

    千次阅读 2017-07-28 12:59:32
    C语言程序,将一个文件中保存的控制LED的十六进制读取,并写入串口由433M发送至连接有另一433M的MSP430单片机  C语言程序:  #include #include FILE * fileFP; int main(void) { FILE *fp; int temp; int ...
  • 这将从指定的输入文件中读取USB人机接口设备(HID)报告描述符,然后尝试对其进行解码,并可以选择从中创建C语言头文件。 它还会进行一些最小程度的完整性检查,以验证报告描述符是否有效。 输入文件可以是二进制...
  • 全国计算机二级C语言

    2010-09-22 20:27:53
    1.请编制函数ReadDat( )实现从文件HEX.IN中读取100个十六进 制数到字符串数组xx中; 请编制函数H16To10(), 将xx中的十六进 制数转换成十进制数并把已转换的十进制数仍存放在字符串数组xx 中, 最后调用函数WriteDat...
  • 10.3.5 读取十六进制和八进制值 379 10.3.6 用scanf()读取字符 381 10.3.7 scanf()的陷阱 383 10.3.8 从键盘上输入字符串 383 10.3.9 键盘的非格式化输入 384 10.4 屏幕输出 389 10.4.1 使用printf()格式输出...
  • 你必须知道的495个C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    这导致空间浪费而且无法与外部数据文件进行“二进制”读写。能否关掉填充,或者控制结构域的对齐方式? 2.14 为什么sizeof返回的值大于结构大小的期望值,是不是尾部有填充? 2.15 如何确定域在结构中的字节偏移...
  • 十六进制与八进制常量 93 快捷运算符 94 副作用 95 ++x或x++ 96 更多的副作用问题 97 答案 98 编程练习 99 第六章 条件和控制语句 101 if语句 101 else语句 102 怎样避免误用strcmp函数 104 循环语句 104...
  • o 3.10 我的编译器在结构中留下了空洞, 这导致空间浪费而且无法与外部数据文件进行 "二进制" 读写。能否关掉填充, 或者控制结构域的对齐方式? o 3.11 为什么 sizeof 返回的值大于结构的期望值, 是不是尾部有填充? ...
  •  14.1.3 文本流和二进制流 218  14.1.4 预定义的流 218  14.2 使用C语言的流函数 219  14.2.1 例子 219  14.3 读取键盘输入 220  14.3.1 字符输入 220  14.3.2 格式化输入 225  14.4 控制屏幕输出 ...

空空如也

空空如也

1 2 3
收藏数 51
精华内容 20
关键字:

c语言读取十六进制文件

c语言 订阅