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

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

urt_core_t core;

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

/* LOCAL VARIABLES                                                            */

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

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

/* LOCAL FUNCTIONS                                                            */

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

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

/* EXPORTED FUNCTIONS                                                         */

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

/**

 * @brief   Initialize the Core.

 */

void urtCoreInit(void)

{

  core._nodes = NULL;

  core._status = URT_STATUS_OK;

  urtEventSourceInit(core._evtSource);

  urtMutexInit(&core._lock);

  #if (URT_CFG_PUBSUB_ENABLED)

    core._topics = NULL;

  #endif /* URT_CFG_PUBSUB_ENABLED */

  #if (URT_CFG_RPC_ENABLED)

    core.urt_service_t = NULL;

  #endif /* URT_CFG_RPC_ENABLED */

  return;

}

/**

 * @brief   Get Core status.

 *

 * @return  Current system status.

 */

urt_status_t urtCoreGetStatus(void)

{

  return core._status;

}

/**

 * @brief   Start threads of all nodes of the Core.

 */

void urtCoreStartNodes(void)

{

  //TODO: Lock core

  urt_node_t* node = core._nodes;

  while (node)

  {

    urtThreadStart(node->thread);

    node = node->next;

  }

  //TODO: Unlock core

  return;

}

/**

 * @brief   Synchronize all nodes of the core.

 *

 * @param[in] node  Pointer to a node to synchronize. Must not be NULL.

 *

 * @return  Returns URT_STATUS_OK if all nodes are synchronized and proceed.

 *          Returns URT_STATUS_SYNC_ERROR if an exception occurred (faulty stage value detected).

 *          Returns URT_STATUS_SYNC_PENDING if there are nodes left to synchronize.

 *          In the latter case, the node thread must still wait for the control event (proceed) to synchronize.

 */

urt_status_t urtCoreSynchronize(urt_node_t* node)

{

  //TODO: Lock core

  //TODO: Increment node's stage value

  urt_node_t* nodeFromCore = core._nodes;

  while (nodeFromCore /*stage equals stage*/)

  {

    nodeFromCore = nodeFromCore->next;

  }

  bool temp = false;

  if (temp/*all nodes are the same stage*/)

  {

    //TODO: Unlock core

    return URT_STATUS_OK;

  }

  else if (temp/*stage of the last checked node was one less than the argument*/)

  {

    //TODO: Unlock core

    return URT_STATUS_SYNC_PENDING;

  }

  else

  {

      urtCoreStopNodes(URT_STATUS_SYNC_ERROR);

      return URT_STATUS_SYNC_ERROR;

  }

}

/**

 * @brief   Stop threads of all nodes of the Core.

 *

 * @param[in] reason  The reason why the function was called. For normal shutdown URT_STATUS_OK should be used.

 *

 * @return  Returns URT_STATUS_OK if there was no call with another reason than URT_STATUS_OK before.

 *          If the function has been called before with a different reason, that reason is returned.

 */

urt_status_t urtCoreStopNodes(urt_status_t reason)

{

  //TODO: Lock core

  if (core._status == URT_STATUS_OK)

  {

    if (core._nodes->thread->prio < URT_THREAD_PRIO_HIGH_MAX)

    {

      core._nodes->thread->prio = URT_THREAD_PRIO_HIGH_MAX;

    }

    else

    {

      core._status = reason;

      urt_node_t* node = core._nodes;

      while (node)

      {

        urt_node_t* tempNode = node;

        tempNode = NULL;

        node = node->next;

      }

      //TODO: broadcast control event (terminate)

      //TODO:Unlock core

      //TODO: Thread boosted its priority?

    }

  }

  else

  {

      //TODO:Unlock core

      return core._status;

  }

  return URT_STATUS_OK;

}

/**

 * @brief   Get the topic of the Core.

 *

 * @param[in] id  Identifier of the topic to retrieve.

 *

 * @return  Returns a pointer to the requested service. Returns NULL if no service matches the given ID.

 */

#if (URT_CFG_PUBSUB_ENABLED)

  urt_topic_t* urtCoreGetTopic(urt_topicid_t id) {return urt_topic_t;}

#endif /* URT_CFG_PUBSUB_ENABLED */

/**

 * @brief   Get the service of the Core.

 *

 * @param[in] id  Identifier of the service to retrieve.

 *

 * @return Returns a pointer to the requested service. Returns NULL if no service matches the given ID.

 */  

#if (URT_CFG_RPC_ENABLED)

  urt_service_t urtCoreGetService(urt_serviceid_t id) {return urt_service_t;}

#endif /* URT_CFG_RPC_ENABLED */