【NXP OKdo E1双核Cortex M33开发板 】基于Keil双核架构的研究3

story_xjj

基于Keil双核架构的研究3

-共享内存

1.  设计思想

在Core0和Core1之间开辟一段SRAM，作为双核之间数据传递的共用内存。以Core0的RPMSG通讯作为触发信号，填充共享内存段的数据，然后Core1通过RPMSG信息通知Core0接收数据。这种方式对于传输数据频率较低，但传输数据量很大时还是非常有效的。

2.  软件实践

利用前次RPMSG-Lite的试验的结果，重新规划设计内存的试用情况，从0x20039800开始到0x20040000止，大约26K的内存空间用来作为核间通讯的共享内存。

1. <div align="left">    #define DATA_SH_MEM_ADDR    0x20039800</div><div align="left">    #defineDATA_SH_MEM_SIZE    0x6800</div>

复制代码

构建一个结构体指针，用来管理共享内存。根据实际需要，可以将这段内存再次划分为多个段。

1. typedef struct
   
2. {
   
3.   uint32_t type;
   
4.   uint8_t dat[100];
   
5.   uint16_t crc;
   
6. }*DATA_SH_MEM_PTR;
   
7. 
   
8. DATA_SH_MEM_PTR data_sh_mem_ptr = (DATA_SH_MEM_PTR)DATA_SH_MEM_ADDR;

复制代码

这里假设这种类型的结构体和使用方法。
Core1在接收到Core0发送的rpmsg信息后，在rpmsg的回调函数中填充共享内存，并且对填入的数据形成校验：

1. /*Internal functions */
   
2. staticint32_t my_ept_read_cb(void *payload, uint32_t payload_len, uint32_t src, void*priv)
   
3. {
   
4.     int32_t *has_received = priv;
   
5.           int i;
   
6.           uint16_t crc = 0;
   
7. 
   
8.     if (payload_len <= sizeof(THE_MESSAGE))
   
9.     {
   
10.           (void)memcpy((void*)&msg, payload, payload_len);
    
11.         remote_addr   = src;
    
12.         *has_received = 1;
    
13.           data_sh_mem_ptr->type= 0x01;      //type
    
14.           for(i=0;i<100;i++)
    
15.           {
    
16.                data_sh_mem_ptr->dat =(uint8_t)msg.DATA;
    
17.                crc +=data_sh_mem_ptr->dat;
    
18.           }
    
19.           data_sh_mem_ptr->crc= crc;
    
20.     }
    
21.     return RL_RELEASE;
    
22. }
    
23. 在主循环中，查看是否完成数据填充，完成填充后，发送rpmsg消息通知Core0进行共享内存数据解析。
    
24. Core0在接收到Core1的rpmsg后，在回调函数中解析共享内存数据，并进行校验：
    
25. <p>/* This is the read callback,note we are in a task context when this callback</p><p>is invoked, so kernelprimitives can be used freely */</p><p>static int32_tmy_ept_read_cb(void *payload, uint32_t payload_len, uint32_t src, void *priv)</p>{
    
26.     int32_t *has_received = priv;
    
27.     int i;
    
28.     uint16_t crc = 0;
    
29. 
    
30.     if (payload_len <= sizeof(THE_MESSAGE))
    
31.     {
    
32.           if(data_sh_mem_ptr->type == 0x01)      
    
33.          {
    
34.               data_sh_mem_ptr->type = 0x00;
    
35.               for(i=0;i<100;i++)
    
36.                  crc += data_sh_mem_ptr->dat;
    
37.              if(crc == data_sh_mem_ptr->crc)
    
38.              {
    
39. <p>//                  (void)PRINTF("Primary corereceived sh mem data success\r\n");</p><p>                   (void)PRINTF("ss:DATA =%i\r\n", data_sh_mem_ptr->dat[0]);</p>             }
    
40.               else
    
41.               {
    
42. <p>//                (void)PRINTF("Primary corereceived sh mem data failed\r\n");</p><p>                 (void)PRINTF("ff:crc0 = %ucrc1= %u \r\n", crc,data_sh_mem_ptr->crc);</p>              }
    
43.           }
    
44. 
    
45. <p>        (void)memcpy((void *)&msg, payload,payload_len);</p>        *has_received = 1;
    
46.     }
    
47.           count++;
    
48.     return RL_RELEASE;
    
49. }

复制代码

当Core0完成共享内存信息处理后，即完成一次Core0和Core1核间数据交换。Core0可以随即发起下一次数据交换，也可以采用周期性的方式触发下一次的数据交换。
为了保证数据传输的速度，不采用rpmsg数据同步，而是采用环形队列的方式管理共享内存空间，如果Core0查询的速度和环形队列空间的适当控制，可以保证实时数据传递，进行在一个CPU内部一样。

3.  效果验证

story_xjj

怎么变得这么乱啊