home *** CD-ROM | disk | FTP | other *** search
/ Resource for Source: C/C++ / Resource for Source - C-C++.iso / codelib9 / v_11_03 / 1103042c < prev    next >
Encoding:
Text File  |  1995-11-01  |  5.2 KB  |  213 lines
  1. /****************************************************/
  2. /*                                                  */
  3. /*      DEMO.C - demo code for SSX                  */
  4. /*      (stack swap executive)                      */
  5. /*                                                  */
  6. /*      By Tom Green and Dennis Cronin              */
  7. /*      10/19/92                                    */
  8. /*                                                  */
  9. /****************************************************/
  10.  
  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #include <dos.h>
  14. #include <bios.h>
  15. #include <conio.h>
  16. #include "ssx.h"
  17.  
  18. /* vector for PC timer interrupt */
  19. #define TIMER_INT_VEC           8
  20. /* 18.2 clock ticks per second on PC */
  21. #define TICKS_PER_SECOND        18L
  22.  
  23. #define NUM_PQ_TASKS            5
  24. #define NUM_TS_TASKS            5
  25.  
  26. void key_task(void);
  27. void print_ts_count_task(void);
  28. void sys_time_task(void);
  29. void ts_task(void);
  30. void print_q_task(void);
  31. void interrupt tick_handler(void);
  32.  
  33. unsigned int pq_task_counter=0;
  34. unsigned int ts_task_counter=0;
  35. wait_q print_q;
  36. void interrupt (*old_timer_int)(void);
  37. unsigned long pq_count[NUM_PQ_TASKS];
  38. unsigned long ts_count[NUM_TS_TASKS];
  39.  
  40. void main(void)
  41. {
  42.     unsigned int i;
  43.  
  44.     clrscr();
  45.  
  46.     pq_task_counter=0;
  47.     ts_task_counter=0;
  48.  
  49.     if((ssx_init()) == INIT_ERROR){
  50.         printf("\nError initting SSX");
  51.         exit(1);
  52.     }
  53.  
  54.     /* set up timer tick interrupt handler */
  55.     old_timer_int = getvect(TIMER_INT_VEC);
  56.     setvect(TIMER_INT_VEC,tick_handler);
  57.  
  58.     /* install print q tasks */
  59.     for(i = 1;i <= NUM_PQ_TASKS;i++){
  60.         if((ssx_task_create(1,i,print_q_task,0x200,
  61.                             "task"))!=SUCCESS)
  62.             cprintf("\nError creating task %d",i);
  63.     }
  64.     /* install time slice tasks */
  65.     for(i = NUM_PQ_TASKS + 1;i <= (NUM_TS_TASKS +
  66.                                NUM_PQ_TASKS);i++){
  67.         if((ssx_task_create(1,i,ts_task,0x200,
  68.             "ts_task"))!=SUCCESS)
  69.             cprintf("\nError creating ts task");
  70.     }
  71.     /* install print ts count task */
  72.     if((ssx_task_create(1,22,print_ts_count_task,0x200,
  73.         "pts_task"))!=SUCCESS)
  74.         cprintf("\nError creating ts count task");
  75.     /* install keypress task */
  76.     if((ssx_task_create(1,21,key_task,0x200,
  77.         "key_task"))!=SUCCESS)
  78.         cprintf("\nError creating keypress task");
  79.     /* install system time task */
  80.     if((ssx_task_create(1,23,sys_time_task,0x200,
  81.         "st_task"))!=SUCCESS)
  82.         cprintf("\nError creating system time task");
  83.     cprintf("\r\nDone creating tasks");
  84.     cprintf("\r\nPress key to start SSX");
  85.     bioskey(0);
  86.     clrscr();
  87.     SET_SEMAPHORE(&print_q);
  88.     ssx_run();
  89.  
  90.     /* reset to old timer int handler */
  91.     setvect(TIMER_INT_VEC,old_timer_int);
  92.  
  93.     clrscr();
  94. }
  95.  
  96.  
  97. /*
  98.  * ts_task - time slice task. this task gets a full
  99.  *           time slice to increment counter.
  100.  *           print_ts_count_task prints counters.
  101.  */
  102.  
  103. void ts_task(void)
  104. {
  105.     int task_num;
  106.     
  107.     task_num = ts_task_counter++;
  108.     ts_count[task_num] = 0L;
  109.  
  110.     while(1){
  111.         ts_count[task_num]++;
  112.     }
  113. }
  114.  
  115. /*
  116.  * print_q_task - this task waits for print q we have
  117.  *                set up and then increments counter
  118.  *                and prints and then releases print q
  119.  */
  120.  
  121. void print_q_task(void)
  122. {
  123.     unsigned int y,task_num;
  124.  
  125.     task_num = pq_task_counter++;
  126.     y = task_num + 1;
  127.     pq_count[task_num] = 0L;
  128.  
  129.     while(1){
  130.         ssx_wait(&print_q);
  131.         pq_count[task_num]++;
  132.         gotoxy(1,y);
  133.         cprintf("Task    %02d %08lx",task_num,
  134.                 pq_count[task_num]);
  135.         ssx_alert(&print_q);
  136.     }
  137. }
  138.  
  139. /*
  140.  * print_ts_count_task - task that prints counts
  141.  *                       from time sliced tasks
  142.  *                       once every 3 seconds
  143.  */
  144.  
  145. void print_ts_count_task(void)
  146. {
  147.     int task_num;
  148.  
  149.     while(1){
  150.         ssx_wait(&print_q);
  151.         for(task_num = 0;task_num < NUM_TS_TASKS;
  152.             task_num++){
  153.             gotoxy(1,task_num + NUM_TS_TASKS + 1);
  154.             cprintf("TS Task %02d %08lx",task_num,
  155.                     ts_count[task_num]);
  156.         }
  157.         ssx_alert(&print_q);
  158.         ssx_task_delay(3 * TICKS_PER_SECOND);
  159.     }
  160. }
  161.  
  162. /*
  163.  * key_task - task that checks for keypress every
  164.  *            2 seconds. calls ssx_stop when key
  165.  *            is pressed
  166.  */
  167.  
  168. void key_task(void)
  169. {
  170.     while(1){
  171.         if((bioskey(1)) != 0){
  172.             bioskey(0);
  173.             ssx_stop();
  174.         }
  175.         ssx_task_delay(2 * TICKS_PER_SECOND);
  176.     }
  177. }
  178.  
  179.  
  180. /*
  181.  * sys_time_task - prints how long it has been
  182.  *                 running once every minute
  183.  */
  184.  
  185. void sys_time_task(void)
  186. {
  187.     int task_num;
  188.  
  189.     while(1){
  190.         ssx_wait(&print_q);
  191.         gotoxy(1,15);
  192.         cprintf("Sytem time = %08lx seconds",
  193.             ssx_get_time() / TICKS_PER_SECOND);
  194.         ssx_alert(&print_q);
  195.         ssx_task_delay(1 * TICKS_PER_SECOND);
  196.     }
  197. }
  198.  
  199.  
  200.  
  201. /*
  202.  * tick_handler - handles 18.2 per second timer
  203.  *                interrupts on PC
  204.  */
  205.  
  206. void interrupt tick_handler(void)
  207. {
  208.     /* call original PC timer handler */
  209.     (*old_timer_int)();
  210.     /* inform SSX of clock tick */
  211.     ssx_clock_tick();
  212. }
  213.