Statistics
| Branch: | Revision:

urtware / src / urt_core.c @ cd0cba58

History | View | Annotate | Download (7.07 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
 * @brief  core
38
 */
39
typedef struct urt_core
40
{
41
  urt_node_t* _nodes;
42
  urt_osEventSource_t* _evtSource;
43
  urt_osMutex_t _lock;
44
  urt_status_t _status;
45
  #if (URT_CFG_PUBSUB_ENABLED)
46
    urt_topic_t* _topics;
47
  #endif /* URT_CFG_PUBSUB_ENABLED */
48
  #if (URT_CFG_RPC_ENABLED)
49
    urt_service_t* _services;
50
  #endif /* URT_CFG_RPC_ENABLED */
51
}urt_core_t;
52

    
53
static urt_core_t core;
54

    
55
/******************************************************************************/
56
/* LOCAL VARIABLES                                                            */
57
/******************************************************************************/
58

    
59
/******************************************************************************/
60
/* LOCAL FUNCTIONS                                                            */
61
/******************************************************************************/
62

    
63
/******************************************************************************/
64
/* EXPORTED FUNCTIONS                                                         */
65
/******************************************************************************/
66

    
67
/**
68
 * @brief   Initialize the Core.
69
 */
70
void urtCoreInit(void)
71
{
72
  core._nodes = NULL;
73
  core._status = URT_STATUS_OK;
74
  urtEventSourceInit(core._evtSource);
75
  urtMutexInit(&core._lock);
76
  #if (URT_CFG_PUBSUB_ENABLED)
77
    core._topics = NULL;
78
  #endif /* URT_CFG_PUBSUB_ENABLED */
79
  #if (URT_CFG_RPC_ENABLED)
80
    core.urt_service_t = NULL;
81
  #endif /* URT_CFG_RPC_ENABLED */
82
  return;
83
}
84

    
85
/**
86
 * @brief   Get Core status.
87
 *
88
 * @return  Current system status.
89
 */
90
urt_status_t urtCoreGetStatus(void)
91
{
92
  return core._status;
93
}
94

    
95
urt_osEventMask_t urtCoreGetEventMask(void)
96
{
97
    return EVENT_MASK(32);
98
}
99

    
100
/**
101
 * @brief   Get Core mutex.
102
 *
103
 * @return  Current system mutex.
104
 */
105
urt_osMutex_t urtCoreGetMutex(void)
106
{
107
    return core._lock;
108
}
109

    
110
/**
111
 * @brief   Get Core event source.
112
 *
113
 * @return  Current system event source.
114
 */
115
urt_osEventSource_t* urtCoreGetEvtSource(void)
116
{
117
    return core._evtSource;
118
}
119

    
120
urt_node_t* urtCoreGetNodes(void)
121
{
122
    return core._nodes;
123
}
124

    
125
/**
126
 * @brief   Start threads of all nodes of the Core.
127
 */
128
void urtCoreStartNodes(void)
129
{
130
  urtMutexLock(&core._lock);
131
  urt_node_t* node = core._nodes;
132
  while (node)
133
  {
134
    urtThreadStart(node->thread);
135
    node = node->next;
136
  }
137
  urtMutexUnlock(&core._lock);
138
  return;
139
}
140

    
141
/**
142
 * @brief   Synchronize all nodes of the core.
143
 *
144
 * @param[in] node  Pointer to a node to synchronize. Must not be NULL.
145
 *
146
 * @return  Returns URT_STATUS_OK if all nodes are synchronized and proceed.
147
 *          Returns URT_STATUS_SYNC_ERROR if an exception occurred (faulty stage value detected).
148
 *          Returns URT_STATUS_SYNC_PENDING if there are nodes left to synchronize.
149
 *          In the latter case, the node thread must still wait for the control event (proceed) to synchronize.
150
 */
151
urt_status_t urtCoreSynchronizeNodes(urt_node_t* node)
152
{
153
  urtDebugAssert(node != NULL);
154

    
155
  urtMutexLock(&core._lock);
156
  node->stage -= 1;
157
  urt_node_t* nodeFromCore = core._nodes;
158
  while (nodeFromCore && nodeFromCore->stage == node->stage)
159
  {
160
    nodeFromCore = nodeFromCore->next;
161
  }
162
  if (nodeFromCore)
163
  {
164
    urt_osEventFlags_t flag = URT_EVENTFLAG_PROCEED;
165
    urtEventSourceBroadcast(core._evtSource, flag);
166
    urtMutexUnlock(&core._lock);
167
    return URT_STATUS_OK;
168
  }
169
  else if (nodeFromCore->stage == (node->stage - 1))
170
  {
171
    urtMutexUnlock(&core._lock);
172
    return URT_STATUS_SYNC_PENDING;
173
  }
174
  else
175
  {
176
      urtCoreStopNodes(URT_STATUS_SYNC_ERROR);
177
      urtMutexUnlock(&core._lock);
178
      return URT_STATUS_SYNC_ERROR;
179
  }
180
}
181

    
182
/**
183
 * @brief   Stop threads of all nodes of the Core.
184
 *
185
 * @param[in] reason  The reason why the function was called. For normal shutdown URT_STATUS_OK should be used.
186
 *
187
 * @return  Returns URT_STATUS_OK if there was no call with another reason than URT_STATUS_OK before.
188
 *          If the function has been called before with a different reason, that reason is returned.
189
 */
190
urt_status_t urtCoreStopNodes(urt_status_t reason)
191
{
192
  urtMutexLock(&core._lock);
193
  bool priorityBoosted = false;
194
  urt_osThreadPrio_t oldPrio;
195

    
196
  if (core._status == URT_STATUS_OK)
197
  {
198
    if (core._nodes->thread->prio < URT_THREAD_PRIO_HIGH_MAX)
199
    {
200
      oldPrio = core._nodes->thread->prio;
201
      priorityBoosted = true;
202
      core._nodes->thread->prio = URT_THREAD_PRIO_HIGH_MAX;
203
    }
204
    core._status = reason;
205
    urt_node_t* node = core._nodes;
206
    while (node)
207
    {
208
      urtThreadTerminate(node->thread, URT_THREAD_TERMINATE_REQUEST);
209
      node = node->next;
210
    }
211
    urt_osEventFlags_t flag = URT_EVENTFLAG_TERMINATE;
212
    urtEventSourceBroadcast(core._evtSource, flag);
213
    urtMutexUnlock(&core._lock);
214
    if (priorityBoosted)
215
      core._nodes->thread->prio = oldPrio;
216
    return URT_STATUS_OK;
217
  }
218
  else
219
  {
220
    urtMutexUnlock(&core._lock);
221
    return core._status;
222
  }
223
}
224

    
225
/**
226
 * @brief   Get the topic of the Core.
227
 *
228
 * @param[in] id  Identifier of the topic to retrieve.
229
 *
230
 * @return  Returns a pointer to the requested service. Returns NULL if no service matches the given ID.
231
 */
232
#if (URT_CFG_PUBSUB_ENABLED)
233
  urt_topic_t* urtCoreGetTopic(urt_topicid_t id) {return urt_topic_t;}
234
#endif /* URT_CFG_PUBSUB_ENABLED */
235

    
236

    
237
/**
238
 * @brief   Get the service of the Core.
239
 *
240
 * @param[in] id  Identifier of the service to retrieve.
241
 *
242
 * @return Returns a pointer to the requested service. Returns NULL if no service matches the given ID.
243
 */  
244
#if (URT_CFG_RPC_ENABLED)
245
  urt_service_t urtCoreGetService(urt_serviceid_t id) {return urt_service_t;}
246
#endif /* URT_CFG_RPC_ENABLED */
247

    
248