| Line 52... |
Line 52... |
uint32 magic;
|
uint32 magic;
|
const char *name;
|
const char *name;
|
OS_Semaphore_t *semaphore;
|
OS_Semaphore_t *semaphore;
|
HeapNode_t *available;
|
HeapNode_t *available;
|
HeapNode_t base;
|
HeapNode_t base;
|
|
int count;
|
struct OS_Heap_s *alternate;
|
struct OS_Heap_s *alternate;
|
};
|
};
|
//typedef struct OS_Heap_s OS_Heap_t;
|
//typedef struct OS_Heap_s OS_Heap_t;
|
|
|
typedef enum {
|
typedef enum {
|
| Line 154... |
Line 155... |
heap->available = (HeapNode_t*)(heap + 1);
|
heap->available = (HeapNode_t*)(heap + 1);
|
heap->available->next = &heap->base;
|
heap->available->next = &heap->base;
|
heap->available->size = (size - sizeof(OS_Heap_t)) / sizeof(HeapNode_t);
|
heap->available->size = (size - sizeof(OS_Heap_t)) / sizeof(HeapNode_t);
|
heap->base.next = heap->available;
|
heap->base.next = heap->available;
|
heap->base.size = 0;
|
heap->base.size = 0;
|
|
heap->count = 0;
|
|
heap->alternate = NULL;
|
return heap;
|
return heap;
|
}
|
}
|
|
|
|
|
/******************************************/
|
/******************************************/
|
| Line 194... |
Line 197... |
node->size = nunits;
|
node->size = nunits;
|
}
|
}
|
heap->available = prevp;
|
heap->available = prevp;
|
node->next = (HeapNode_t*)heap;
|
node->next = (HeapNode_t*)heap;
|
OS_SemaphorePost(heap->semaphore);
|
OS_SemaphorePost(heap->semaphore);
|
|
++heap->count;
|
|
//UartPrintfCritical("OS_HeapMalloc(%d)=0x%x\n", bytes, (int)(node+1));
|
return (void*)(node + 1);
|
return (void*)(node + 1);
|
}
|
}
|
if(node == heap->available) //Wrapped around free list
|
if(node == heap->available) //Wrapped around free list
|
{
|
{
|
OS_SemaphorePost(heap->semaphore);
|
OS_SemaphorePost(heap->semaphore);
|
if(heap->alternate)
|
if(heap->alternate)
|
return OS_HeapMalloc(heap->alternate, bytes);
|
return OS_HeapMalloc(heap->alternate, bytes);
|
|
printf("M%d ", heap->count);
|
return NULL;
|
return NULL;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
| Line 214... |
Line 220... |
void OS_HeapFree(void *block)
|
void OS_HeapFree(void *block)
|
{
|
{
|
OS_Heap_t *heap;
|
OS_Heap_t *heap;
|
HeapNode_t *bp, *node;
|
HeapNode_t *bp, *node;
|
|
|
|
//UartPrintfCritical("OS_HeapFree(0x%x)\n", block);
|
assert(block);
|
assert(block);
|
bp = (HeapNode_t*)block - 1; //point to block header
|
bp = (HeapNode_t*)block - 1; //point to block header
|
heap = (OS_Heap_t*)bp->next;
|
heap = (OS_Heap_t*)bp->next;
|
assert(heap->magic == HEAP_MAGIC);
|
assert(heap->magic == HEAP_MAGIC);
|
if(heap->magic != HEAP_MAGIC)
|
if(heap->magic != HEAP_MAGIC)
|
return;
|
return;
|
|
--heap->count;
|
OS_SemaphorePend(heap->semaphore, OS_WAIT_FOREVER);
|
OS_SemaphorePend(heap->semaphore, OS_WAIT_FOREVER);
|
for(node = heap->available; !(node < bp && bp < node->next); node = node->next)
|
for(node = heap->available; !(node < bp && bp < node->next); node = node->next)
|
{
|
{
|
if(node >= node->next && (bp > node || bp < node->next))
|
if(node >= node->next && (bp > node || bp < node->next))
|
break; //freed block at start or end of area
|
break; //freed block at start or end of area
|
| Line 909... |
Line 917... |
|
|
|
|
|
|
/***************** Jobs *******************/
|
/***************** Jobs *******************/
|
/******************************************/
|
/******************************************/
|
typedef void (*JobFunc_t)();
|
|
static OS_MQueue_t *jobQueue;
|
static OS_MQueue_t *jobQueue;
|
static OS_Thread_t *jobThread;
|
static OS_Thread_t *jobThread;
|
|
|
//This thread waits for jobs that request a function to be called
|
//This thread waits for jobs that request a function to be called
|
static void JobThread(void *arg)
|
static void JobThread(void *arg)
|
| Line 923... |
Line 930... |
(void)arg;
|
(void)arg;
|
for(;;)
|
for(;;)
|
{
|
{
|
OS_MQueueGet(jobQueue, message, OS_WAIT_FOREVER);
|
OS_MQueueGet(jobQueue, message, OS_WAIT_FOREVER);
|
funcPtr = (JobFunc_t)message[0];
|
funcPtr = (JobFunc_t)message[0];
|
funcPtr(message[1], message[2], message[3]);
|
funcPtr((void*)message[1], (void*)message[2], (void*)message[3]);
|
}
|
}
|
}
|
}
|
|
|
|
|
/******************************************/
|
/******************************************/
|
//Call a function using the job thread so the caller won't be blocked
|
//Call a function using the job thread so the caller won't be blocked
|
void OS_Job(void (*funcPtr)(), void *arg0, void *arg1, void *arg2)
|
void OS_Job(JobFunc_t funcPtr, void *arg0, void *arg1, void *arg2)
|
{
|
{
|
uint32 message[4];
|
uint32 message[4];
|
int rc;
|
int rc;
|
|
|
OS_SemaphorePend(SemaphoreLock, OS_WAIT_FOREVER);
|
OS_SemaphorePend(SemaphoreLock, OS_WAIT_FOREVER);
|
| Line 1418... |
Line 1425... |
#else
|
#else
|
//Support RTOS inside Windows
|
//Support RTOS inside Windows
|
#undef kbhit
|
#undef kbhit
|
#undef getch
|
#undef getch
|
#undef putch
|
#undef putch
|
extern int kbhit();
|
extern int kbhit(void);
|
extern int getch(void);
|
extern int getch(void);
|
extern int putch(int);
|
extern int putch(int);
|
extern void __stdcall Sleep(unsigned long value);
|
extern void __stdcall Sleep(unsigned long value);
|
#endif
|
#endif
|
|
|
