Statistics
| Branch: | Revision:

urtware / src / urt_node.c @ e360ce71

History | View | Annotate | Download (6.96 KB)

1 1fb06240 skenneweg
/*
2
µRtWare is a lightweight publish/subscribe middleware for real-time
3
applications. It was developed as part of the software habitat for the
4
Autonomous Mini Robot [1] (AMiRo) but can be used for other purposes as well.
5

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

8
This program is free software: you can redistribute it and/or modify
9
it under the terms of the GNU General Public License as published by
10
the Free Software Foundation, either version 3 of the License, or
11
(at your option) any later version.
12

13
This program is distributed in the hope that it will be useful,
14
but WITHOUT ANY WARRANTY; without even the implied warranty of
15
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
GNU General Public License for more details.
17

18
You should have received a copy of the GNU General Public License
19
along with this program.  If not, see <http://www.gnu.org/licenses/>.
20
*/
21
22 7d9678db skenneweg
#include <urtware.h>
23
24 1fb06240 skenneweg
/******************************************************************************/
25
/* LOCAL DEFINITIONS                                                          */
26
/******************************************************************************/
27
28
/******************************************************************************/
29
/* EXPORTED VARIABLES                                                         */
30
/******************************************************************************/
31
32
/******************************************************************************/
33
/* LOCAL TYPES                                                                */
34
/******************************************************************************/
35
36
/******************************************************************************/
37
/* LOCAL VARIABLES                                                            */
38
/******************************************************************************/
39
40
/******************************************************************************/
41
/* LOCAL FUNCTIONS                                                            */
42
/******************************************************************************/
43
44 17d978fe skenneweg
/**
45
 * @brief  Main function of a node.
46
 *
47
 * @param[in] arg  Optional Argument to the thread main function.
48
 */
49
void _main(void* arg)
50
{
51 1bfc6b25 skenneweg
  urt_osEventMask_t mask;
52 cd0cba58 skenneweg
  urt_osEventFlags_t flag = 0;
53 408b49ce skenneweg
  urtEventRegister(urtCoreGetEvtSource(), &(((urt_node_t*)arg)->listener), mask, flag);
54
  if (((urt_node_t*)arg)->setupcallback != NULL)
55 1bfc6b25 skenneweg
  {
56 408b49ce skenneweg
    mask = ((urt_node_t*)arg)->setupcallback(((urt_node_t*)arg), ((urt_node_t*)arg)->setupparams);
57 cd0cba58 skenneweg
    if (mask == urtCoreGetEventMask())
58 17d978fe skenneweg
    {
59 408b49ce skenneweg
      urtCoreStopNodes(URT_STATUS_NODE_INVALEVTMASK);
60 17d978fe skenneweg
    }
61 1bfc6b25 skenneweg
  }
62
  else
63
  {
64 408b49ce skenneweg
    mask = URT_EVENTMASK_ALL;
65 1bfc6b25 skenneweg
  }
66
67 408a606c skenneweg
  if (urtCoreGetStatus() == URT_STATUS_OK)
68 1bfc6b25 skenneweg
  {
69 408b49ce skenneweg
    urtCoreSynchronizeNodes(((urt_node_t*)arg));
70 1bfc6b25 skenneweg
  }
71
72 e360ce71 skenneweg
73
  while (/*!*/urtThreadShouldTerminate()) //TODO: uncomment
74 1bfc6b25 skenneweg
  {
75
    urt_osEventMask_t temp = urtEventWait(mask, URT_EVENT_WAIT_ONE, URT_DELAY_INFINITE);
76 cd0cba58 skenneweg
    if (temp == urtCoreGetEventMask())
77 17d978fe skenneweg
    {
78 408b49ce skenneweg
      ((urt_node_t*)arg)->loopcallback(((urt_node_t*)arg), mask, ((urt_node_t*)arg)->loopparams);
79 1bfc6b25 skenneweg
      #if (URT_CFG_PUBSUB_PROFILING || URT_CFG_RPC_PROFILING)
80 408b49ce skenneweg
        ((urt_node_t*)arg)->loops++;
81 1bfc6b25 skenneweg
      #endif /* URT_CFG_PUBSUB_PROFILING || URT_CFG_RPC_PROFILING */
82 cd0cba58 skenneweg
      if (mask == urtCoreGetEventMask())
83 1bfc6b25 skenneweg
      {
84
        urtCoreStopNodes(URT_STATUS_NODE_INVALEVTMASK);
85
      }
86 17d978fe skenneweg
    }
87 1bfc6b25 skenneweg
  }
88
89 408b49ce skenneweg
  if (((urt_node_t*)arg)->shutdowncallback != NULL)
90 1bfc6b25 skenneweg
  {
91 408b49ce skenneweg
    ((urt_node_t*)arg)->shutdowncallback(((urt_node_t*)arg), urtCoreGetStatus(), ((urt_node_t*)arg)->shutdownparams);
92 1bfc6b25 skenneweg
  }
93 408b49ce skenneweg
  urtEventUnregister(urtCoreGetEvtSource(), &((urt_node_t*)arg)->listener);
94
  urt_osThread_t* threadToTerminate = ((urt_node_t*)arg)->thread;
95 792f6c74 skenneweg
  while (threadToTerminate->children != NULL || threadToTerminate->sibling != NULL)
96 1bfc6b25 skenneweg
  {
97 792f6c74 skenneweg
    if (threadToTerminate->children != NULL)
98
      urtThreadTerminate(threadToTerminate->children, URT_THREAD_TERMINATE_REQUEST);
99
    if(threadToTerminate->sibling != NULL)
100
      urtThreadTerminate(threadToTerminate->sibling, URT_THREAD_TERMINATE_REQUEST);
101 1bfc6b25 skenneweg
  }
102 f86427e8 skenneweg
  urtThreadTerminate(threadToTerminate, URT_THREAD_TERMINATE_REQUEST);
103 792f6c74 skenneweg
104 408b49ce skenneweg
  urt_osThread_t* threadToJoin = ((urt_node_t*)arg)->thread;
105 22ccef0f skenneweg
  while (threadToJoin->children != NULL || threadToJoin->sibling != NULL)
106
  {
107
    if (threadToJoin->children != NULL)
108
      urtThreadJoin(threadToJoin->children);
109
    if(threadToJoin->sibling != NULL)
110
      urtThreadJoin(threadToJoin->sibling);
111
  }
112 e360ce71 skenneweg
  //urtThreadJoin(threadToJoin); //TODO: uncomment
113 22ccef0f skenneweg
114 1bfc6b25 skenneweg
  return;
115 17d978fe skenneweg
}
116
117 1fb06240 skenneweg
/******************************************************************************/
118
/* EXPORTED FUNCTIONS                                                         */
119
/******************************************************************************/
120 7d9678db skenneweg
121
/**
122 17d978fe skenneweg
 * @brief  Initalize a node.
123 7d9678db skenneweg
 *
124 5198dfae skenneweg
 * @param[in] node  The node to initialize. Must not be NULL.
125 408b49ce skenneweg
 * @param[in] thread  The thread to intialize.
126 5198dfae skenneweg
 * @param[in] setupcallback  Callback function to be executed during setup.
127
 *                           May be NULL if no custom setup is required.
128
 * @param[in] setupparams  Parameters for the setup callback function.
129 1f7ffcff skenneweg
 *                         Must be NULL if no setup callback is specified.
130
 *                         May be NULL if the specified setup callback does not expect parameters.
131 5198dfae skenneweg
 * @param[in] loopcallback  Callback function to be executed in a loop.
132
 * @param[in] loopparams  Parameters for the loop callback function.
133
 *                        May be NULL if the specified loop callback does not expect parameters.
134
 * @param[in] shutdowncallback  Callback function to be executed during shutdown.
135
 *                              May be NULL if no custom shutdown is required.
136
 * @param[in] shutdownparams  Parameters for the loop callback function.
137
 *                            Must be NULL if no shutdown callback is specified.
138
 *                            May be NULL if the specified shutdown callback does not expect parameters.
139 7d9678db skenneweg
 */
140 4ea18a07 Svenja
void urtNodeInit(urt_node_t* node, urt_osThread_t* thread, urt_osThreadPrio_t prio, urt_nodeSetupCallback_t setupcallback,
141
                 void* setupparams, urt_nodeLoopCallback_t loopcallback, void* loopparams,
142
                 urt_nodeShutdownCallback_t shutdowncallback, void* shutdownparams)
143 1f7ffcff skenneweg
{
144 17d978fe skenneweg
  urtDebugAssert(node != NULL);
145
  if (setupcallback == NULL)
146
    urtDebugAssert(setupparams == NULL);
147
148 64fde4ba skenneweg
  node->next = NULL;
149 408b49ce skenneweg
  node->thread = urtThreadInit((void*)thread, sizeof(thread), prio, (urt_osThreadFunction_t) _main, (void*)node);
150 64fde4ba skenneweg
  node->setupcallback = setupcallback;
151
  node->setupparams = setupparams;
152 2c811df1 skenneweg
  node->loopcallback = loopcallback;
153 64fde4ba skenneweg
  node->loopparams = loopparams;
154 2c811df1 skenneweg
  node->shutdowncallback = shutdowncallback;
155
  node->shutdownparams = shutdownparams;
156 64fde4ba skenneweg
  node->stage = 0;
157 2c811df1 skenneweg
  urtEventListenerInit(node->listener);
158 1f7ffcff skenneweg
  #if (URT_CFG_PUBSUB_PROFILING || URT_CFG_RPC_PROFILING)
159 64fde4ba skenneweg
    node->loops = 0;
160 1f7ffcff skenneweg
  #endif /* URT_CFG_PUBSUB_PROFILING || URT_CFG_RPC_PROFILING */
161 792f6c74 skenneweg
  urt_osMutex_t* mutexTemp = urtCoreGetMutex();
162
  urtMutexLock(mutexTemp);
163 408a606c skenneweg
    node->next = urtCoreGetNodes();
164 e360ce71 skenneweg
    urtCoreSetNodes(node);
165 792f6c74 skenneweg
  urtMutexUnlock(mutexTemp);
166 1f7ffcff skenneweg
  return;
167
}