【LPC54114双核任务二】+双核之间通讯

leo121_3006061

LPC54114双核（M4 /M0+),如何实现双核之间的通信,NXP官方提供Multicore Software Development Kit (MCSDK) ，双核的管理如下图所示

可以看出MCSDK由三个组件组成

1.  Multicore Manager (MCMGR)
     1). 维护系统里所有核的信息     2）.为第二核加载代码（当代码在ram里时，此功能才可用）
     3）.第二或辅助核的开启和关闭
     4）.维护共享的内存区域的地址映射表
我们可以通过sdk自带的例程Hello world 来理解Multicore Manager，为了更好的运行例程，我稍加修改了一下。
大致上，分别创建两个独立的keil工程，分别是m0+核与m4核，然后首先编译m0+核工程，再编译m4并且附加m0+一并且下载到开发板。
第一步 ，在m0核的keil工程里实现6，7的LED闪烁，下边附上部分代码。

1. int main(void)
   
2. {
   
3.     uint32_t startupData, i;
   
4. 
   
5. 
   
6. 
   
7.     /* Initialize MCMGR before calling its API */
   
8.     MCMGR_Init();
   
9. 
   
10.     /* Get the startup data */
    
11.     MCMGR_GetStartupData(kMCMGR_Core1, &startupData);
    
12. 
    
13.     /* Make a noticable delay after the reset */
    
14.     /* Use startup parameter from the master core... */
    
15.     for (i = 0; i < startupData; i++)
    
16.         delay();
    
17. 
    
18.     /* Init board hardware.*/
    
19.     /* enable clock for GPIO */
    
20.     CLOCK_EnableClock(kCLOCK_Gpio0);
    
21.     CLOCK_EnableClock(kCLOCK_Gpio1);
    
22.     BOARD_InitPins_Core1();
    
23.     /* Configure LED */
    
24.    // LED_INIT();
    
25. led_init();
    
26.     /* Signal the other core we are ready */
    
27.     MCMGR_SignalReady(kMCMGR_Core1);
    
28. 
    
29.     while (1)
    
30.     {
    
31.         delay();
    
32. 
    
33.                         led_toggle(6); //
    
34.                          led_toggle(7);
    
35.     }

复制代码

然后修改如下图所示--user， $K\ARM\ARMCC\bin\fromelf.exe --bincombined --bincombined_base=0x20010000 --output=$Lcore1_image.bin !L，然后编译，不要下载。

第二步 再创建m4核的工程，我也稍微做了修改，为了减少篇幅，请看部分代码，此部分是当key建按下时m0+核停止运行。

1. /* Define the init structure for the switches*/
   
2.     gpio_pin_config_t sw_config = {kGPIO_DigitalInput, 0};
   
3. 
   
4.     /* Init board hardware.*/
   
5.     /* attach 12 MHz clock to FLEXCOMM0 (debug console) */
   
6.     CLOCK_AttachClk(kFRO12M_to_FLEXCOMM0);
   
7. 
   
8.     BOARD_InitPins_Core0();
   
9.     BOARD_BootClockFROHF48M();
   
10.     BOARD_InitDebugConsole();
    
11. 
    
12.     /* Init switches */
    
13.     GPIO_PinInit(BOARD_SW1_GPIO, BOARD_SW1_GPIO_PORT, BOARD_SW1_GPIO_PIN, &sw_config);
    
14.     GPIO_PinInit(BOARD_SW2_GPIO, BOARD_SW2_GPIO_PORT, BOARD_SW2_GPIO_PIN, &sw_config);
    
15. 
    
16. #ifdef CORE1_IMAGE_COPY_TO_RAM
    
17.     /* Calculate size of the image  - not required on LPCExpresso. LPCExpresso copies image to RAM during startup
    
18.      * automatically */
    
19.     uint32_t core1_image_size;
    
20.     core1_image_size = get_core1_image_size();
    
21.     PRINTF("Copy Secondary core image to address: 0x%x, size: %d\n", CORE1_BOOT_ADDRESS, core1_image_size);
    
22. 
    
23.     /* Copy Secondary core application from FLASH to RAM. Primary core code is executed from FLASH, Secondary from RAM
    
24.      * for maximal effectivity.*/
    
25.     memcpy(CORE1_BOOT_ADDRESS, (void *)CORE1_IMAGE_START, core1_image_size);
    
26. #endif
    
27. key_init();
    
28.     /* Initialize MCMGR before calling its API */
    
29.     MCMGR_Init();
    
30. 
    
31.     /* Boot Secondary core application */
    
32.     PRINTF("Starting Secondary core.\n");
    
33.     MCMGR_StartCore(kMCMGR_Core1, CORE1_BOOT_ADDRESS, 1, kMCMGR_Start_Synchronous);
    
34. 
    
35.     /* Print the initial banner from Primary core */
    
36.     PRINTF("\r\nHello World from the Primary Core!\r\n\n");
    
37. 
    
38.     PRINTF("Press the Key1 button to Stop Secondary core.\r\n");
    
39.     PRINTF("Press the Key2 button to Start Secondary core.\r\n");
    
40. 
    
41.     while (1)
    
42.     {
    
43. 
    
44. 
    
45.                         if(key_value(0)==0)
    
46.                         {
    
47.                                         MCMGR_StopCore(kMCMGR_Core1);
    
48.                                         PRINTF("Stopped Secondary core.\n");
    
49.                                         delay();
    
50.                         
    
51.                         
    
52.                         }
    
53.                         if(key_value(0)==1)
    
54.                         {
    
55.                                         MCMGR_StartCore(kMCMGR_Core1, CORE1_BOOT_ADDRESS, 5, kMCMGR_Start_Synchronous);
    
56.                                         PRINTF("Started Secondary core.\n");
    
57.                                         delay();
    
58.                         
    
59.                         }
    
60.     }

复制代码

第三步编译m4并附加m0+（此步骤是代码里有），一并下载到开发板，打开串口调试工具，显示如下图所示信息


通过上面的步骤，很容易了解利用M4控制M0+的起停。

2.  Remote Processor Messaging - Lite (RPMsg-Lite)主要为异构多核之间通讯提供接口。
     推荐资源 http://github.com/NXPmicro/rpmsg-lite和官方的sdk接下来通过简单的修改官方的sdk就可以实现本次任务的要求，附上代码
m0+核的代码（只有修改的部分）

1. #define RPMSG_LITE_LINK_ID (RL_PLATFORM_LPC5411x_M4_M0_LINK_ID)
   
2. #define MCMGR_USED
   
3. #define LOCAL_EPT_ADDR (30)
   
4. 
   
5. typedef struct the_message
   
6. {
   
7.     uint32_t DATA;
   
8. } THE_MESSAGE, *THE_MESSAGE_PTR;
   
9. 
   
10. /*******************************************************************************
    
11. * Prototypes
    
12. ******************************************************************************/
    
13. 
    
14. /*******************************************************************************
    
15. * Code
    
16. ******************************************************************************/
    
17. 
    
18. THE_MESSAGE volatile msg = {0};
    
19. unsigned long remote_addr = 0;
    
20. 
    
21. /* Internal functions */
    
22. static int my_ept_read_cb(void *payload, int payload_len, unsigned long src, void *priv)
    
23. {
    
24.     int *has_received = priv;
    
25. 
    
26.     if (payload_len <= sizeof(THE_MESSAGE))
    
27.     {
    
28.         memcpy((void *)&msg, payload, payload_len);
    
29.         remote_addr = src;
    
30.         *has_received = 1;
    
31.                         PRINTF("The m0+ core received msg from m4 core\r\n");
    
32.                         PRINTF("Message: Size=%x, DATA = %i\n\r", payload_len, msg.DATA);<font color="#ff0000">//接到m4内核传递的消息并且通过uart打印出来，m0+核相当于转发消息</font>
    
33.     }
    
34.     return RL_RELEASE;
    
35. }
    
36. 
    
37. /*!
    
38. * @brief Main function
    
39. */
    
40. int main(void)
    
41. {
    
42.         char ch=0;
    
43.     volatile int has_received = 0;
    
44.     struct rpmsg_lite_ept_static_context my_ept_context;
    
45.     struct rpmsg_lite_endpoint *my_ept;
    
46.     struct rpmsg_lite_instance rpmsg_ctxt;
    
47.     struct rpmsg_lite_instance *my_rpmsg;
    
48. 
    
49.     /* Initialize standard SDK demo application pins */
    
50.     BOARD_InitPins_Core1();
    
51.        
    
52.          /* Initialize standard SDK demo application pins */
    
53.     /* attach 12 MHz clock to FLEXCOMM0 (debug console) */
    
54.     CLOCK_AttachClk(kFRO12M_to_FLEXCOMM0);
    
55. 
    
56.     BOARD_InitDebugConsole();
    
57. 
    
58. #ifdef MCMGR_USED
    
59.     uint32_t startupData;
    
60. 
    
61.     /* Initialize MCMGR before calling its API */
    
62.     MCMGR_Init();
    
63. 
    
64.     /* Get the startup data */
    
65.     MCMGR_GetStartupData(kMCMGR_Core1, &startupData);
    
66. 
    
67.     my_rpmsg = rpmsg_lite_remote_init((void *)startupData, RPMSG_LITE_LINK_ID, RL_NO_FLAGS, &rpmsg_ctxt);
    
68. 
    
69.     /* Signal the other core we are ready */
    
70.     MCMGR_SignalReady(kMCMGR_Core1);
    
71. #else
    
72.     my_rpmsg = rpmsg_lite_remote_init((void *)RPMSG_LITE_SHMEM_BASE, RPMSG_LITE_LINK_ID, RL_NO_FLAGS, &rpmsg_ctxt);
    
73. #endif /* MCMGR_USED */
    
74. 
    
75.     while (!rpmsg_lite_is_link_up(my_rpmsg))
    
76.         ;
    
77. 
    
78.     my_ept = rpmsg_lite_create_ept(my_rpmsg, LOCAL_EPT_ADDR, my_ept_read_cb, (void *)&has_received, &my_ept_context);
    
79. #ifdef RPMSG_LITE_NS_USED
    
80.     rpmsg_ns_announce(my_rpmsg, my_ept, RPMSG_LITE_NS_ANNOUNCE_STRING, RL_NS_CREATE);
    
81. #endif /*RPMSG_LITE_NS_USED*/
    
82.     has_received = 0;
    
83.                 //msg.DATA=ch;
    
84.     while (1) //rx received data
    
85.     {
    
86.                          ch= GETCHAR();
    
87.                         msg.DATA=ch-49;
    
88.                        
    
89.         if (msg.DATA)<font color="#ff0000">//从uart传递过来的值，转发给m4核</font>
    
90.         {
    
91.             has_received = 0;
    
92.            // msg.DATA++;
    
93.             rpmsg_lite_send(my_rpmsg, my_ept, remote_addr, (char *)&msg, sizeof(THE_MESSAGE), RL_DONT_BLOCK);
    
94.         }
    
95.     }
    
96. 
    
97.     rpmsg_lite_destroy_ept(my_rpmsg, my_ept);
    
98.     my_ept = NULL;
    
99.     rpmsg_lite_deinit(my_rpmsg);
    
100.     msg.DATA = 0;
     
101. 
     
102.     /* End of example */
     
103. 
     
104. }

复制代码

m4核代码

1. static int my_ept_read_cb(void *payload, int payload_len, unsigned long src, void *priv)
   
2. {
   
3.     int *has_received = priv;
   
4. 
   
5.     if (payload_len <= sizeof(THE_MESSAGE))
   
6.     {
   
7.         memcpy((void *)&msg, payload, payload_len);
   
8.         *has_received = 1;
   
9.     }
   
10.                 msg.DATA++; <font color="#ff0000">//接收从m0+核传递过来的数据；为了区别原始数据，进行++操作</font>
    
11.    // PRINTF("Primary core received a msg\n\r");
    
12.    // PRINTF("Message: Size=%x, DATA = %i\n\r", payload_len, msg.DATA);
    
13.     return RL_RELEASE;
    
14. }
    
15. 
    
16. /*!
    
17. * @brief Main function
    
18. */
    
19. int main(void)
    
20. {
    
21.     volatile int has_received;
    
22.     struct rpmsg_lite_ept_static_context my_ept_context;
    
23.     struct rpmsg_lite_endpoint *my_ept;
    
24.     struct rpmsg_lite_instance rpmsg_ctxt;
    
25.     struct rpmsg_lite_instance *my_rpmsg;
    
26. 
    
27.     /* Initialize standard SDK demo application pins */
    
28.     /* attach 12 MHz clock to FLEXCOMM0 (debug console) */
    
29.     CLOCK_AttachClk(kFRO12M_to_FLEXCOMM0);
    
30. 
    
31.     BOARD_InitPins_Core0();
    
32.     BOARD_BootClockFROHF48M();
    
33.     BOARD_InitDebugConsole();
    
34. 
    
35. #ifdef CORE1_IMAGE_COPY_TO_RAM
    
36.     /* Calculate size of the image */
    
37.     uint32_t core1_image_size;
    
38.     core1_image_size = get_core1_image_size();
    
39.    //PRINTF("Copy CORE1 image to address: 0x%x, size: %d\n", CORE1_BOOT_ADDRESS, core1_image_size);
    
40. 
    
41.     /* Copy application from FLASH to RAM */
    
42.     memcpy(CORE1_BOOT_ADDRESS, (void *)CORE1_IMAGE_START, core1_image_size);
    
43. #endif
    
44. 
    
45.     /* Initialize MCMGR before calling its API */
    
46.     MCMGR_Init();
    
47. 
    
48.     /* Boot Secondary core application */
    
49.     MCMGR_StartCore(kMCMGR_Core1, CORE1_BOOT_ADDRESS, (uint32_t)rpmsg_lite_base, kMCMGR_Start_Synchronous);
    
50. 
    
51.     // Print the initial banner
    
52.    // PRINTF("\r\nRPMsg demo starts\n\n\r");
    
53. 
    
54.     my_rpmsg = rpmsg_lite_master_init(rpmsg_lite_base, SH_MEM_TOTAL_SIZE, RPMSG_LITE_LINK_ID, RL_NO_FLAGS, &rpmsg_ctxt);
    
55. 
    
56.     my_ept = rpmsg_lite_create_ept(my_rpmsg, LOCAL_EPT_ADDR, my_ept_read_cb, (void *)&has_received, &my_ept_context);
    
57. 
    
58.     has_received = 0;
    
59. 
    
60.     /* Send the first message to the remoteproc */
    
61.     msg.DATA = 10;<font color="#ff0000">//初次运行通过m0+核传递的数据</font>
    
62.     rpmsg_lite_send(my_rpmsg, my_ept, REMOTE_EPT_ADDR, (char *)&msg, sizeof(THE_MESSAGE), RL_DONT_BLOCK);
    
63. 
    
64. while (msg.DATA <= 100)
    
65.     {
    
66.         if (has_received)
    
67.       {
    
68.             has_received = 0;
    
69.             msg.DATA++;
    
70.             rpmsg_lite_send(my_rpmsg, my_ept, 30, (char *)&msg, sizeof(THE_MESSAGE), RL_DONT_BLOCK);
    
71.         }
    
72.     }
    
73. 
    
74.     rpmsg_lite_destroy_ept(my_rpmsg, my_ept);
    
75.     my_ept = NULL;
    
76.     rpmsg_lite_deinit(my_rpmsg);
    
77. 
    
78.     // Print the ending banner
    
79.     //PRINTF("\r\nRPMsg demo ends\n\n\r");
    
80.   

复制代码

运行效果如下图所示


上述过程是利用共享内存，来实现消息传输的。


3. Embedded Remote Procedure Call (eRPC)
eRPC Getting Started User's Guide.pdf (970.6 KB, 下载次数: 60)

2017-6-26 12:05 上传

点击文件名下载附件
利用eRPC不仅可以实现这次任务的要求，还可以实现多处理器间的通讯。
具体实现待续。

阅读全文

小马哥-1650185

赞一个

nxp_helloworld

看不大懂

Paderboy

赞。。。

leo121_3006061

小马哥-1650185 发表于 2017-6-27 16:40
赞一个

感谢鼓励

leo121_3006061

Paderboy 发表于 2017-6-27 19:21
赞。。。

感谢鼓励

leo121_3006061

nxp_helloworld 发表于 2017-6-27 16:58
看不大懂

写的不太好，多多包涵

湉湉

双核感觉很神奇的样子