Revision e360ce71

View differences:

inc/urt_core.h
58 58
  urt_osMutex_t* urtCoreGetMutex(void);
59 59
  urt_osEventSource_t* urtCoreGetEvtSource(void);
60 60
  urt_node_t* urtCoreGetNodes(void);
61
  void urtCoreSetNodes(urt_node_t* node);
61 62
  void urtCoreStartNodes(void);
62 63
  urt_status_t urtCoreSynchronizeNodes(urt_node_t* node);
63 64
  urt_status_t urtCoreStopNodes(urt_status_t reason);
src/urt_core.c
117 117
    return &core._evtSource;
118 118
}
119 119

  
120

  
121
/**
122
 * @brief   Get Core nodes.
123
 *
124
 * @return  Nodes registered to the core.
125
 */
120 126
urt_node_t* urtCoreGetNodes(void)
121 127
{
122 128
    return core._nodes;
123 129
}
124 130

  
131
void urtCoreSetNodes(urt_node_t* node)
132
{
133
    core._nodes = node;
134
    return;
135
}
136

  
125 137
/**
126 138
 * @brief   Start threads of all nodes of the Core.
127 139
 */
......
133 145
  {
134 146
    urtThreadStart(node->thread);
135 147
    node = node->next;
148
    urtThreadMSleep(100); //TODO: delete
136 149
  }
137 150
  urtMutexUnlock(&core._lock);
138 151
  return;
......
153 166
  urtDebugAssert(node != NULL);
154 167

  
155 168
  urtMutexLock(&core._lock);
156
  node->stage -= 1;
169
  node->stage++;
157 170
  urt_node_t* nodeFromCore = core._nodes;
158 171
  while (nodeFromCore && nodeFromCore->stage == node->stage)
159 172
  {
160 173
    nodeFromCore = nodeFromCore->next;
161 174
  }
162
  if (nodeFromCore)
175

  
176
  if (!nodeFromCore)
163 177
  {
164 178
    urt_osEventFlags_t flag = URT_EVENTFLAG_PROCEED;
165 179
    urtEventSourceBroadcast(&core._evtSource, flag);
src/urt_node.c
69 69
    urtCoreSynchronizeNodes(((urt_node_t*)arg));
70 70
  }
71 71

  
72
  while (!urtThreadShouldTerminate())
72

  
73
  while (/*!*/urtThreadShouldTerminate()) //TODO: uncomment
73 74
  {
74 75
    urt_osEventMask_t temp = urtEventWait(mask, URT_EVENT_WAIT_ONE, URT_DELAY_INFINITE);
75 76
    if (temp == urtCoreGetEventMask())
......
90 91
    ((urt_node_t*)arg)->shutdowncallback(((urt_node_t*)arg), urtCoreGetStatus(), ((urt_node_t*)arg)->shutdownparams);
91 92
  }
92 93
  urtEventUnregister(urtCoreGetEvtSource(), &((urt_node_t*)arg)->listener);
93

  
94 94
  urt_osThread_t* threadToTerminate = ((urt_node_t*)arg)->thread;
95 95
  while (threadToTerminate->children != NULL || threadToTerminate->sibling != NULL)
96 96
  {
......
109 109
    if(threadToJoin->sibling != NULL)
110 110
      urtThreadJoin(threadToJoin->sibling);
111 111
  }
112
  urtThreadJoin(threadToJoin);
112
  //urtThreadJoin(threadToJoin); //TODO: uncomment
113 113

  
114 114
  return;
115 115
}
......
146 146
    urtDebugAssert(setupparams == NULL);
147 147

  
148 148
  node->next = NULL;
149
  urtPrintf("Test before threadInit in node\n");
150
  urtThreadMSleep(10);
151 149
  node->thread = urtThreadInit((void*)thread, sizeof(thread), prio, (urt_osThreadFunction_t) _main, (void*)node);
152
  urtPrintf("Test after threadInit in node\n");
153
  urtThreadMSleep(10);
154 150
  node->setupcallback = setupcallback;
155 151
  node->setupparams = setupparams;
156 152
  node->loopcallback = loopcallback;
......
165 161
  urt_osMutex_t* mutexTemp = urtCoreGetMutex();
166 162
  urtMutexLock(mutexTemp);
167 163
    node->next = urtCoreGetNodes();
168
    urt_node_t* nodeCore = urtCoreGetNodes();
169
    nodeCore->next = node;
164
    urtCoreSetNodes(node);
170 165
  urtMutexUnlock(mutexTemp);
171 166
  return;
172 167
}

Also available in: Unified diff