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                                                            */

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

urt_node_t localNode; //TODO

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

/* LOCAL FUNCTIONS                                                            */

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

/**

 * @brief  Main function of a node.

 *

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

 */

void _main(void* arg)

{

  urt_osEventMask_t mask;

  urt_osEventFlags_t flag = 0;

  urtEventRegister(urtCoreGetEvtSource(), &localNode.listener, mask, flag);

  if (localNode.setupcallback != NULL)

  {

    mask = localNode.setupcallback(&localNode, arg);

    if (mask == urtCoreGetEventMask())

    {

        urtCoreStopNodes(URT_STATUS_NODE_INVALEVTMASK);

    }

  }

  else

  {

     mask = 0xFFFFFFFF;

  }

  if (urtCoreGetStatus() == URT_STATUS_OK)

  {

    urtCoreSynchronizeNodes(&localNode);

  }

  bool terminated = false;

  if (terminated /*TODO: replace with function*/)

  {

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

    if (temp == urtCoreGetEventMask())

    {

      localNode.loopcallback(&localNode, mask, arg);

      #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(), arg);

  }

  urtEventUnregister(urtCoreGetEvtSource(), &localNode.listener);

  urt_osThread_t* threadToTerminate = localNode.thread;

  urt_osThread_t* threadToTerminateChild;

  while (threadToTerminate != NULL)

  {

    threadToTerminateChild = threadToTerminate->children;

    urtThreadTerminate(&threadToTerminate, URT_THREAD_TERMINATE_REQUEST);

    threadToTerminate = threadToTerminateChild;

  }

  urtThreadExit();

  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_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;

  void *memory = (void*)0x28ff44;

  urt_osThreadFunction_t func; //TODO: Here the hello world func?

  thread = urtThreadInit(memory, SIZEOF_PTR, URT_THREAD_PRIO_NORMAL_MIN, func, NULL);

  node->thread = thread;

  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 = node;

  urtMutexUnlock(&mutexTemp);

  localNode = *node;

  return;

}