Root/plasma/kernel/rtos_test.c

1/*--------------------------------------------------------------------
2 * TITLE: Test Plasma Real Time Operating System
3 * AUTHOR: Steve Rhoads (rhoadss@yahoo.com)
4 * DATE CREATED: 1/1/06
5 * FILENAME: rtos_test.c
6 * PROJECT: Plasma CPU core
7 * COPYRIGHT: Software placed into the public domain by the author.
8 * Software 'as is' without warranty. Author liable for nothing.
9 * DESCRIPTION:
10 * Test Plasma Real Time Operating System
11 *--------------------------------------------------------------------*/
12#include "plasma.h"
13#include "rtos.h"
14#include "tcpip.h"
15
16/* Including mmu.h will cause all OS calls to use SYSCALL */
17//#include "mmu.h"
18
19//#define DLL_SETUP
20//#define DLL_CALL
21//#include "dll.h"
22
23#define SEMAPHORE_COUNT 50
24#define TIMER_COUNT 10
25
26extern void TestMathFull(void);
27
28typedef struct {
29   OS_Thread_t *MyThread[TIMER_COUNT];
30   OS_Semaphore_t *MySemaphore[SEMAPHORE_COUNT];
31   OS_Mutex_t *MyMutex;
32   OS_Timer_t *MyTimer[TIMER_COUNT];
33   OS_MQueue_t *MyQueue[TIMER_COUNT];
34   int TimerDone;
35} TestInfo_t;
36
37int Global;
38
39//******************************************************************
40static void TestCLib(void)
41{
42   char s1[80], s2[80], *ptr;
43   int rc, v1, v2, v3;
44
45   printf("TestCLib\n");
46   strcpy(s1, "Hello ");
47   memset(s2, 0, sizeof(s2));
48   strncpy(s2, "World wide", 5);
49   strcat(s1, s2);
50   strncat(s1, "!\nthing", 14);
51   printf("%s", s1);
52   rc = strcmp(s1, "Hello World!\n");
53   assert(rc == 0);
54   rc = strcmp(s1, "Hello WOrld!\n");
55   assert(rc > 0);
56   rc = strcmp(s1, "Hello world!\n");
57   assert(rc < 0);
58   rc = strncmp(s1, "Hellx", 4);
59   assert(rc == 0);
60   ptr = strstr(s1, "orl");
61   assert(ptr[0] = 'o');
62   rc = strlen(s1);
63   assert(rc == 13);
64   memcpy(s2, s1, rc+1);
65   rc = memcmp(s1, s2, 8);
66   assert(rc == 0);
67   s2[5] = 'z';
68   rc = memcmp(s1, s2, 8);
69   assert(rc != 0);
70   memset(s2, 0, 5);
71   memset(s2, 'a', 3);
72   rc = abs(-5);
73   itoa(1234, s1, 10);
74   itoa(0, s1, 10);
75   itoa(-1234, s1, 10);
76   itoa(0xabcd, s1, 16);
77   itoa(0x12ab, s1, 16);
78   sprintf(s1, "test c%c d%d 0x%x s%s End\n", 'C', 1234, 0xabcd, "String");
79   printf("%s", s1);
80   sprintf(s1, "test c%c d%6d 0x%6x s%8s End\n", 'C', 1234, 0xabcd, "String");
81   printf("%s", s1);
82   sscanf("1234 -1234 0xabcd text h", "%d %d %x %s", &v1, &v2, &v3, s1);
83   assert(v1 == 1234 && v2 == -1234 && v3 == 0xabcd);
84   assert(strcmp(s1, "text") == 0);
85   //UartScanf("%d %d", &v1, &v2);
86   //printf("v1 = %d v2 = %d\n", v1, v2);
87   printf("Done.\n");
88}
89
90//******************************************************************
91static void TestHeap(void)
92{
93   uint8 *ptrs[256], size[256], *ptr;
94   int i, j, k, value;
95
96   printf("TestHeap\n");
97   memset(ptrs, 0, sizeof(ptrs));
98   for(i = 0; i < 1000; ++i)
99   {
100      j = rand() & 255;
101      if(ptrs[j])
102      {
103         ptr = ptrs[j];
104         value = size[j];
105         for(k = 0; k < value; ++k)
106         {
107            if(ptr[k] != value)
108               printf("Error\n");
109         }
110         OS_HeapFree(ptrs[j]);
111      }
112      size[j] = (uint8)(rand() & 255);
113      ptrs[j] = OS_HeapMalloc(NULL, size[j]);
114      if(ptrs[j] == NULL)
115         printf("malloc NULL\n");
116      else
117         memset(ptrs[j], size[j], size[j]);
118   }
119   for(i = 0; i < 256; ++i)
120   {
121      if(ptrs[i])
122         OS_HeapFree(ptrs[i]);
123   }
124   printf("Done.\n");
125}
126
127//******************************************************************
128static void MyThreadMain(void *arg)
129{
130   OS_Thread_t *thread;
131   int priority;
132
133   thread = OS_ThreadSelf();
134   priority = OS_ThreadPriorityGet(thread);
135   OS_ThreadSleep(10);
136   printf("Arg=%d thread=0x%x info=0x%x priority=%d\n",
137      (uint32)arg, thread, OS_ThreadInfoGet(thread, 0), priority);
138   OS_ThreadExit();
139}
140
141static void TestThread(void)
142{
143   OS_Thread_t *thread;
144   int i, priority;
145
146   printf("TestThread\n");
147   for(i = 0; i < 32; ++i)
148   {
149      priority = 50 + i;
150      thread = OS_ThreadCreate("MyThread", MyThreadMain, (uint32*)i, priority, 0);
151      OS_ThreadInfoSet(thread, 0, (void*)(0xabcd + i));
152      //printf("Created thread 0x%x\n", thread);
153   }
154
155   thread = OS_ThreadSelf();
156   priority = OS_ThreadPriorityGet(thread);
157   printf("Priority = %d\n", priority);
158   OS_ThreadPrioritySet(thread, 200);
159   printf("Priority = %d\n", OS_ThreadPriorityGet(thread));
160   OS_ThreadPrioritySet(thread, priority);
161
162   printf("Thread time = %d\n", OS_ThreadTime());
163   OS_ThreadSleep(100);
164   printf("Thread time = %d\n", OS_ThreadTime());
165}
166
167//******************************************************************
168static void TestSemThread(void *arg)
169{
170   int i;
171   TestInfo_t *info = (TestInfo_t*)arg;
172
173   for(i = 0; i < SEMAPHORE_COUNT/2; ++i)
174   {
175      printf("s");
176      OS_SemaphorePend(info->MySemaphore[i], OS_WAIT_FOREVER);
177      OS_SemaphorePost(info->MySemaphore[i + SEMAPHORE_COUNT/2]);
178   }
179   OS_ThreadExit();
180}
181
182static void TestSemaphore(void)
183{
184   int i, rc;
185   TestInfo_t info;
186   printf("TestSemaphore\n");
187   for(i = 0; i < SEMAPHORE_COUNT; ++i)
188   {
189      info.MySemaphore[i] = OS_SemaphoreCreate("MySem", 0);
190      //printf("sem[%d]=0x%x\n", i, MySemaphore[i]);
191   }
192
193   OS_ThreadCreate("TestSem", TestSemThread, &info, 50, 0);
194
195   for(i = 0; i < SEMAPHORE_COUNT/2; ++i)
196   {
197      printf("S");
198      OS_SemaphorePost(info.MySemaphore[i]);
199      rc = OS_SemaphorePend(info.MySemaphore[i + SEMAPHORE_COUNT/2], 500);
200      assert(rc == 0);
201   }
202
203   printf(":");
204   rc = OS_SemaphorePend(info.MySemaphore[0], 10);
205   assert(rc != 0);
206   printf(":");
207   OS_SemaphorePend(info.MySemaphore[0], 100);
208   printf(":");
209
210   for(i = 0; i < SEMAPHORE_COUNT; ++i)
211      OS_SemaphoreDelete(info.MySemaphore[i]);
212
213   printf("\nDone.\n");
214}
215
216//******************************************************************
217static void TestMutexThread(void *arg)
218{
219   TestInfo_t *info = (TestInfo_t*)arg;
220
221   printf("Waiting for mutex\n");
222   OS_MutexPend(info->MyMutex);
223   printf("Have Mutex1\n");
224   OS_MutexPend(info->MyMutex);
225   printf("Have Mutex2\n");
226   OS_MutexPend(info->MyMutex);
227   printf("Have Mutex3\n");
228
229   OS_ThreadSleep(100);
230
231   OS_MutexPost(info->MyMutex);
232   OS_MutexPost(info->MyMutex);
233   OS_MutexPost(info->MyMutex);
234
235   OS_ThreadExit();
236}
237
238static void TestMutex(void)
239{
240   TestInfo_t info;
241   printf("TestMutex\n");
242   info.MyMutex = OS_MutexCreate("MyMutex");
243   OS_MutexPend(info.MyMutex);
244   OS_MutexPend(info.MyMutex);
245   OS_MutexPend(info.MyMutex);
246
247   OS_ThreadSleep(100);
248
249   OS_ThreadCreate("TestMutex", TestMutexThread, &info, 50, 0);
250
251   OS_ThreadSleep(50);
252   OS_MutexPost(info.MyMutex);
253   OS_MutexPost(info.MyMutex);
254   OS_MutexPost(info.MyMutex);
255
256   printf("Try get mutex\n");
257   OS_MutexPend(info.MyMutex);
258   printf("Gotit\n");
259
260   OS_MutexDelete(info.MyMutex);
261   printf("Done.\n");
262}
263
264//******************************************************************
265static void TestMQueue(void)
266{
267   OS_MQueue_t *mqueue;
268   char data[16];
269   int i, rc;
270
271   printf("TestMQueue\n");
272   mqueue = OS_MQueueCreate("MyMQueue", 10, 16);
273   strcpy(data, "Test0");
274   for(i = 0; i < 16; ++i)
275   {
276      data[4] = (char)('0' + i);
277      OS_MQueueSend(mqueue, data);
278   }
279   for(i = 0; i < 16; ++i)
280   {
281      memset(data, 0, sizeof(data));
282      rc = OS_MQueueGet(mqueue, data, 20);
283      if(rc == 0)
284         printf("message=(%s)\n", data);
285      else
286         printf("timeout\n");
287   }
288
289   OS_MQueueDelete(mqueue);
290   printf("Done.\n");
291}
292
293//******************************************************************
294static void TestTimerThread(void *arg)
295{
296   int index;
297   uint32 data[4];
298   OS_Timer_t *timer;
299   TestInfo_t *info = (TestInfo_t*)arg;
300
301   //printf("TestTimerThread\n");
302
303   OS_ThreadSleep(1);
304   index = (int)OS_ThreadInfoGet(OS_ThreadSelf(), 0);
305   //printf("index=%d\n", index);
306   OS_MQueueGet(info->MyQueue[index], data, 1000);
307   timer = (OS_Timer_t*)data[1];
308   printf("%d ", data[2]);
309   OS_MQueueGet(info->MyQueue[index], data, 1000);
310   printf("%d ", data[2]);
311   ++info->TimerDone;
312   OS_ThreadExit();
313}
314
315static void TestTimer(void)
316{
317   int i;
318   TestInfo_t info;
319
320   printf("TestTimer\n");
321   info.TimerDone = 0;
322   for(i = 0; i < TIMER_COUNT; ++i)
323   {
324      info.MyQueue[i] = OS_MQueueCreate("MyQueue", 10, 16);
325      info.MyTimer[i] = OS_TimerCreate("MyTimer", info.MyQueue[i], i);
326      info.MyThread[i] = OS_ThreadCreate("TimerTest", TestTimerThread, &info, 50, 0);
327      OS_ThreadInfoSet(info.MyThread[i], 0, (void*)i);
328      OS_TimerStart(info.MyTimer[i], 10+i*2, 220+i);
329   }
330
331   while(info.TimerDone < TIMER_COUNT)
332      OS_ThreadSleep(10);
333
334   for(i = 0; i < TIMER_COUNT; ++i)
335   {
336      OS_MQueueDelete(info.MyQueue[i]);
337      OS_TimerDelete(info.MyTimer[i]);
338   }
339
340   printf("Done.\n");
341}
342
343//******************************************************************
344#if 1
345void TestMath(void)
346{
347   int i;
348   float a, b, sum, diff, mult, div;
349   uint32 compare;
350
351   //Check add subtract multiply and divide
352   for(i = -4; i < 4; ++i)
353   {
354      a = (float)(i * 10 + (float)63.2);
355      b = (float)(-i * 5 + (float)3.5);
356      sum = a + b;
357      diff = a - b;
358      mult = a * b;
359      div = a / b;
360      printf("a=%dE-3 b=%dE-3 sum=%dE-3 diff=%dE-3 mult=%dE-3 div=%dE-3\n",
361         (int)(a*(float)1000), (int)(b*(float)1000),
362         (int)(sum*(float)1000), (int)(diff*(float)1000),
363         (int)(mult*(float)1000), (int)(div*(float)1000));
364   }
365
366   //Comparisons
367   b = (float)2.0;
368   compare = 0;
369   for(i = 1; i < 4; ++i)
370   {
371      a = (float)i;
372      compare = (compare << 1) | (a == b);
373      compare = (compare << 1) | (a != b);
374      compare = (compare << 1) | (a < b);
375      compare = (compare << 1) | (a <= b);
376      compare = (compare << 1) | (a > b);
377      compare = (compare << 1) | (a >= b);
378   }
379   printf("Compare = %8x %s\n", compare,
380      compare==0x1c953 ? "OK" : "ERROR");
381
382   //Cosine
383   for(a = (float)0.0; a <= (float)(3.1415); a += (float)(3.1415/16.0))
384   {
385      b = FP_Cos(a);
386      printf("cos(%4dE-3) = %4dE-3\n",
387         (int)(a*(float)1000.0), (int)(b*(float)1000.0));
388   }
389}
390#endif
391
392//******************************************************************
393#ifndef WIN32
394static void MySyscall(void *arg)
395{
396   uint32 *stack = arg;
397   stack[STACK_EPC] += 4; //skip over SYSCALL
398   printf("Inside MySyscall %d\n", stack[28/4]);
399}
400
401void TestSyscall(void)
402{
403   OS_InterruptRegister((uint32)(1<<31), MySyscall);
404   OS_Syscall(57);
405   OS_ThreadSleep(1);
406   printf("Done\n");
407}
408#endif
409
410#ifdef __MMU_ENUM_H__
411void TestProcess(void)
412{
413   OS_Process_t *process;
414   process = (OS_Process_t*)OS_HeapMalloc(NULL, sizeof(OS_Process_t));
415   process->name = "test";
416   process->funcPtr = MainThread;
417   process->arg = NULL;
418   process->priority = 200;
419   process->stackSize = 1024*32;
420   process->heapSize = 1024*128;
421   process->processId = 1;
422   process->semaphoreDone = OS_SemaphoreCreate("processDone", 0);
423   printf("Creating process\n");
424   OS_MMUProcessCreate(process);
425   OS_SemaphorePend(process->semaphoreDone, OS_WAIT_FOREVER);
426   printf("Process done\n");
427   OS_MMUProcessDelete(process);
428}
429#endif
430
431
432//******************************************************************
433void MMUTest(void);
434void HtmlThread(void *arg);
435void ConsoleInit(void);
436void exit(int);
437uint8 macAddress[] = {0x00, 0x10, 0xdd, 0xce, 0x15, 0xd4};
438
439
440void MainThread(void *Arg)
441{
442   int ch, i, display=1;
443   (void)Arg;
444#ifdef __MMU_ENUM_H__
445   OS_MMUInit();
446#endif
447
448#ifdef INCLUDE_ETH
449   EthernetInit(macAddress);
450   IPInit(EthernetTransmit, macAddress, "plasma");
451   HtmlInit(1);
452#endif
453
454#ifdef INCLUDE_HTML
455   IPInit(NULL, macAddress, "plasma");
456   HtmlInit(1);
457#endif
458
459#ifdef INCLUDE_CONSOLE
460   ConsoleInit();
461#endif
462
463   for(;;)
464   {
465      if(display)
466      {
467         printf("\n");
468         printf("1 CLib\n");
469         printf("2 Heap\n");
470         printf("3 Thread\n");
471         printf("4 Semaphore\n");
472         printf("5 Mutex\n");
473         printf("6 MQueue\n");
474         printf("7 Timer\n");
475         printf("8 Math\n");
476         printf("9 Syscall\n");
477#ifdef __MMU_ENUM_H__
478         printf("p MMU Process\n");
479#endif
480      }
481      printf("> ");
482      display = 1;
483      ch = UartRead();
484      printf("%c\n", ch);
485      switch(ch)
486      {
487#ifdef WIN32
488      case '0': exit(0);
489#endif
490      case '1': TestCLib(); break;
491      case '2': TestHeap(); break;
492      case '3': TestThread(); break;
493      case '4': TestSemaphore(); break;
494      case '5': TestMutex(); break;
495      case '6': TestMQueue(); break;
496      case '7': TestTimer(); break;
497      case '8': TestMath(); break;
498#ifndef WIN32
499      case '9': TestSyscall(); break;
500#endif
501#ifdef __MMU_ENUM_H__
502      case 'p': TestProcess(); break;
503#endif
504#ifdef WIN32
505      case 'm': TestMathFull(); break;
506#endif
507      case 'g': printf("Global=%d\n", ++Global); break;
508      default:
509         printf("E");
510         display = 0;
511         for(i = 0; i < 30; ++i)
512         {
513            while(kbhit())
514               ch = UartRead();
515            OS_ThreadSleep(1);
516         }
517         break;
518      }
519   }
520}
521
522
523

Archive Download this file

Branches:
master



interactive