AMiRo-OS

/*

µRtWare is a lightweight publish/subscribe middleware for real-time

applications. It was developed as part of the software habitat for the

Autonomous Mini Robot [1] (AMiRo) but can be used for other purposes as well.

Copyright (C) 2018..2020  Thomas Schöpping et al.

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include <urtware.h>

/******************************************************************************/

/* LOCAL DEFINITIONS                                                          */

/******************************************************************************/

/******************************************************************************/

/* EXPORTED VARIABLES                                                         */

/******************************************************************************/

/******************************************************************************/

/* LOCAL TYPES                                                                */

/******************************************************************************/

/******************************************************************************/

/* LOCAL VARIABLES                                                            */

/******************************************************************************/

/******************************************************************************/

/* LOCAL FUNCTIONS                                                            */

/******************************************************************************/

/**

 * @brief  Main function of a node.

 *

 * @param[in] arg  Optional Argument to the thread main function.

 */

void _main(void* arg)

{

  urt_node_t* localNode = (urt_node_t*)arg;

  urt_osEventMask_t mask;

  urt_osEventFlags_t flag = 0;

  urtEventRegister(urtCoreGetEvtSource(), &(localNode->listener), mask, flag);

  if (localNode->setupcallback != NULL)

  {

    mask = localNode->setupcallback(localNode, localNode->setupparams);

    if (mask == urtCoreGetEventMask())

    {

        urtCoreStopNodes(URT_STATUS_NODE_INVALEVTMASK);

    }

  }

  else

  {

     mask = URT_EVENTMASK_ALL;

  }

  if (urtCoreGetStatus() == URT_STATUS_OK)

  {

    urtCoreSynchronizeNodes(localNode);

  }

  if (!urtThreadShouldTerminate())

  {

    urt_osEventMask_t temp = urtEventWait(mask, URT_EVENT_WAIT_ONE, URT_DELAY_INFINITE);

    if (temp == urtCoreGetEventMask())

    {

      localNode->loopcallback(localNode, mask, localNode->loopparams);

      #if (URT_CFG_PUBSUB_PROFILING || URT_CFG_RPC_PROFILING)

        localNode->loops++;

      #endif /* URT_CFG_PUBSUB_PROFILING || URT_CFG_RPC_PROFILING */

      if (mask == urtCoreGetEventMask())

      {

        urtCoreStopNodes(URT_STATUS_NODE_INVALEVTMASK);

      }

    }

  }

  if (localNode->shutdowncallback)

  {

    localNode->shutdowncallback(localNode, urtCoreGetStatus(), localNode->shutdownparams);

  }

  urtEventUnregister(urtCoreGetEvtSource(), &localNode->listener);

  urt_osThread_t* threadToTerminate = localNode->thread;

  while (threadToTerminate->children != NULL || threadToTerminate->sibling != NULL)

  {

    if (threadToTerminate->children != NULL)

      urtThreadTerminate(threadToTerminate->children, URT_THREAD_TERMINATE_REQUEST);

    if(threadToTerminate->sibling != NULL)

      urtThreadTerminate(threadToTerminate->sibling, URT_THREAD_TERMINATE_REQUEST);

  }

  urtThreadTerminate(threadToTerminate, URT_THREAD_TERMINATE_REQUEST);

  urt_osThread_t* threadToJoin = localNode->thread;

  while (threadToJoin->children != NULL || threadToJoin->sibling != NULL)

  {

    if (threadToJoin->children != NULL)

      urtThreadJoin(threadToJoin->children);

    if(threadToJoin->sibling != NULL)

      urtThreadJoin(threadToJoin->sibling);

  }

  urtThreadJoin(threadToJoin);

  return;

}

/******************************************************************************/

/* EXPORTED FUNCTIONS                                                         */

/******************************************************************************/

/**

 * @brief  Initalize a node.

 *

 * @param[in] node  The node to initialize. Must not be NULL.

 * @param[in] thread  The thread to intialize. Must be NULL.

 * @param[in] setupcallback  Callback function to be executed during setup.

 *                           May be NULL if no custom setup is required.

 * @param[in] setupparams  Parameters for the setup callback function.

 *                         Must be NULL if no setup callback is specified.

 *                         May be NULL if the specified setup callback does not expect parameters.

 * @param[in] loopcallback  Callback function to be executed in a loop.

 * @param[in] loopparams  Parameters for the loop callback function.

 *                        May be NULL if the specified loop callback does not expect parameters.

 * @param[in] shutdowncallback  Callback function to be executed during shutdown.

 *                              May be NULL if no custom shutdown is required.

 * @param[in] shutdownparams  Parameters for the loop callback function.

 *                            Must be NULL if no shutdown callback is specified.

 *                            May be NULL if the specified shutdown callback does not expect parameters.

 */

void urtNodeInit(urt_node_t* node, urt_osThread_t* thread, urt_osThreadPrio_t prio, urt_nodeSetupCallback_t setupcallback,

                 void* setupparams, urt_nodeLoopCallback_t loopcallback, void* loopparams,

                 urt_nodeShutdownCallback_t shutdowncallback, void* shutdownparams)

{

  urtDebugAssert(node != NULL);

  urtDebugAssert(thread == NULL);

  if (setupcallback == NULL)

    urtDebugAssert(setupparams == NULL);

  node->next = NULL;

  node->thread = urtThreadInit(thread, sizeof(thread), prio, _main, node);

  node->setupcallback = setupcallback;

  node->setupparams = setupparams;

  node->loopcallback = loopcallback;

  node->loopparams = loopparams;

  node->shutdowncallback = shutdowncallback;

  node->shutdownparams = shutdownparams;

  node->stage = 0;

  urtEventListenerInit(node->listener);

  #if (URT_CFG_PUBSUB_PROFILING || URT_CFG_RPC_PROFILING)

    node->loops = 0;

  #endif /* URT_CFG_PUBSUB_PROFILING || URT_CFG_RPC_PROFILING */

  urt_osMutex_t* mutexTemp = urtCoreGetMutex();

  urtMutexLock(mutexTemp);

    node->next = urtCoreGetNodes();

    urt_node_t* nodeCore = urtCoreGetNodes();

    nodeCore->next = node;

  urtMutexUnlock(mutexTemp);

  return;

}