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

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

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

/* EXPORTED FUNCTIONS                                                         */

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

/**

 * @brief  Initalize the node.

 *

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

 * @param[in] thread  The already initialized, exclusive thread for the node. Must not 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.

 *                          Must not be NULL.

 * @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)

{

  node->next = 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_core_t temp; //TODO: Correct?

  urtMutexLock(&temp._lock);

    node->next = temp._nodes;

    temp._nodes = node;

  urtMutexUnlock(&temp._lock);

  return;

}