将字符数组缓冲区作为十六进制存储在 C 中的 uint32_t 缓冲区中

Question

我能够读取十六进制文件并将内容存储在字符缓冲区中，我需要将字符缓冲区中的字符作为十六进制值存储在缓冲区中，如下所示。 这样我就可以使用该十六进制值写入仅接受uint32_t的硬件数据寄存器。

char * buffer =[AABBCCDDEE112233445566]

输出：

partitioned_buffer = 0xAABBCCDD

partitioned_buffer = 0xEE112233

等等。 任何人都可以对此提供帮助。 先感谢您。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char *fip_buffer;
char *emmc_pattern_buffer;

char hex_pattern() { 
    FILE *fileptr;
    char *buffer;
    long filelen;
    int i,j;
    

    fileptr = fopen("fip.hex", "rb");         
    if( fileptr == NULL ) {
       printf("cannot open file");// exit(1);
     }
    fseek(fileptr, 0, SEEK_END);          
    filelen = ftell(fileptr);            
    rewind(fileptr);                      
    fip_buffer = (char *)malloc((filelen+1)*sizeof(char)); 

    for(i = 0; i < filelen; i++) {
       fread(fip_buffer+i, 1, 1, fileptr); 
    
    }
       
    
    fclose(fileptr); // Close the file
    return(fip_buffer);
}



char hex_pattern_read(int a, int filelen){
char mem[8],mem2[7];
int i,j;
for(i=a;i<filelen;i++){
      mem[j]=fip_buffer[i];
      mem[8]='\0';
      j++;
      if(j==8){strcpy(mem2,mem);j=0; break;
       }
   } 
   emmc_pattern_buffer=mem2;
   return(emmc_pattern_buffer);
}




int main(int argc, char **argv) {
printf("Reading hex file\n");
int i,j;
hex_pattern();
int len = strlen(fip_buffer);
//printf("size of buffer is=%d\n%c\n",len,fip_buffer);
for(i=0; i<2; i++){
  // printf("Entered loop1");
 for(j=0;j<3;j++){
   int temp = (j*8)+(128*i);
    hex_pattern_read(temp,len); //need to store the returned emmc_pattern_buffer character as hex value 
   printf("%02X\n",emmc_pattern_buffer);
  }
}
return 0;

Answer 1

从评论...

我正在将十六进制文件内容读入缓冲区，缓冲区中有一系列字符，如 12345678aa64000101681fa1ed19f39d41e...等等，我每次都尝试读取 8 个字符并且能够打印它们，但我想存储该字符到十六进制值。

...我知道您正在成功地从您的输入文件中读取 32 位无符号数的十六进制文本表示，并且您想将其转换为机器的内部数字表示。 为此，字节是否具有单独的个体意义完全没有区别。

那么，完成该任务的最简单方法是使缓冲区至少有 9 个字节长，以便它有空间容纳 8 个十六进制数字和一个字符串终止符，确保存在终止符，并使用strtoul()函数执行转换：

char buffer[9];
// ... fill buffer, including terminator byte ...
char *end;
uint32_t value = strtoul(buffer, &end, 16);
if (end != buffer + 8) // ... handle bad data ...

Answer 2

如果我正确理解问题，则有一个带有字节流的文件，必须通过将每个文件打包 4 字节来发送到register 。

您可以按如下方式组合单个字节以制作uint32_t ，

uint32_t partitioned_buffer =  (buffer[0]<<24u) | (buffer [1]<<16u) | (buffer[2]<<8u) |  buffer[3];

您甚至可以将字节流转换为 o/p uint32_t缓冲区，如下所示，

uint32_t partitioned_buffer[op_bufferSize];
for(i =0;i<op_bufferSize;i++)
 {
     int offset = i<<2;
    partitioned_buffer[i] =  (buffer[offset+0]<<24u) | (buffer [offset+1 ]<<16u) | (buffer[offset+2]<<8u) |  buffer[offset+3];
 }

Answer 3

您可以编写一个函数将字符转换为整数

uint32_t convertbyte(char *buffer)
{
    uint32_t ret = 0;
    uint8_t i;
    for (i=0; i<8; i++)
    {
        ret *= 16;
        if ((buffer[i] >= 'A') && (buffer[i] <= 'F'))
            ret += buffer[i] - 'A' + 10;
        else if ((buffer[i] >= '0') && (buffer[i] <= '9'))
            ret += buffer[i] - '0';
        else
        {
            printf (" Malformed input");
            return 0;
        }
    }
    return ret;
}

然后可以为每个需要转换的 32 位整数调用此函数。

#include <stdio.h>
#include <stdint.h>

uint32_t convertbyte(char *buffer);

int main(void)
{
    char *buffer = "AABBCCDDEE112233445566";
    uint32_t partitioned, partitioned2;

    partitioned = convertbyte(buffer);
    printf ("%X\n",partitioned);
    
    partitioned2 = convertbyte(buffer+8);
    printf ("%X\n",partitioned2);

    return 0;
}

输出是

AABBCCDD

EE112233

Answer 4

您可以使用以下函数将十六进制表示的字符串转换为 32 位（与 uint32_t 相同）十六进制值。

int char2hex(char ch)
{
    int value = -1;
    switch(ch)
    {
        case '0' : value = 0;
        break;
        case '1' : value = 1;
        break;
        case '2' : value = 2;
        break;
        case '3' : value = 3;
        break;
        case '4' : value = 4;
        break;
        case '5' : value = 5;
        break;
        case '6' : value = 6;
        break;
        case '7' : value = 7;
        break;
        case '8' : value = 8;
        break;
        case '9' : value = 9;
        break;
        case 'A' : 
        case 'a' : value = 10;
        break;
        case 'B' :
        case 'b' : value = 11;
        break;
        case 'C' :
        case 'c' : value = 12;
        break;
        case 'D' :
        case 'd' : value = 13;
        break;
        case 'E' :
        case 'e' : value = 14;
        break;
        case 'F' : 
        case 'f' :value = 15;
        break;
    }
    return value;
}

long str2longhex(char * str){
    int nibble = 0;
    long hex_value = 0;
    for(unsigned int str_i = 0; str_i < 8; str_i++){
#if 1 //Change the 1 to 0 if you want to reverse the endianess
        nibble = char2hex(str[str_i]);
#else
        nibble = char2hex(str[7-str_i]);
#endif        
        if(nibble < 0){
            //Not a hex representation.
            return -1;
        }
        hex_value = ((hex_value<<4)&0xFF) | nibble;
    }
    return hex_value;
}


int main()
{
    char * buffer = "AABBCCDDEE112233445566";
    long value = 0;
    unsigned int buffer_i = 0; 
    while(buffer_i+8 <= strlen(buffer))
    {
        value = str2longhex(&buffer[buffer_i]);
        printf("partitioned_buffer:0x%08lX\n",value);
        buffer_i += 8;
    }
    return 0;
}

通常在十六进制文件中（如果你的意思是带有 .hex 的文件）数据从最低内存位置存储到最高位置，即如果文本文件包含“AABBCCDD”，则相应的十六进制值将是 0xDDCCBBAA。 不知道您的文件中的表示，但请检查它。