Revision 792f6c74

View differences:

inc/urt_core.h
55 55 
  void urtCoreInit(void);
56 56 
  urt_status_t urtCoreGetStatus(void);
57 57 
  urt_osEventMask_t urtCoreGetEventMask(void);
58 
  urt_osMutex_t urtCoreGetMutex(void);
58 
  urt_osMutex_t* urtCoreGetMutex(void);
59 59 
  urt_osEventSource_t* urtCoreGetEvtSource(void);
60 60 
  urt_node_t* urtCoreGetNodes(void);
61 61 
  void urtCoreStartNodes(void);
src/urt_core.c
39 39 
typedef struct urt_core
40 40 
{
41 41 
  urt_node_t* _nodes;
42 
  urt_osEventSource_t* _evtSource;
42 
  urt_osEventSource_t _evtSource;
43 43 
  urt_osMutex_t _lock;
44 44 
  urt_status_t _status;
45 45 
  #if (URT_CFG_PUBSUB_ENABLED)
......
71 71 
{
72 72 
  core._nodes = NULL;
73 73 
  core._status = URT_STATUS_OK;
74 
  urtEventSourceInit(core._evtSource);
74 
  urtEventSourceInit(&core._evtSource);
75 75 
  urtMutexInit(&core._lock);
76 76 
  #if (URT_CFG_PUBSUB_ENABLED)
77 77 
    core._topics = NULL;
......
94 94 

  		




  95
  95
  
    
urt_osEventMask_t urtCoreGetEventMask(void)


  		




  96
  96
  
    
{


  		




  97
  
  
    
    return EVENT_MASK(32);


  		




  
  97
  
    
    return URT_EVENTMASK_MAXPRIO;


  		




  98
  98
  
    
}


  		




  99
  99
  
    

  		




  100
  100
  
    
/**


  		




  ......




  102
  102
  
    
 *


  		




  103
  103
  
    
 * @return  Current system mutex.


  		




  104
  104
  
    
 */


  		




  105
  
  
    
urt_osMutex_t urtCoreGetMutex(void)


  		




  
  105
  
    
urt_osMutex_t* urtCoreGetMutex(void)


  		




  106
  106
  
    
{


  		




  107
  
  
    
    return core._lock;


  		




  
  107
  
    
    return &core._lock;


  		




  108
  108
  
    
}


  		




  109
  109
  
    

  		




  110
  110
  
    
/**


  		




  ......




  114
  114
  
    
 */


  		




  115
  115
  
    
urt_osEventSource_t* urtCoreGetEvtSource(void)


  		




  116
  116
  
    
{


  		




  117
  
  
    
    return core._evtSource;


  		




  
  117
  
    
    return &core._evtSource;


  		




  118
  118
  
    
}


  		




  119
  119
  
    

  		




  120
  120
  
    
urt_node_t* urtCoreGetNodes(void)


  		




  121
  121
  
    
{


  		




  122
  
  
    
    return core._nodes;


  		




  
  122
  
    
    return &core._nodes;


  		




  123
  123
  
    
}


  		




  124
  124
  
    

  		




  125
  125
  
    
/**


  		




  ......




  162
  162
  
    
  if (nodeFromCore)


  		




  163
  163
  
    
  {


  		




  164
  164
  
    
    urt_osEventFlags_t flag = URT_EVENTFLAG_PROCEED;


  		




  165
  
  
    
    urtEventSourceBroadcast(core._evtSource, flag);


  		




  
  165
  
    
    urtEventSourceBroadcast(&core._evtSource, flag);


  		




  166
  166
  
    
    urtMutexUnlock(&core._lock);


  		




  167
  167
  
    
    return URT_STATUS_OK;


  		




  168
  168
  
    
  }


  		




  ......




  209
  209
  
    
      node = node->next;


  		




  210
  210
  
    
    }


  		




  211
  211
  
    
    urt_osEventFlags_t flag = URT_EVENTFLAG_TERMINATE;


  		




  212
  
  
    
    urtEventSourceBroadcast(core._evtSource, flag);


  		




  
  212
  
    
    urtEventSourceBroadcast(&core._evtSource, flag);


  		




  213
  213
  
    
    urtMutexUnlock(&core._lock);


  		




  214
  214
  
    
    if (priorityBoosted)


  		




  215
  215
  
    
      core._nodes->thread->prio = oldPrio;


  		












  

    
      src/urt_node.c
    
  





  37
  37
  
    
/* LOCAL VARIABLES                                                            */


  		




  38
  38
  
    
/******************************************************************************/


  		




  39
  39
  
    

  		




  40
  
  
    
urt_node_t localNode; //TODO


  		




  
  40
  
    
urt_node_t localNode;


  		




  
  41
  
    
static  URT_THREAD_MEMORY(_node_thread, AMIROOS_CFG_SHELL_STACKSIZE);


  		




  41
  42
  
    

  		




  42
  43
  
    
/******************************************************************************/


  		




  43
  44
  
    
/* LOCAL FUNCTIONS                                                            */


  		




  ......




  63
  64
  
    
  }


  		




  64
  65
  
    
  else


  		




  65
  66
  
    
  {


  		




  66
  
  
    
     mask = 0xFFFFFFFF;


  		




  
  67
  
    
     mask = ALL_EVENTS;


  		




  67
  68
  
    
  }


  		




  68
  69
  
    

  		




  69
  70
  
    
  if (urtCoreGetStatus() == URT_STATUS_OK)


  		




  ......




  71
  72
  
    
    urtCoreSynchronizeNodes(&localNode);


  		




  72
  73
  
    
  }


  		




  73
  74
  
    

  		




  74
  
  
    
  bool terminated = false;


  		




  75
  
  
    
  if (terminated /*TODO: replace with function*/)


  		




  
  75
  
    
  if (!urtThreadShouldTerminate())


  		




  76
  76
  
    
  {


  		




  77
  77
  
    
    urt_osEventMask_t temp = urtEventWait(mask, URT_EVENT_WAIT_ONE, URT_DELAY_INFINITE);


  		




  78
  78
  
    
    if (temp == urtCoreGetEventMask())


  		




  ......




  93
  93
  
    
    localNode.shutdowncallback(&localNode, urtCoreGetStatus(), arg);


  		




  94
  94
  
    
  }


  		




  95
  95
  
    
  urtEventUnregister(urtCoreGetEvtSource(), &localNode.listener);


  		




  
  96
  
    

  		




  
  97
  
    

  		




  96
  98
  
    
  urt_osThread_t* threadToTerminate = localNode.thread;


  		




  97
  
  
    
  urt_osThread_t* threadToTerminateChild;


  		




  98
  
  
    
  while (threadToTerminate != NULL)


  		




  
  99
  
    
  while (threadToTerminate->children != NULL || threadToTerminate->sibling != NULL)


  		




  99
  100
  
    
  {


  		




  100
  
  
    
    threadToTerminateChild = threadToTerminate->children;


  		




  101
  
  
    
    urtThreadTerminate(&threadToTerminate, URT_THREAD_TERMINATE_REQUEST);


  		




  102
  
  
    
    threadToTerminate = threadToTerminateChild;


  		




  
  101
  
    
    if (threadToTerminate->children != NULL)


  		




  
  102
  
    
      urtThreadTerminate(threadToTerminate->children, URT_THREAD_TERMINATE_REQUEST);


  		




  
  103
  
    
    if(threadToTerminate->sibling != NULL)


  		




  
  104
  
    
      urtThreadTerminate(threadToTerminate->sibling, URT_THREAD_TERMINATE_REQUEST);


  		




  103
  105
  
    
  }


  		




  104
  
  
    
  urtThreadExit();


  		




  
  106
  
    
  urtThreadTerminate(&threadToTerminate, URT_THREAD_TERMINATE_REQUEST);


  		




  
  107
  
    

  		




  105
  108
  
    
  return;


  		




  106
  109
  
    
}


  		




  107
  110
  
    

  		




  ......




  138
  141
  
    
    urtDebugAssert(setupparams == NULL);


  		




  139
  142
  
    

  		




  140
  143
  
    
  node->next = NULL;


  		




  141
  
  
    
  void *memory = (void*)0x28ff44;


  		




  142
  
  
    
  urt_osThreadFunction_t func; //TODO: Here the hello world func?


  		




  143
  
  
    
  thread = urtThreadInit(memory, SIZEOF_PTR, URT_THREAD_PRIO_NORMAL_MIN, func, NULL);


  		




  144
  
  
    
  node->thread = thread;


  		




  
  144
  
    
  node->thread = urtThreadInit(_node_thread, sizeof(_node_thread), URT_THREAD_PRIO_NORMAL_MIN, _main, setupparams);


  		




  145
  145
  
    
  node->setupcallback = setupcallback;


  		




  146
  146
  
    
  node->setupparams = setupparams;


  		




  147
  147
  
    
  node->loopcallback = loopcallback;


  		




  ......




  153
  153
  
    
  #if (URT_CFG_PUBSUB_PROFILING || URT_CFG_RPC_PROFILING)


  		




  154
  154
  
    
    node->loops = 0;


  		




  155
  155
  
    
  #endif /* URT_CFG_PUBSUB_PROFILING || URT_CFG_RPC_PROFILING */


  		




  156
  
  
    
  urt_osMutex_t mutexTemp = urtCoreGetMutex();


  		




  157
  
  
    
  urtMutexLock(&mutexTemp);


  		




  
  156
  
    
  urt_osMutex_t* mutexTemp = urtCoreGetMutex();


  		




  
  157
  
    
  urtMutexLock(mutexTemp);


  		




  158
  158
  
    
    node->next = urtCoreGetNodes();


  		




  159
  159
  
    
    urt_node_t* nodeCore = urtCoreGetNodes();


  		




  160
  160
  
    
    nodeCore = node;


  		




  161
  
  
    
  urtMutexUnlock(&mutexTemp);


  		




  
  161
  
    
  urtMutexUnlock(mutexTemp);


  		




  162
  162
  
    
  localNode = *node;


  		




  163
  163
  
    
  return;


  		




  164
  164
  
    
}


  		












Also available in:  Unified diff