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:Correct?

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

/* LOCAL FUNCTIONS                                                            */

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

/**

 * @brief  Main function of a node.

 *

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

 */

void _main(void* arg)

{

    //TODO: Register to core event

    if (localNode.setupcallback != NULL)

    {

        // urt_osEventMask_t mask = localNode.setupcallback(localNode, arg);

        // TODOs

    }

    else

    {

        //TODO: act as if setupcallback returned 0xF..F

    }

    if (core._status == URT_STATUS_OK)

    {

        //TODO: Suspend all child threads

        urtCoreSynchronizeNodes(&localNode);

        //TODO: Resume all child threads

    }

    //TODOs

    return;

}

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

/* EXPORTED FUNCTIONS                                                         */

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

/**

 * @brief  Initalize a 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)

{

  urtDebugAssert(node != NULL);

  urtDebugAssert(thread != NULL);

  //TODO: Setupcallback

  if (setupcallback == NULL)

    urtDebugAssert(setupparams == NULL);

  urtDebugAssert(loopcallback != NULL);

  //urtDebugAssert(/*loopparams*/);

  //urtDebugAssert(shutdowncallback);

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

  urtMutexLock(&core._lock);

    node->next = core._nodes;

    core._nodes = node;

  urtMutexUnlock(&core._lock);

  localNode = *node;

  return;

}