title: How to pass a structure as a parameter when creating a FreeRTOS task?
body: <p>I am currently working on the Cortex-M4 of the NXP i.MX8 M Mini processor.
  I am developing the application of the M4 (OS FreeRTOS).
  What I would like to do is to fill a structure, create a task, pass this structure as a parameter to this task and reuse this structure in this task.</p>
  <p>However, I can't get the values of the structure passed as parameter in the created task.
  At compile time, I get &quot;warning: dereferencing 'void *' pointer&quot; or &quot;error: request for member 'my_rpmsg' in something not a structure or union&quot;</p>
  <p>Here is my code :</p>
  <pre><code>/*
   * Copyright (c) 2016, Freescale Semiconductor, Inc.
   * Copyright 2016-2017 NXP
   * All rights reserved.
   *
   * SPDX-License-Identifier: BSD-3-Clause
   */
  
  #include &lt;stdio.h&gt;
  #include &lt;stdlib.h&gt;
  #include &lt;string.h&gt;
  #include &quot;rpmsg_lite.h&quot;
  #include &quot;rpmsg_queue.h&quot;
  #include &quot;rpmsg_ns.h&quot;
  #include &quot;pin_mux.h&quot;
  #include &quot;clock_config.h&quot;
  #include &quot;board.h&quot;
  #include &quot;fsl_debug_console.h&quot;
  #include &quot;FreeRTOS.h&quot;
  #include &quot;task.h&quot;
  
  #include &quot;fsl_uart.h&quot;
  #include &quot;rsc_table.h&quot;
  /*******************************************************************************
   * Definitions
   ******************************************************************************/
  #define RPMSG_LITE_SHMEM_BASE         (VDEV0_VRING_BASE)
  #define RPMSG_LITE_LINK_ID            (RL_PLATFORM_IMX8MM_M4_USER_LINK_ID)
  #define RPMSG_LITE_NS_ANNOUNCE_STRING &quot;rpmsg-virtual-tty-channel-1&quot;
  #define RPMSG_TASK_STACK_SIZE (256)
  #define RPMSG_RX_TASK_STACK_SIZE (256)
  #define RPMSG_TX_TASK_STACK_SIZE (256)
  #ifndef LOCAL_EPT_ADDR
  #define LOCAL_EPT_ADDR (30)
  #endif
  
  /* Globals */
  static char app_buf[512]; /* Each RPMSG buffer can carry less than 512 payload */
  
  /*******************************************************************************
   * Prototypes
   ******************************************************************************/
  
  /*******************************************************************************
   * Code
   ******************************************************************************/
  static TaskHandle_t rpmsg_task_handle = NULL;
  static TaskHandle_t rpmsg_tx_task_handle = NULL;
  
  struct rpmsg_struct
  {
      struct rpmsg_lite_endpoint *volatile my_ept;
      volatile rpmsg_queue_handle my_queue;
      struct rpmsg_lite_instance *volatile my_rpmsg;
  };
  
  static void rpmsg_tx_task(void *param)
  {
      volatile uint32_t remote_addr;
  //    struct rpmsg_lite_endpoint *volatile my_ept;
  //    volatile rpmsg_queue_handle my_queue;
  //    struct rpmsg_lite_instance *volatile my_rpmsg;
      void *rx_buf;
      uint32_t len;
      int32_t result;
      void *tx_buf;
      uint32_t size;
  
      /* Print the initial banner */
      PRINTF(&quot;\r\nRPMSG String Echo FreeRTOS RTOS API Demo...\r\n&quot;);
  
      for (;;)
      {
          /* Get RPMsg rx buffer with message */
          result =
              rpmsg_queue_recv_nocopy(param-&gt;my_rpmsg, param-&gt;my_queue, (uint32_t *)&amp;remote_addr, (char **)&amp;rx_buf, &amp;len, RL_BLOCK);
          if (result != 0)
          {
              assert(false);
          }
  
          /* Copy string from RPMsg rx buffer */
          assert(len &lt; sizeof(app_buf));
          memcpy(app_buf, rx_buf, len);
          app_buf[len] = 0; /* End string by '\0' */
  
          if ((len == 2) &amp;&amp; (app_buf[0] == 0xd) &amp;&amp; (app_buf[1] == 0xa))
              PRINTF(&quot;Get New Line From Master Side\r\n&quot;);
          else
              PRINTF(&quot;Get Message From Master Side : \&quot;%s\&quot; [len : %d]\r\n&quot;, app_buf, len);
  
          /* Get tx buffer from RPMsg */
          tx_buf = rpmsg_lite_alloc_tx_buffer(param-&gt;my_rpmsg, &amp;size, RL_BLOCK);
          assert(tx_buf);
          /* Copy string to RPMsg tx buffer */
          memcpy(tx_buf, app_buf, len);
          /* Echo back received message with nocopy send */
          result = rpmsg_lite_send_nocopy(param-&gt;my_rpmsg, param-&gt;my_ept, remote_addr, tx_buf, len);
          if (result != 0)
          {
              assert(false);
          }
          /* Release held RPMsg rx buffer */
          result = rpmsg_queue_nocopy_free(param-&gt;my_rpmsg, rx_buf);
          if (result != 0)
          {
              assert(false);
          }
      }
  }
  
  static void rpmsg_task(void *param)
  {
      static struct rpmsg_struct my_rpmsg_struct;
  
      /* Print the initial banner */
      PRINTF(&quot;\r\nRPMSG String Echo FreeRTOS RTOS API Demo...\r\n&quot;);
  
  #ifdef MCMGR_USED
      uint32_t startupData;
  
      /* Get the startup data */
      (void)MCMGR_GetStartupData(kMCMGR_Core1, &amp;startupData);
  
      my_rpmsg = rpmsg_lite_remote_init((void *)startupData, RPMSG_LITE_LINK_ID, RL_NO_FLAGS);
  
      /* Signal the other core we are ready */
      (void)MCMGR_SignalReady(kMCMGR_Core1);
  #else
      my_rpmsg_struct.my_rpmsg = rpmsg_lite_remote_init((void *)RPMSG_LITE_SHMEM_BASE, RPMSG_LITE_LINK_ID, RL_NO_FLAGS);
  #endif /* MCMGR_USED */
  
      while (0 == rpmsg_lite_is_link_up(my_rpmsg_struct.my_rpmsg))
          ;
  
      my_rpmsg_struct.my_queue = rpmsg_queue_create(my_rpmsg_struct.my_rpmsg);
      my_rpmsg_struct.my_ept   = rpmsg_lite_create_ept(my_rpmsg_struct.my_rpmsg, LOCAL_EPT_ADDR, rpmsg_queue_rx_cb, my_rpmsg_struct.my_queue);
      (void)rpmsg_ns_announce(my_rpmsg_struct.my_rpmsg, my_rpmsg_struct.my_ept, RPMSG_LITE_NS_ANNOUNCE_STRING, RL_NS_CREATE);
  
      PRINTF(&quot;\r\nNameservice sent, ready for incoming messages...\r\n&quot;);
  
      if (xTaskCreate(rpmsg_tx_task, &quot;rpmsg_tx_task&quot;, RPMSG_TX_TASK_STACK_SIZE, &amp;my_rpmsg_struct, tskIDLE_PRIORITY + 1, &amp;rpmsg_tx_task_handle) != pdPASS)
      {
          PRINTF(&quot;\r\nFailed to create rpmsg_tx_task\r\n&quot;);
          for (;;)
              ;
      }
  }
  
  /*!
   * @brief Main function
   */
  int main(void)
  {
      /* Initialize standard SDK demo application pins */
      /* Board specific RDC settings */
      BOARD_RdcInit();
  
      BOARD_InitBootPins();
      BOARD_BootClockRUN();
      BOARD_InitDebugConsole();
      BOARD_InitMemory();
  
      copyResourceTable();
  
  #ifdef MCMGR_USED
      /* Initialize MCMGR before calling its API */
      (void)MCMGR_Init();
  #endif /* MCMGR_USED */
  
      if (xTaskCreate(rpmsg_task, &quot;rpmsg_task&quot;, RPMSG_TASK_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, &amp;rpmsg_task_handle) != pdPASS)
      {
          PRINTF(&quot;\r\nFailed to create rpmsg_rx_task\r\n&quot;);
          for (;;)
              ;
      }
  
      vTaskStartScheduler();
  
      PRINTF(&quot;Failed to start FreeRTOS on core0.\n&quot;);
      for (;;)
          ;
  }
  </code></pre>