{"id":5185,"date":"2019-09-04T18:06:28","date_gmt":"2019-09-05T01:06:28","guid":{"rendered":"https:\/\/visualgdb.com\/w\/?p=5185"},"modified":"2019-09-04T18:06:28","modified_gmt":"2019-09-05T01:06:28","slug":"using-openamp-for-cross-core-communication-on-stm32mp1","status":"publish","type":"post","link":"https:\/\/visualgdb.com\/tutorials\/arm\/stm32\/stm32mp1\/openamp\/","title":{"rendered":"Using OpenAMP for Cross-core Communication on STM32MP1"},"content":{"rendered":"

This tutorial shows how to use the OpenAMP<\/a> library to communicate between multiple cores of the STM32MP1 device. We will start with a basic project that creates a virtual COM port that can be used to send data between the Linux running on the Cortex-A core and the embedded firmware running on the Cortex-M4 core. We will then modify the firmware to respond to basic commands sent from the Linux side.<\/p>\n

Before you begin, install VisualGDB 5.4R11 or later.<\/p>\n

    \n
  1. Start Visual Studio and select the VisualGDB Embedded Project Wizard:\"\"<\/a><\/li>\n
  2. Enter the name and pick the location of the project that will be created by VisualGDB:\"\"<\/a><\/li>\n
  3. Proceed with the default settings (Embedded binary -> MSBuild) on the first page of the wizard:\"\"<\/a><\/li>\n
  4. On the next page of the wizard select the ARM toolchain and pick the STM32MP1 device that is installed on your development board:\"\"<\/a><\/li>\n
  5. On the Sample Selection page switch to the “STM32 CubeMX Samples” view and pick the OpenAMP_TTY_echo<\/strong> sample:\"\"<\/a><\/li>\n
  6. Ensure your board is in the production mode (i.e. boots Linux from the SD card) and connect power, Ethernet and ST-Link (see this tutorial<\/a> for more details), then let VisualGDB detect the on-board ST-Link and ensure STM32MP1xx (with PMIC)<\/strong> is selected as the debugged device:\"\"<\/a><\/li>\n
  7. Press the “Test” button to verify the JTAG connectivity:\"\"<\/a><\/li>\n
  8. Finally, press “Finish” to create the project. VisualGDB will clone the OpenAMP_TTY_Echo<\/strong> example so that you will be able to build and debug it. Build it via Build->Build Solution and check the outgoing calls from main() to quickly get a list of virtual UART-related functions provided by OpenAMP:\"\"<\/a><\/li>\n
  9. Sending and receiving packets from Linux running on the Cortex-A core involves calling the following functions from the Cortex-M4 firmware:\n
      \n
    1. MX_IPCC_Init()<\/strong> needs to be called in order to initialize the inter-core communication hardware.<\/li>\n
    2. MX_OPENAMP_Init()<\/strong> initializes the OpenAMP library.<\/li>\n
    3. VIRT_UART_Init()<\/strong> creates a new virtual UART port (available as \/dev\/ttyRPMSGx<\/strong> on the Linux side)<\/li>\n
    4. VIRT_UART_RegisterCallback()<\/strong> registers a callback that will be invoked by OpenAMP when Linux-side code sends a message via the virtual UART port.<\/li>\n
    5. VIRT_UART_Transmit()<\/strong> sends a message back to the Linux side.<\/li>\n
    6. OPENAMP_check_for_message()<\/strong> needs to be called from the main loop in order to poll for the incoming messages and call the previously registered RX callbacks.<\/li>\n<\/ol>\n

       <\/li>\n

    7. Before you can begin debugging the program, it needs to be registered with the Linux system by uploading it to \/lib\/firmware<\/strong> and writing to virtual files under \/sys\/class\/remoteproc<\/strong>. Follow this tutorial<\/a> to to understand the necessary steps or simply paste the following custom actions to custom debug steps before launching the debugger (requires the Custom edition of VisualGDB):\n
      <?xml version=\"1.0\" encoding=\"utf-16\"?>\r\n<ArrayOfCustomActionBase xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\" xmlns:xsd=\"http:\/\/www.w3.org\/2001\/XMLSchema\">\r\n  <CustomActionBase xsi:type=\"CommandLineAction\">\r\n    <SkipWhenRunningCommandList>false<\/SkipWhenRunningCommandList>\r\n    <RemoteHost>\r\n      <HostName>stm32mp1<\/HostName>\r\n      <Transport>SSH<\/Transport>\r\n      <UserName>root<\/UserName>\r\n    <\/RemoteHost>\r\n    <Command>echo<\/Command>\r\n    <Arguments>start &gt; \/sys\/class\/remoteproc\/remoteproc0\/state<\/Arguments>\r\n    <WorkingDirectory>\/<\/WorkingDirectory>\r\n    <BackgroundMode>false<\/BackgroundMode>\r\n  <\/CustomActionBase>\r\n  <CustomActionBase xsi:type=\"FileTransferAction\">\r\n    <SkipWhenRunningCommandList>false<\/SkipWhenRunningCommandList>\r\n    <SourceHost>\r\n      <HostName>BuildMachine<\/HostName>\r\n      <Transport>BuiltinShortcut<\/Transport>\r\n    <\/SourceHost>\r\n    <DestinationHost>\r\n      <HostName>stm32mp1<\/HostName>\r\n      <Transport>SSH<\/Transport>\r\n      <UserName>root<\/UserName>\r\n    <\/DestinationHost>\r\n    <SourceFilePath>$(TargetPath)<\/SourceFilePath>\r\n    <DestinationFilePath>\/lib\/firmware\/$(TargetFileName)<\/DestinationFilePath>\r\n    <OverwriteTrigger>Always<\/OverwriteTrigger>\r\n  <\/CustomActionBase>\r\n  <CustomActionBase xsi:type=\"CommandLineAction\">\r\n    <SkipWhenRunningCommandList>false<\/SkipWhenRunningCommandList>\r\n    <RemoteHost>\r\n      <HostName>stm32mp1<\/HostName>\r\n      <Transport>SSH<\/Transport>\r\n      <UserName>root<\/UserName>\r\n    <\/RemoteHost>\r\n    <Command>echo<\/Command>\r\n    <Arguments>stop &gt; \/sys\/class\/remoteproc\/remoteproc0\/state || echo \"Already stopped\"<\/Arguments>\r\n    <WorkingDirectory>\/<\/WorkingDirectory>\r\n    <BackgroundMode>false<\/BackgroundMode>\r\n  <\/CustomActionBase>\r\n  <CustomActionBase xsi:type=\"CommandLineAction\">\r\n    <SkipWhenRunningCommandList>false<\/SkipWhenRunningCommandList>\r\n    <RemoteHost>\r\n      <HostName>stm32mp1<\/HostName>\r\n      <Transport>SSH<\/Transport>\r\n      <UserName>root<\/UserName>\r\n    <\/RemoteHost>\r\n    <Command>echo<\/Command>\r\n    <Arguments>$(TargetFileName) &gt; \/sys\/class\/remoteproc\/remoteproc0\/firmware<\/Arguments>\r\n    <WorkingDirectory>\/<\/WorkingDirectory>\r\n    <BackgroundMode>false<\/BackgroundMode>\r\n  <\/CustomActionBase>\r\n<\/ArrayOfCustomActionBase><\/pre>\n
      \"\"<\/a><\/li>\n
    8. Set a breakpoint in VIRT_UART0_RxClptCallback()<\/strong> and press F5 to begin debugging the program:\"\"<\/a><\/li>\n
    9. Connect to the STM32MP1 board via SSH and run the “cat \/dev\/ttyRPMSG0” command to begin displaying the output from the virtual COM port:\"\"<\/a><\/li>\n
    10. In another tab run “echo test > \/dev\/ttyRPMSG0”:\"\"<\/a><\/li>\n
    11. The breakpoint will trigger, showing the message received from the Linux side:\"\"<\/a><\/li>\n
    12. Use the call stack to navigate to the MAILBOX_Poll()<\/strong> function and take a note of its logic. The function uses the msg_received_ch1<\/strong> and msg_received_ch2<\/strong> global variables to detect when a new message has arrived to the mailbox and then calls the previously registered callback function with it:\"\"<\/a><\/li>\n
    13. Go to the definition of msg_received_ch2<\/strong> and use the Code\/Data Relations view of CodeJumps to quickly locate the function that sets the variable:\"\"<\/a><\/li>\n
    14. Go to the IPCC2_channel_callback()<\/strong> function and set a breakpoint there. Then press F5 to continue execution. Check the console running the “cat” command. The message received via the virtual COM port will get echoed there:\"\"<\/a><\/li>\n
    15. Run the “echo test > \/dev\/ttyRPMSG0” command again to send another message. The breakpoint in IPCC_channel2_callback()<\/strong> will trigger. Check the call stack to see how the function was invoked by the interrupt handler for the IPCC_RX1<\/strong> interrupt:\"\"<\/a><\/li>\n
    16. Now we will modify the Cortex-M firmware to continuously blink the on-board LEDs and update the Linux firmware to change the blinking frequency by writing messages to \/dev\/ttyRPMSG0<\/strong>. Update the VIRT_UART0_RxCpltCallback()<\/strong> function to append the incoming data to the buffer instead of overwriting it each time:\n
      void VIRT_UART0_RxCpltCallback(VIRT_UART_HandleTypeDef *huart)\r\n{\r\n    log_info(\"Msg received on VIRTUAL UART0 channel:  %s \\n\\r\", (char *) huart->pRxBuffPtr);\r\n    size_t todo = MAX_BUFFER_SIZE - VirtUart0ChannelRxSize - 1;\r\n\r\n    if (todo > huart->RxXferSize)\r\n        todo = huart->RxXferSize;\r\n\r\n    memcpy(VirtUart0ChannelBuffRx + VirtUart0ChannelRxSize, huart->pRxBuffPtr, todo);\r\n    VirtUart0ChannelRxSize += todo;\r\n    VirtUart0ChannelBuffRx[VirtUart0ChannelRxSize] = 0;\r\n}<\/pre>\n
      Then add the following function to read the data from the buffer line-by-line:<\/p>\n
      size_t ReadLineFromVirtualUART(char *pBuffer, size_t maxSize)\r\n{\r\n    OPENAMP_check_for_message();\r\n\r\n    int pos = 0;\r\n    for (pos = 0; pos < VirtUart0ChannelRxSize; pos++)\r\n    {\r\n        if (VirtUart0ChannelBuffRx[pos] == '\\n')\r\n        {\r\n            size_t todo = pos;\r\n            if (todo >= maxSize)\r\n                todo = maxSize - 1;\r\n            memcpy(pBuffer, VirtUart0ChannelBuffRx, todo);\r\n            pBuffer[todo] = 0;\r\n\r\n            pos++;\r\n            memmove(VirtUart0ChannelBuffRx, VirtUart0ChannelBuffRx + pos, VirtUart0ChannelRxSize - pos);\r\n            VirtUart0ChannelRxSize -= pos;\r\n            return pos - 1;\r\n        }\r\n    }\r\n\r\n    return 0;\r\n}<\/pre>\n
      Finally, update main() to blink the LED continuously, updating the frequency when a new message is received via ReadLineFromVirtualUART():<\/p>\n
      \u00a0 __HAL_RCC_GPIOH_CLK_ENABLE();\r\n  GPIO_InitTypeDef GPIO_InitStructure;\r\n  GPIO_InitStructure.Pin = GPIO_PIN_7;\r\n  GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;\r\n  GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH;\r\n  GPIO_InitStructure.Pull = GPIO_NOPULL;\r\n  HAL_GPIO_Init(GPIOH, &GPIO_InitStructure);\r\n\r\n  uint32_t toggleTime;\r\n  uint32_t period = 1000;\r\n  char buf[64];\r\n\r\n  while (1)\r\n  {\r\n      if (HAL_GetTick() >= toggleTime)\r\n      {\r\n          HAL_GPIO_TogglePin(GPIOH, GPIO_PIN_7);\r\n          toggleTime = HAL_GetTick() + period;\r\n      }\r\n\r\n      if (ReadLineFromVirtualUART(buf, sizeof(buf)))\r\n      {\r\n          period = atoi(buf);\r\n      }\r\n  }<\/pre>\n<\/li>\n
    17. Press F5 to build and start the new version of the program. Observe how the on-board LED is being toggled each second:\"\"<\/a><\/li>\n
    18. Run “echo 100 > \/dev\/ttyRPMSG0” from an SSH terminal and observe how the LED blinking frequency changes:\"\"<\/a><\/li>\n
    19. You can set a breakpoint inside main() to step through the logic responsible for parsing the commands from the Linux side:\"\"<\/a><\/li>\n<\/ol>\n
       <\/p>\n","protected":false},"excerpt":{"rendered":"
      This tutorial shows how to use the OpenAMP library to communicate between multiple cores of the STM32MP1 device. We will<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[90],"tags":[61,187],"_links":{"self":[{"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/posts\/5185"}],"collection":[{"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/comments?post=5185"}],"version-history":[{"count":2,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/posts\/5185\/revisions"}],"predecessor-version":[{"id":5207,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/posts\/5185\/revisions\/5207"}],"wp:attachment":[{"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/media?parent=5185"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/categories?post=5185"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/tags?post=5185"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}