Statistics
| Branch: | Revision:

urtware / src / urt_node.c @ 408b49ce

History | View | Annotate | Download (6.96 KB)

1
/*
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
#include <urtware.h>
23

    
24
/******************************************************************************/
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
/**
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
  urt_osEventMask_t mask;
52
  urt_osEventFlags_t flag = 0;
53
  urtEventRegister(urtCoreGetEvtSource(), &(((urt_node_t*)arg)->listener), mask, flag);
54
  if (((urt_node_t*)arg)->setupcallback != NULL)
55
  {
56
    mask = ((urt_node_t*)arg)->setupcallback(((urt_node_t*)arg), ((urt_node_t*)arg)->setupparams);
57
    if (mask == urtCoreGetEventMask())
58
    {
59
      urtCoreStopNodes(URT_STATUS_NODE_INVALEVTMASK);
60
    }
61
  }
62
  else
63
  {
64
    mask = URT_EVENTMASK_ALL;
65
  }
66

    
67
  if (urtCoreGetStatus() == URT_STATUS_OK)
68
  {
69
    urtCoreSynchronizeNodes(((urt_node_t*)arg));
70
  }
71

    
72
  while (!urtThreadShouldTerminate())
73
  {
74
    urt_osEventMask_t temp = urtEventWait(mask, URT_EVENT_WAIT_ONE, URT_DELAY_INFINITE);
75
    if (temp == urtCoreGetEventMask())
76
    {
77
      ((urt_node_t*)arg)->loopcallback(((urt_node_t*)arg), mask, ((urt_node_t*)arg)->loopparams);
78
      #if (URT_CFG_PUBSUB_PROFILING || URT_CFG_RPC_PROFILING)
79
        ((urt_node_t*)arg)->loops++;
80
      #endif /* URT_CFG_PUBSUB_PROFILING || URT_CFG_RPC_PROFILING */
81
      if (mask == urtCoreGetEventMask())
82
      {
83
        urtCoreStopNodes(URT_STATUS_NODE_INVALEVTMASK);
84
      }
85
    }
86
  }
87

    
88
  if (((urt_node_t*)arg)->shutdowncallback != NULL)
89
  {
90
    ((urt_node_t*)arg)->shutdowncallback(((urt_node_t*)arg), urtCoreGetStatus(), ((urt_node_t*)arg)->shutdownparams);
91
  }
92
  urtEventUnregister(urtCoreGetEvtSource(), &((urt_node_t*)arg)->listener);
93

    
94
  urt_osThread_t* threadToTerminate = ((urt_node_t*)arg)->thread;
95
  while (threadToTerminate->children != NULL || threadToTerminate->sibling != NULL)
96
  {
97
    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
  }
102
  urtThreadTerminate(threadToTerminate, URT_THREAD_TERMINATE_REQUEST);
103

    
104
  urt_osThread_t* threadToJoin = ((urt_node_t*)arg)->thread;
105
  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
  urtThreadJoin(threadToJoin);
113

    
114
  return;
115
}
116

    
117
/******************************************************************************/
118
/* EXPORTED FUNCTIONS                                                         */
119
/******************************************************************************/
120

    
121
/**
122
 * @brief  Initalize a node.
123
 *
124
 * @param[in] node  The node to initialize. Must not be NULL.
125
 * @param[in] thread  The thread to intialize.
126
 * @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
 *                         Must be NULL if no setup callback is specified.
130
 *                         May be NULL if the specified setup callback does not expect parameters.
131
 * @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
 */
140
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
{
144
  urtDebugAssert(node != NULL);
145
  if (setupcallback == NULL)
146
    urtDebugAssert(setupparams == NULL);
147

    
148
  node->next = NULL;
149
  node->thread = urtThreadInit((void*)thread, sizeof(thread), prio, (urt_osThreadFunction_t) _main, (void*)node);
150
  node->setupcallback = setupcallback;
151
  node->setupparams = setupparams;
152
  node->loopcallback = loopcallback;
153
  node->loopparams = loopparams;
154
  node->shutdowncallback = shutdowncallback;
155
  node->shutdownparams = shutdownparams;
156
  node->stage = 0;
157
  urtEventListenerInit(node->listener);
158
  #if (URT_CFG_PUBSUB_PROFILING || URT_CFG_RPC_PROFILING)
159
    node->loops = 0;
160
  #endif /* URT_CFG_PUBSUB_PROFILING || URT_CFG_RPC_PROFILING */
161
  urt_osMutex_t* mutexTemp = urtCoreGetMutex();
162
  urtMutexLock(mutexTemp);
163
    node->next = urtCoreGetNodes();
164
    urt_node_t* nodeCore = urtCoreGetNodes();
165
    nodeCore->next = node;
166
  urtMutexUnlock(mutexTemp);
167
  return;
168
}