c-处理阵列数据

Question

我在数组之间传递数据以进行处理时遇到了一个问题，似乎无法解决。（我正在Nios II处理器上运行代码）

HAL类型定义：alt_u8：无符号8位整数。alt_u32：无符号32位整数。

我的FPGA中的核心每次接收128位用于数据处理。通过将4 x 32位无符号int传递给函数，我在原始代码中实现了这一点

alt_u32 load[4] = {0x10101010, 0x10101010, 0x10101010, 0x10101010}; 

函数处理这些数据，并使用另一个数组检索信息。

data_setload(&context,&load);       //load data
data_process(&context);                    //process
memcpy(resultdata,context.result,4*sizeof(unsigned int));
for(i=0; i<4 ; i++){    
    printf("received 0x%X n",resultdata[i]);       //print to screen
} 

上面的效果很好，但当我尝试将它与第二部分结合时，它不起作用。

我有一个用于存储数据的缓冲区：alt_u8 rbuf[512]；

当数据缓冲区变满时，我试图将"rbuf"的内容传输到数组"load"。主要问题是load[4]采用4乘32位无符号int进行处理。因此，我想用rbuf中的数据"填充"这4乘32位无符号int，处理数据并将结果保存到数组中。然后再次循环，用下一组数据（来自rbuf）填充数组load[4]，并继续，直到rbuf为空。（必要时用零填充）

alt_u8 rbuf[512];
alt_u8 store[512];
alt_u32 resultdata[512];
alt_u32 *reg;                
int d, k, j;
for (j=0; j<512; j++){
    read_byte(&ch);   //gets data
    rbuf[j]=ch;       //stores to array rbuf
}
printf(" rbuf is full n");
memcpy(store,rbuf,512*sizeof(alt_u8));  //store gets the value in rbuf.
for(k=0;k<16;k++)  //for loop used take in 4 chars to one unsigned 32 bit int
{
    for(d=0;d<4;d++)    //store 4 chars into an one 32 bit unsigned int
    {
        *reg = (*reg<<8 | store[d])  ;
    }
    reg =+1;     //increment pointer to next address location(not working properly)
}            //loop back
reg = 0;      //set pointer address back to 0
for(j=0;j<16;j++)   //trying to process data from here 
{   
    memcpy(load,reg,4*sizeof(alt_u32));      //copy first 4 locations from 'reg' to 'load'
    data_setload(&context,&load);       //pass 'load' to function
    data_process(&context);                      //process 128 bits
    memcpy(resultdata,context.result,4*sizeof(alt_u32));  //results copied to 'resultdata'
    *reg = *reg + 4;            //increment pointer address by 4?
    *resultdata = *resultdata+4;        //increment resultdata address by 4 and loop again
}        
/** need to put data back in char form for displaying***/
for(k=0;k<16;k++)              //for loop used take chars from 32 unsigned int
{
   for(d=4;d>=0;d--)            //loads 4 chars FROM A 32 unsigned int
   {
      store[d] = *resultdata;
      *resultdata = *resultdata>>8;
   }
   resultdata =+1;  //increment pointer next address location
}
for(d=0; d<512 ; d++){
    printf("received 0x%X ",store[d]);

最终目标是采取：

无符号8位的Array_A将其复制到无符号32位的Array_B[4]中>>用我的HDL代码处理Array_B[4]。它要求输入为128位。然后循环返回并获取接下来的128位并对其进行处理。

Answer 1

reg已定义但未初始化，因此它将是一个空指针，您正在尝试向它写入一个值（*reg分配值，reg分配地址）。

此外，k-d循环是错误的。如果您正确初始化了reg，那么一个非常简单的方法是：

 for(k=0;k<16;k += 4)              //for loop used take chars from 32 unsigned int
 {
    *rbuf = *((alt_u32*)&store[k]);
    rbuf++;
 }

该循环将获取存储在存储区开头的四个字节，并将它们复制到rbuf所指向的位置。

我几乎要说，这不是你想要实现的，而是你的代码试图做到的。如果你想完全复制商店到rbuf指向的地方，那么你可以这样做：

 for(k=0;k<512;k += 4)              //for loop used take chars from 32 unsigned int
 {
    *rbuf = *((alt_u32*)&store[k]);
    rbuf++;
 }

这将把存储在store中的所有值复制到rbuf。

此外，一种更好、更快、更清洁的方式：

memcpy(rbuf, &store, 512);
rbuf += 512 / sizeof(alt_u32);

最后，如果您只想用前四个整数填充负载，那么您可以这样做：

for(k = 0; k < 4; k++)
{
    load[k] = *((alt_u32*)&rbuf[k * 4]);
}

或

memcpy(&load, &rbuf, 4 * sizeof(alt_u32));

那么你就不需要存储笔记了。

最后，这里有一个具有最低内存使用率和最佳性能的完整重写函数：

alt_u8 rbuf[512];
alt_u32 resultdata[128]; //fixed its size to 128, (512 / sizeof(alt_u32))
int j;
//Do the loop to load data in rbuf
for (j=0; j<512; j++)
    read_byte(&rbuf[j]);
printf(" rbuf is full n");
//Loop through rbuf in 4 * 32 bits per iteration (4*4 bytes)
for(j = 0; j < 512; j+= sizeof(alt_u32) * 4)
{
    data_setload(&context, (alt_u32*)&rbuf[j]); //I assume this function expects an alt_u32 pointer to 4 alt_u32 values
    data_process(&context);
    memcpy(&resultdata[j / sizeof(alt_u32)], context.result, sizeof(alt_u32) * 4);//I assume context.result is a pointer, if not then add & before it
}
//Print received data
for(j=0; j<512 ; j++){
    printf("received 0x%X ",rbuf[d]);