处理阵列数据

Question

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

哈尔类型定义: alt_u8 :无符号8位整数.alt_u32 :无符号32位整数.

我的FPGA中的核心一次接收128位用于数据处理。通过将4x32位无符号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 rbuf512；

当数据缓冲区满时，我试图将'rbuf‘的内容传输到数组'load’。主要问题是load4采用4乘32位无符号int进行处理。因此，我希望用rbuf中的数据“填充”这4x32位无符号int，处理数据并将结果保存到数组中。然后再次循环，用下一组数据(来自rbuf)填充数组load4，然后继续，直到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]);

最终目标是：

Array_A的无符号8位复制到一个Array_B4的32位>>无符号处理Array_B4与我的HDL代码。它要求输入为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++;
 }

它将存储在存储中的所有值复制到rbuf。

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

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

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

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]);