home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / listings / v_09_01 / 9n01114a < prev    next >
Text File  |  1990-11-29  |  37KB  |  1,472 lines
  1. /*0*********************************************************
  2. *   Richard Carver                            July 1990
  3. * 
  4. *   This program demonstrates interprocess communication
  5. *   between several tasks using the iRMX II Operating
  6. *   System.
  7. *
  8. *   Two tasks are used for resource control.  The
  9. *   clock_task() controls use of the hardware clock and the
  10. *   crt_task() controls use of the display screen.
  11. *
  12. *   The count_task() competes with the clock_task() for
  13. *   use of the crt_task() services.  The timer_task() uses
  14. *   the services of the clock_task() for a software timer.
  15. *
  16. *   The initial task, main(), starts every thing up and,
  17. *   when the timer_task() finishes, shuts everything down.
  18. ***********************************************************/
  19.  
  20. #include <stdio.h>
  21. #include <stdlib.h>
  22. #include <string.h>
  23. #include <rmxc.h>         /* iRMX OS calls & structures   */
  24. #include <rmxerr.h>       /* iRMX status codes (defines)  */
  25. #include <delay.h>        /* Hardcoded delay loop macros  */
  26.  
  27. #define ERROR   (0xFFFF)    /* Error Condition  */
  28.  
  29. #define FALSE   (0)
  30. #define TRUE    (!FALSE)
  31.  
  32. #define MAX_CLOCK_RETRIES   (4)
  33.  
  34. /* The NULL token (similar to NULL pointer) */
  35.  
  36. #define NUL_TKN   ((selector)0)
  37.  
  38. /* Options for rqgettasktokens()  */
  39.  
  40. #define THIS_TASK (0x00)
  41. #define THIS_JOB  (0x01)
  42. #define PARAM_OBJ (0x02)
  43. #define ROOT_JOB  (0x03)
  44.  
  45. /* Options for rqcreatemailbox()  */
  46.  
  47. #define FIFO_OBJ_MBX      (0x0000)
  48. #define PRIORITY_OBJ_MBX  (0x0001)
  49. #define FIFO_DATA_MBX     (0x0020)
  50. #define PRIORITY_DATA_MBX (0x0021)
  51.  
  52. /* Options for rqcreatesemaphore()  */
  53.  
  54. #define FIFO_SEM      (0x0000)
  55. #define PRIORITY_SEM  (0x0001)
  56.  
  57. #define SEM_INIT_0    (0)
  58. #define SEM_MAX_1     (1)
  59.  
  60. /* Common wait times for iRMX System Calls  */
  61.  
  62. #define NO_WAIT       (0x0000)
  63. #define WAIT_FOREVER  (0xFFFF)
  64.  
  65. /* Options for rqcreatetask() */
  66.  
  67. #define NO_FLOAT    (0x0000)
  68. #define DEFAULT_STACK_SIZE    ((unsigned int)2048)
  69.  
  70. /* Task Priorities  */
  71.  
  72. #define CLOCK_TASK_PRIORITY   ((unsigned char)48)
  73. #define TIMER_TASK_PRIORITY       ((unsigned char)150)
  74. #define CRT_TASK_PRIORITY     ((unsigned char)200)
  75. #define COUNT_TASK_PRIORITY   ((unsigned char)200)
  76.  
  77. /* Defines For Hardware Clock */
  78. /* Clock Interrupt Level */
  79.  
  80. #define CLOCK_INT_LEVEL (0x26)
  81.  
  82. /* Clock Ports */
  83.  
  84. #define ADR_PORT  ((unsigned short)0xA060)
  85. #define DAT_PORT  ((unsigned short)0xA062)
  86. #define CNT_PORT  ((unsigned short)0xA064)
  87. #define PIO_PORT  ((unsigned short)0xA066)
  88.  
  89. /* Clock Port I/O Operations */
  90.  
  91. #define PIO_READ  ((unsigned char)0x82)
  92. #define PIO_WRITE ((unsigned char)0x80)
  93.  
  94. /* Clock Registers */
  95.  
  96. #define SEC01_REG (0x00)
  97. #define SEC10_REG (0x01)
  98. #define MIN01_REG (0x02)
  99. #define MIN10_REG (0x03)
  100. #define HRS01_REG (0x04)
  101. #define HRS10_REG (0x05)
  102. #define DAT01_REG (0x07)
  103. #define DAT10_REG (0x08)
  104. #define MON01_REG (0x09)
  105. #define MON10_REG (0x0A)
  106. #define YRS01_REG (0x0B)
  107. #define YRS10_REG (0x0C)
  108.  
  109. /* Clock Control Lines */
  110.  
  111. #define CNT_RST     ((unsigned char)0x00)
  112. #define INT_ENB     ((unsigned char)0x20)
  113. #define HOLD_HIGH   ((unsigned char)0x10)
  114. #define HOLD_READ   ((unsigned char)0x30)
  115. #define HOLD_WRITE  ((unsigned char)0x50)
  116.  
  117. /* Defines for months */
  118.  
  119. #define JANUARY     (1)
  120. #define FEBRUARY    (2)
  121. #define MARCH       (3)
  122. #define DECEMBER    (12)
  123.  
  124. /* Time/Date and Timers Data Structure  */
  125.  
  126. #define MAX_TIMERS    (10)
  127.  
  128. struct SYS_TIME_STR
  129.   {
  130.   unsigned char change_flg;
  131.   unsigned char second;
  132.   unsigned char minute;
  133.   unsigned char hour;
  134.   unsigned char date;
  135.   unsigned char month;
  136.   unsigned char year;
  137.  
  138.   struct TIMER_STR
  139.     {
  140.     unsigned char in_use;
  141.     unsigned int  count;
  142.     unsigned int  timeout;
  143.     selector    sem_tkn;
  144.     }timer[MAX_TIMERS];
  145.   };
  146.  
  147. /* Request Message format for the Display Task  */
  148.  
  149. struct CRT_REQ_STR
  150.   {
  151.   unsigned char *msg_ptr;
  152.   unsigned int  row;
  153.   unsigned int  col;
  154.   };
  155.  
  156. /* Object Catalog Names */
  157.  
  158. const unsigned char
  159.   clock_sem_name[] = "\011CLOCK_SEM",
  160.   init_sem_name[] = "\010INIT_SEM";
  161.  
  162. const unsigned char
  163.   time_seg_name[] = "\010TIME_SEG";
  164.  
  165. const unsigned char
  166.   crt_req_mbx_name[] = "\007CRT_MBX";
  167.  
  168. const unsigned char
  169.   crt_shtdwn_sem_name[] = "\012CRT_SHTDWN",
  170.   clock_shtdwn_sem_name[] = "\014CLOCK_SHTDWN",
  171.   count_shtdwn_sem_name[] = "\014COUNT_SHTDWN";
  172.  
  173. /* Days Per Month */
  174.  
  175. const unsigned char
  176.   days_in_month[12] =
  177.   {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  178.  
  179. /* Global System Time/Date Structure */
  180.  
  181. selector  sys_time_seg;
  182. struct SYS_TIME_STR *sys_time;
  183.  
  184. /* Task declarations  */
  185.  
  186. void clock_task(void);
  187. void crt_task(void);
  188. void timer_task(void);
  189. void count_task(void);
  190.  
  191. /* Task objects (global for debugging purposes) */
  192.  
  193. selector    clock_tsk;
  194. selector    crt_tsk;
  195. selector    timer_tsk;
  196. selector    count_tsk;
  197.  
  198. /*1*********************************************************
  199. * Task:     main()  (the initial task)
  200. *
  201. * Summary:  Starts it all up and shuts it all down.
  202. *
  203. * Caveats:  None
  204. ***********************************************************/
  205.  
  206. void main(void)
  207.   {
  208.   selector  current_job;      /* current job            */
  209.   selector  init_sem;         /* initilaization sem     */
  210.   selector  clock_sem;        /* time/date shared memory*/
  211.   selector  clock_shtdwn_sem; /* clock_task() shutdown  */
  212.   selector  count_shtdwn_sem; /* count_task() shutdown  */
  213.   selector  crt_shtdwn_sem;   /* crt_task() shutdown    */
  214.   selector  sys_time_seg;     /* time/date data segment */
  215.  
  216.   unsigned int    status;     /* iRMX condition code    */
  217.  
  218.   struct EXCEPTIONSTRUCT  exceptioninfo;
  219.  
  220.  
  221. /*  Disable current task's exception handler  */
  222.  
  223.   rqgetexceptionhandler(&exceptioninfo, &status);
  224.   exceptioninfo.exceptionmode = 0;
  225.   rqsetexceptionhandler(&exceptioninfo, &status);
  226.  
  227. /*  Get Token For Current Job */
  228.  
  229.   current_job = rqgettasktokens(THIS_JOB, &status);
  230.  
  231. /*  Create and catalog the semaphore used for */
  232. /*  accessing the shared clock data.          */
  233.  
  234.   clock_sem = rqcreatesemaphore(SEM_INIT_0,
  235.     SEM_MAX_1, PRIORITY_SEM, &status);
  236.   rqcatalogobject(current_job,
  237.     clock_sem, &clock_sem_name, &status);
  238.  
  239. /*  Create and catalog the semaphore used for */
  240. /*  synchronizing tasks during initialization */
  241. /*  and shutdown.                             */
  242.  
  243.   init_sem = rqcreatesemaphore(SEM_INIT_0,
  244.     99, FIFO_SEM, &status);
  245.   rqcatalogobject(current_job,
  246.     init_sem, &init_sem_name, &status);
  247.  
  248. /*  Create and catalog the segment of memory  */
  249. /*  used to hold the shared time/date data.   */
  250.  
  251.   sys_time_seg = rqcreatesegment(
  252.     sizeof(struct SYS_TIME_STR), &status);
  253.   rqcatalogobject(current_job,
  254.     sys_time_seg, &time_seg_name, &status);
  255.  
  256. /*  Create and catalog the semaphores used to */
  257. /*  signal task shutdown.                     */
  258.  
  259.   clock_shtdwn_sem = rqcreatesemaphore(SEM_INIT_0,
  260.     SEM_MAX_1, FIFO_SEM, &status);
  261.   rqcatalogobject(current_job,
  262.     clock_shtdwn_sem, &clock_shtdwn_sem_name, &status);
  263.  
  264.   crt_shtdwn_sem = rqcreatesemaphore(SEM_INIT_0,
  265.     SEM_MAX_1, FIFO_SEM, &status);
  266.   rqcatalogobject(current_job,
  267.     crt_shtdwn_sem, &crt_shtdwn_sem_name, &status);
  268.  
  269.   count_shtdwn_sem = rqcreatesemaphore(SEM_INIT_0,
  270.     SEM_MAX_1, FIFO_SEM, &status);
  271.   rqcatalogobject(current_job,
  272.     count_shtdwn_sem, &count_shtdwn_sem_name, &status);
  273.  
  274. /*  Create the crt_task().  Wait for the task to  */
  275. /*  indicate it has completed initialization.     */
  276.  
  277.   crt_tsk = rqcreatetask(CRT_TASK_PRIORITY, &crt_task,
  278.     NUL_TKN, NULL, DEFAULT_STACK_SIZE, NO_FLOAT, &status);
  279.  
  280.   rqreceiveunits(init_sem, 1, WAIT_FOREVER, &status);
  281.  
  282. /*  Create the clock_task().  Wait for the task   */
  283. /*  to indicate it has completed initialization.  */
  284.  
  285.   clock_tsk = rqcreatetask(CLOCK_TASK_PRIORITY, &clock_task,
  286.     NUL_TKN, NULL, DEFAULT_STACK_SIZE, NO_FLOAT, &status);
  287.  
  288.   rqreceiveunits(init_sem, 1, WAIT_FOREVER, &status);
  289.  
  290. /*  Create the count_task().  Wait for the task   */
  291. /*  to indicate it has completed initialization.  */
  292.  
  293.   count_tsk = rqcreatetask(COUNT_TASK_PRIORITY, &count_task,
  294.     NUL_TKN, NULL, DEFAULT_STACK_SIZE, NO_FLOAT, &status);
  295.  
  296.   rqreceiveunits(init_sem, 1, WAIT_FOREVER, &status);
  297.  
  298. /*  Create the timer_task().  Wait for the task   */
  299. /*  to indicate it has completed initialization.  */
  300. /*  This also signals the shutdown process.       */
  301.  
  302.   timer_tsk = rqcreatetask(TIMER_TASK_PRIORITY, &timer_task,
  303.     NUL_TKN, NULL, DEFAULT_STACK_SIZE, NO_FLOAT, &status);
  304.  
  305.   rqreceiveunits(init_sem, 1, WAIT_FOREVER, &status);
  306.  
  307. /*  Begin shutdown by first disabling any further   */
  308. /*  interrupts from the hardware clock.  This task  */
  309. /*  suspends itself for 2/100th of a second to      */
  310. /*  ensure interrupt is disabled.                   */
  311.  
  312.   rqdisable(CLOCK_INT_LEVEL, &status);
  313.   rqsleep(2, &status);
  314.  
  315. /*  Send shutdown signals to all tasks and wait */
  316. /*  for all tasks to complete shutdown.         */
  317.  
  318.   rqsendunits(count_shtdwn_sem, 1, &status);
  319.   rqsendunits(crt_shtdwn_sem, 1, &status);
  320.   rqsendunits(clock_shtdwn_sem, 1, &status);
  321.  
  322.   rqreceiveunits(init_sem, 3, WAIT_FOREVER, &status);
  323.  
  324. /*  Cleanup before terminating.  This includes  */
  325. /*  deleting tasks and uncataloging/deleteing   */
  326. /*  all objects created.                        */
  327.  
  328.   rqdeletetask(crt_tsk, &status);
  329.   rqdeletetask(clock_tsk, &status);
  330.   rqdeletetask(count_tsk, &status);
  331.   rqdeletetask(timer_tsk, &status);
  332.  
  333.   rquncatalogobject(current_job,
  334.     &clock_sem_name, &status);
  335.   rquncatalogobject(current_job,
  336.     &init_sem_name, &status);
  337.   rquncatalogobject(current_job,
  338.     &time_seg_name, &status);
  339.   rquncatalogobject(current_job,
  340.     &crt_req_mbx_name, &status);
  341.  
  342.   rquncatalogobject(current_job,
  343.     &clock_shtdwn_sem_name, &status);
  344.   rquncatalogobject(current_job,
  345.     &count_shtdwn_sem_name, &status);
  346.   rquncatalogobject(current_job,
  347.     &crt_shtdwn_sem_name, &status);
  348.  
  349.   rqdeletesemaphore(clock_sem, &status);
  350.   rqdeletesemaphore(init_sem, &status);
  351.  
  352.   rqdeletesemaphore(clock_shtdwn_sem, &status);
  353.   rqdeletesemaphore(count_shtdwn_sem, &status);
  354.   rqdeletesemaphore(crt_shtdwn_sem, &status);
  355.  
  356.   rqdeletesegment(sys_time_seg, &status);
  357.  
  358.   cursor_on();
  359.   printf("\nAll Done!\n");
  360.  
  361.   exit(0);
  362.   }
  363.  
  364. /*1*********************************************************
  365. * Function: start_timer
  366. *
  367. * Summary:  Create and start a timer.
  368. *
  369. * Invocation: timer_sem = start_timer(timeout);
  370. *
  371. * Inputs:   timeout (unsigned int) - timer interval
  372. *             in seconds
  373. *
  374. * Outputs:  timer_sem (selector) - the semaphore that will
  375. *             receive a unit at each timer interval
  376. *
  377. * Caveats:  Accesses the time/date data segment that is
  378. *           shared with the clock_task().
  379. ***********************************************************/
  380.  
  381. selector start_timer(unsigned int timeout)
  382.   {
  383.   unsigned int    status;
  384.   unsigned int    indx;
  385.   unsigned int    done;
  386.   unsigned int    no_more_timers;
  387.  
  388.   selector    timer_sem;
  389.   selector    current_job;
  390.   selector    clock_sem;
  391.   selector    sys_time_seg;
  392.  
  393.   struct SYS_TIME_STR   *sys_time;
  394.  
  395.   indx = 0;
  396.   done = FALSE;
  397.   no_more_timers = TRUE;
  398.   timer_sem = NUL_TKN;
  399.  
  400. /*  Get objects for access semaphore and  */
  401. /*  time/date data segment                */
  402.  
  403.   current_job = rqgettasktokens(THIS_JOB, &status);
  404.  
  405.   clock_sem = rqlookupobject(current_job,
  406.     &clock_sem_name, NO_WAIT, &status);
  407.   sys_time_seg = rqlookupobject(current_job,
  408.     &time_seg_name, NO_WAIT, &status);
  409.  
  410.   sys_time = buildptr(sys_time_seg, 0);
  411.  
  412. /* Access time/date memory  */
  413.  
  414.   rqreceiveunits(clock_sem, 1, WAIT_FOREVER, &status);
  415.  
  416. /*  Find an empty timer slot  */
  417.  
  418.   while (!done)
  419.     {
  420.     if (!sys_time->timer[indx].in_use)
  421.       {
  422.       done = TRUE;
  423.       no_more_timers = FALSE;
  424.       }
  425.     else
  426.       {
  427.       indx++;
  428.  
  429.       if (indx == MAX_TIMERS)
  430.         {
  431.         done = TRUE;
  432.         }
  433.       }
  434.     }
  435.  
  436. /* Establish a timer */
  437.  
  438.   if (no_more_timers == FALSE)
  439.     {
  440.     if (timeout != 0)
  441.       {
  442.       timer_sem = rqcreatesemaphore(SEM_INIT_0,
  443.         999, FIFO_SEM, &status);
  444.       sys_time->timer[indx].in_use = TRUE;
  445.       sys_time->timer[indx].count = 0;
  446.       sys_time->timer[indx].timeout = timeout;
  447.       sys_time->timer[indx].sem_tkn = timer_sem;
  448.       }
  449.     }
  450.  
  451. /*  Release time/date memory */
  452.  
  453.   rqsendunits(clock_sem, 1, &status);
  454.  
  455. /*  Return timer semaphore to caller  */
  456.  
  457.   return(timer_sem);
  458.   }
  459.  
  460. /*1*********************************************************
  461. * Function: stop_timer
  462. *
  463. * Summary:  Delete a timer.
  464. *
  465. * Invocation: timer_sem = start_timer(timeout);
  466. *
  467. * Inputs:   timeout (unsigned int) - timer interval
  468. *             in seconds
  469. *
  470. * Outputs:  timer_sem (selector) - the semaphore that will
  471. *             receive a unit at each timer interval
  472. *
  473. * Caveats:  Accesses the time/date data segment that is
  474. *           shared with the clock_task().
  475. ***********************************************************/
  476.  
  477. unsigned int stop_timer(selector timer_sem)
  478.   {
  479.   unsigned int    status;
  480.   unsigned int    indx;
  481.   unsigned int    done;
  482.   unsigned int    invalid_timer;
  483.  
  484.   selector    current_job;
  485.   selector    clock_sem;
  486.   selector    sys_time_seg;
  487.  
  488.   struct SYS_TIME_STR   *sys_time;
  489.  
  490.  
  491.   indx = 0;
  492.   done = FALSE;
  493.   invalid_timer = TRUE;
  494.  
  495. /*  Get objects for access semaphore and  */
  496. /*  time/date data segment                */
  497.  
  498.   current_job = rqgettasktokens(THIS_JOB, &status);
  499.  
  500.   clock_sem = rqlookupobject(current_job,
  501.     &clock_sem_name, NO_WAIT, &status);
  502.   sys_time_seg = rqlookupobject(current_job,
  503.     &time_seg_name, NO_WAIT, &status);
  504.  
  505.   sys_time = buildptr(sys_time_seg, 0);
  506.  
  507. /*  Access time/date memory.  */
  508.  
  509.   rqreceiveunits(clock_sem, 1, WAIT_FOREVER, &status);
  510.  
  511. /*  Locate and remove this timer  */
  512.  
  513.   while (!done)
  514.     {
  515.     if (sys_time->timer[indx].in_use &&
  516.       (sys_time->timer[indx].sem_tkn == timer_sem))
  517.       {
  518.       rqdeletesemaphore(timer_sem, &status);
  519.       sys_time->timer[indx].in_use = FALSE;
  520.       sys_time->timer[indx].sem_tkn = NUL_TKN;
  521.       sys_time->timer[indx].count = 0;
  522.       sys_time->timer[indx].timeout = 0;
  523.       done = TRUE;
  524.       invalid_timer = FALSE;
  525.       }
  526.     else
  527.       {
  528.       indx++;
  529.  
  530.       if (indx == MAX_TIMERS)
  531.         {
  532.         done = TRUE;
  533.         }
  534.       }
  535.     }
  536.  
  537. /*  Release time/date memory  */
  538.  
  539.   rqsendunits(clock_sem, 1, &status);
  540.  
  541. /*  Return with result of call  */
  542.  
  543.   return (invalid_timer ? ERROR : EOK);
  544.   }
  545.  
  546.  
  547. /*1*********************************************************
  548. * Task:     count_task
  549. *
  550. * Summary:  Continuously counts and displays a value from
  551. *           0-65535.
  552. *
  553. * Caveats:  Communicates with the crt_task() for displaying
  554. *           counter values.
  555. ***********************************************************/
  556.  
  557. void count_task(void)
  558.   {
  559.   unsigned char counter_buf[6];
  560.  
  561.   selector  current_job;
  562.   selector  rsp_mbx;
  563.   selector  crt_req_mbx;
  564.   selector  init_sem;
  565.   selector  count_shtdwn_sem;
  566.   selector  req_seg;
  567.  
  568.   unsigned int  counter;
  569.   unsigned int    status;
  570.  
  571.   struct CRT_REQ_STR    *req_msg;
  572.  
  573.   struct EXCEPTIONSTRUCT    exceptioninfo;
  574.  
  575. /*  Disable this task's exception handler */
  576.  
  577.   rqgetexceptionhandler(&exceptioninfo, &status);
  578.   exceptioninfo.exceptionmode = 0;
  579.   rqsetexceptionhandler(&exceptioninfo, &status);
  580.  
  581. /*  Lookup/Create needed objects */
  582.  
  583.   current_job = rqgettasktokens(THIS_JOB, &status);
  584.  
  585.   init_sem = rqlookupobject(current_job,
  586.     &init_sem_name, NO_WAIT, &status);
  587.  
  588.   count_shtdwn_sem = rqlookupobject(current_job,
  589.     &count_shtdwn_sem_name, NO_WAIT, &status);
  590.  
  591.   rsp_mbx = rqcreatemailbox(FIFO_OBJ_MBX, &status);
  592.  
  593.   crt_req_mbx = rqlookupobject(current_job,
  594.     &crt_req_mbx_name, NO_WAIT, &status);
  595.  
  596. /*  Initialize request message */
  597.  
  598.   req_seg = rqcreatesegment(
  599.     sizeof(struct CRT_REQ_STR), &status);
  600.  
  601.   req_msg = buildptr(req_seg, 0);
  602.  
  603.   req_msg->msg_ptr = counter_buf;
  604.   req_msg->row = 12;
  605.   req_msg->col = 38;
  606.  
  607. /*  Singal that initialization is completed.  */
  608.  
  609.   rqsendunits(init_sem, 1, &status);
  610.  
  611. /*  Continuously count 0-65535 and display the  */
  612. /*  value until signalled to stop.              */
  613.  
  614.   counter = 0;
  615.  
  616.   rqreceiveunits(count_shtdwn_sem, 1, NO_WAIT, &status);
  617.  
  618.   while (status == ETIME)   /* while no signal received */
  619.     {
  620.     sprintf(counter_buf, "%d", counter);
  621.     rqsendmessage(crt_req_mbx,
  622.       req_seg, rsp_mbx, &status);
  623.     req_seg = rqreceivemessage(rsp_mbx,
  624.       WAIT_FOREVER, NUL_TKN, &status);
  625.     counter++;
  626.     rqreceiveunits(count_shtdwn_sem, 1, NO_WAIT, &status);
  627.     }
  628.  
  629. /*  Cleanup objects created by this task. */
  630.  
  631.   rqdeletemailbox(rsp_mbx, &status);
  632.   rqdeletesegment(req_seg, &status);
  633.  
  634. /*  Signal shutdown complete and suspend execution. */
  635.  
  636.   rqsendunits(init_sem, 1, &status);
  637.  
  638.   rqsuspendtask(NUL_TKN, &status);  /* suspend this task  */
  639.   }
  640.  
  641. /*1*********************************************************
  642. * Task:     timer_task
  643. *
  644. * Summary:  
  645. *
  646. * Caveats:  
  647. ***********************************************************/
  648.  
  649. void timer_task(void)
  650.   {
  651.   selector    current_job;
  652.   selector    init_sem;
  653.   selector    clock_sem;
  654.   selector    timer_sem;
  655.  
  656.   unsigned int    status;
  657.  
  658.   struct EXCEPTIONSTRUCT    exceptioninfo;
  659.  
  660. /*  Disable this task's exception handler */
  661.  
  662.   rqgetexceptionhandler(&exceptioninfo, &status);
  663.   exceptioninfo.exceptionmode = 0;
  664.   rqsetexceptionhandler(&exceptioninfo, &status);
  665.  
  666. /*  Lookup needed objects */
  667.  
  668.   current_job = rqgettasktokens(THIS_JOB, &status);
  669.  
  670.   init_sem = rqlookupobject(current_job,
  671.     &init_sem_name, NO_WAIT, &status);
  672.  
  673. /*  Start a one-second timer.  If the timer was     */
  674. /*  created, wait for 20 seconds (units) then stop  */
  675. /*  stop the timer.                                 */
  676.  
  677.   timer_sem = start_timer(1);
  678.  
  679.   if (timer_sem != NUL_TKN)
  680.     {
  681.     rqreceiveunits(timer_sem, 20, WAIT_FOREVER, &status);
  682.     stop_timer(timer_sem);
  683.     }
  684.  
  685. /*  Signal task finished and suspend execution.   */
  686.  
  687.   rqsendunits(init_sem, 1, &status);
  688.  
  689.   rqsuspendtask(NUL_TKN, &status);  /* suspend this task  */
  690.   }
  691.  
  692. /*1*********************************************************
  693. * Functions:  clrscrn, cursor_on, cursor_off, print_at
  694. *
  695. * Summary:  Functions for basic display control.
  696. *
  697. * Invocation:   clrscrn();
  698. *               curson_on();
  699. *               cursoff_on();
  700. *
  701. * Invocation:   print_at(row, col, msg_ptr)
  702. *
  703. * Inputs: row (unsigned int) - row position
  704. *         col (unsigned int) - column position
  705. *         msg_ptr (unsigned char *) - message string pointer
  706. *
  707. * Caveats:  Escape sequences are for a WYSE60 terminal.
  708. ***********************************************************/
  709.  
  710. void clrscrn(void)
  711.   {
  712.   fprintf(stdout, "\x1B+");
  713.   fflush(stdout);
  714.   return;
  715.   }
  716.  
  717. void cursor_on(void)
  718.   {
  719.   fprintf(stdout, "\x1B`1");
  720.   fflush(stdout);
  721.   return;
  722.   }
  723.  
  724. void cursor_off(void)
  725.   {
  726.   fprintf(stdout, "\x1B`0");
  727.   fflush(stdout);
  728.   return;
  729.   }
  730.  
  731. void print_at(unsigned int row,
  732.   unsigned int col, unsigned char *msg_ptr)
  733.   {
  734.   fprintf(stdout, "\x1B=%c%c%s",
  735.     (row + 31), (col + 31), msg_ptr);
  736.   fflush(stdout);
  737.   return;
  738.   }
  739.  
  740. /*1*********************************************************
  741. * Task:     crt_task
  742. *
  743. * Summary:  
  744. *
  745. * Caveats:  
  746. ***********************************************************/
  747.  
  748. void crt_task(void)
  749.   {
  750.   selector    current_job;
  751.   selector    req_mbx;
  752.   selector    rsp_mbx;
  753.   selector    req_seg;
  754.   selector    init_sem;
  755.   selector    crt_shtdwn_sem;
  756.  
  757.   unsigned int    status;
  758.  
  759.   struct CRT_REQ_STR    *req_msg;
  760.  
  761.   struct EXCEPTIONSTRUCT    exceptioninfo;
  762.  
  763. /*  Disable this task's exception handler */
  764.  
  765.   rqgetexceptionhandler(&exceptioninfo, &status);
  766.   exceptioninfo.exceptionmode = 0;
  767.   rqsetexceptionhandler(&exceptioninfo, &status);
  768.  
  769. /*  Lookup/Create needed objects */
  770.  
  771.   current_job = rqgettasktokens(THIS_JOB, &status);
  772.  
  773.   init_sem = rqlookupobject(current_job,
  774.     &init_sem_name, WAIT_FOREVER, &status);
  775.  
  776.   crt_shtdwn_sem = rqlookupobject(current_job,
  777.     &crt_shtdwn_sem_name, WAIT_FOREVER, &status);
  778.  
  779.   req_mbx = rqcreatemailbox(FIFO_OBJ_MBX, &status);
  780.   rqcatalogobject(current_job,
  781.     req_mbx, &crt_req_mbx_name, &status);
  782.   
  783. /*  Initialize display  */
  784.  
  785.   cursor_off();
  786.   clrscrn();
  787.  
  788. /*  Signal initialization complete  */
  789.  
  790.   rqsendunits(init_sem, 1, &status);
  791.  
  792.  
  793.   rqreceiveunits(crt_shtdwn_sem, 1, NO_WAIT, &status);
  794.  
  795.   while (status == ETIME)
  796.     {
  797.     req_seg = rqreceivemessage(req_mbx,
  798.       WAIT_FOREVER, &rsp_mbx, &status);
  799.  
  800.     req_msg = buildptr(req_seg, 0);
  801.  
  802.     print_at(req_msg->row,
  803.       req_msg->col, req_msg->msg_ptr);
  804.  
  805.     if (rsp_mbx != NUL_TKN)
  806.       {
  807.       rqsendmessage(rsp_mbx, req_seg, NUL_TKN, &status);
  808.       }
  809.     else
  810.       {
  811.       rqdeletesegment(req_seg, &status);
  812.       }
  813.  
  814.     rqreceiveunits(crt_shtdwn_sem, 1, NO_WAIT, &status);
  815.     }
  816.  
  817.   rqsendunits(init_sem, 1, &status);
  818.  
  819.   for(;;)
  820.     {
  821.     req_seg = rqreceivemessage(req_mbx,
  822.       WAIT_FOREVER, &rsp_mbx, &status);
  823.  
  824.     if (rsp_mbx != NUL_TKN)
  825.       {
  826.       rqsendmessage(rsp_mbx, req_seg, NUL_TKN, &status);
  827.       }
  828.     else
  829.       {
  830.       rqdeletesegment(req_seg, &status);
  831.       }
  832.     }
  833.   }
  834.  
  835. /*1*********************************************************
  836. * Function: read_time
  837. *
  838. * Summary:  Read a specified time/date register of the
  839. *           hardware clock.
  840. *
  841. * Invocation: in_byte = read_time(reg);
  842. *
  843. * Inputs:   reg (unsigned char) - the hardware time/date
  844. *             register to be read
  845. *
  846. * Outputs:  in_byte (unsigned char) - the value of the
  847. *             register read
  848. *
  849. * Caveats:  None
  850. ***********************************************************/
  851.  
  852. unsigned char read_time(unsigned char reg)
  853.   {
  854.   unsigned char in_byte;
  855.  
  856.   outbyte(CNT_PORT, HOLD_HIGH);
  857.   delay(3);
  858.   outbyte(CNT_PORT, HOLD_READ);
  859.   delay(1);
  860.   outbyte(ADR_PORT, reg);
  861.   delay(1);
  862.   in_byte = inbyte(DAT_PORT);
  863.   outbyte(CNT_PORT, CNT_RST);
  864.   delay(1);
  865.  
  866.   return (in_byte);
  867.   }
  868.  
  869. /*1*********************************************************
  870. * Function: write_time
  871. *
  872. * Summary:  Write a byte to the specified time/date register
  873. *           of the hardware clock.
  874. *
  875. * Invocation: write_time(reg, out_byte);
  876. *
  877. * Inputs:   reg (unsigned char) - the hardware time/date
  878. *             register
  879. *
  880. *           out_byte (unsigned char) - the value to be
  881. *             written to the hardware clock register
  882. *
  883. * Caveats:  None
  884. ***********************************************************/
  885.  
  886. void write_time(unsigned char reg, unsigned char out_byte)
  887.   {
  888.   outbyte(CNT_PORT, HOLD_HIGH);
  889.   delay(3);
  890.   outbyte(ADR_PORT, reg);
  891.   delay(1);
  892.   outbyte(DAT_PORT, out_byte);
  893.   delay(1);
  894.   outbyte(CNT_PORT, HOLD_WRITE);
  895.   delay(1);
  896.   outbyte(CNT_PORT, CNT_RST);
  897.   delay(1);
  898.  
  899.   return;
  900.   }
  901.  
  902. /*1*********************************************************
  903. * Function: read_clock
  904. *
  905. * Summary:  Read the time/date from the hardware clock and
  906. *           stores it in the global time/date structure.
  907. *
  908. * Invocation: read_clock();
  909. *
  910. * Caveats:  Requires the caller to obtain access the shared
  911. *           time/date data segment.
  912. ***********************************************************/
  913.  
  914. void read_clock(void)
  915.   {
  916.   unsigned char time_buf[13];
  917.   unsigned int  i;
  918.  
  919. /*  Set mode  */
  920.  
  921.   outbyte(PIO_PORT, PIO_READ);
  922.   delay(1);
  923.  
  924. /*  Set control lines to disable interrupts */
  925.  
  926.   outbyte(CNT_PORT, CNT_RST);
  927.   delay(1);
  928.  
  929. /*  Read time/date  */
  930.  
  931.   for (i = 0 ; (i <= 12); i++)
  932.     {
  933.     time_buf[i] = read_time(i);
  934.     }
  935.  
  936.   sys_time->second =
  937.     (10 * (time_buf[SEC10_REG] & 0x07)) +
  938.     (time_buf[SEC01_REG] & 0x0F);
  939.   sys_time->minute =
  940.     (10 * (time_buf[MIN10_REG] & 0x07)) +
  941.     (time_buf[MIN01_REG] & 0x0F);
  942.   sys_time->hour =
  943.     (10 * (time_buf[HRS10_REG] & 0x03)) +
  944.     (time_buf[HRS01_REG] & 0x0F);
  945.   sys_time->date =
  946.     (10 * (time_buf[DAT10_REG] & 0x03)) +
  947.     (time_buf[DAT01_REG] & 0x0F);
  948.   sys_time->month =
  949.     (10 * (time_buf[MON10_REG] & 0x01)) +
  950.     (time_buf[MON01_REG] & 0x0F);
  951.   sys_time->year =
  952.     (10 * (time_buf[YRS10_REG] & 0x0F)) +
  953.     (time_buf[YRS01_REG] & 0x0F);
  954.  
  955. /*  Reset control lines to enable interrupts */
  956.  
  957.   outbyte(CNT_PORT, INT_ENB);
  958.   delay(1);
  959.  
  960.   outbyte(ADR_PORT, 0x0F);
  961.   delay(1);
  962.  
  963.   return;
  964.   }
  965.  
  966. /*1*********************************************************
  967. * Function: write_clock
  968. *
  969. * Summary:  Uses the global time/date structure to write a
  970. *           new time/date to the hardware clock.
  971. *
  972. * Invocation: write_clock();
  973. *
  974. * Caveats:  Requires the caller to obtain access the shared
  975. *           time/date data segment.
  976. ***********************************************************/
  977.  
  978. void write_clock(void)
  979.   {
  980.   unsigned char temp_byte;
  981.  
  982. /*  Set mode  */
  983.  
  984.   outbyte(PIO_PORT, PIO_WRITE);
  985.   delay(1);
  986.  
  987. /*  Set control lines to disable interrupts */
  988.  
  989.   outbyte(CNT_PORT, CNT_RST);
  990.   delay(1);
  991.  
  992. /*  Write time/date.  Seconds always set to 0 */
  993.  
  994.   sys_time->second = 0;
  995.   write_time(SEC01_REG, 0);
  996.   write_time(SEC10_REG, 0);
  997.  
  998.   temp_byte =
  999.     sys_time->minute - (10 * (sys_time->minute / 10));
  1000.   write_time(MIN01_REG, temp_byte);
  1001.   temp_byte = sys_time->minute / 10;
  1002.   write_time(MIN10_REG, temp_byte);
  1003.  
  1004.   temp_byte =
  1005.     sys_time->hour - (10 * (sys_time->hour / 10));
  1006.   write_time(HRS01_REG, temp_byte);
  1007.   temp_byte =
  1008.     (sys_time->hour / 10) | 0x08;     /* 24hr format */
  1009.   write_time(HRS10_REG, temp_byte);
  1010.  
  1011.   temp_byte =
  1012.     sys_time->date - (10 * (sys_time->date / 10));
  1013.   write_time(DAT01_REG, temp_byte);
  1014.   temp_byte = sys_time->date / 10;
  1015.   write_time(DAT10_REG, temp_byte);
  1016.  
  1017.   temp_byte =
  1018.     sys_time->month - (10 * (sys_time->month / 10));
  1019.   write_time(MON01_REG, temp_byte);
  1020.   temp_byte = sys_time->month / 10;
  1021.   write_time(MON10_REG, temp_byte);
  1022.  
  1023.   temp_byte =
  1024.     sys_time->year - (10 * (sys_time->year / 10));
  1025.   write_time(YRS01_REG, temp_byte);
  1026.   temp_byte = sys_time->year / 10;
  1027.   write_time(YRS10_REG, temp_byte);
  1028.  
  1029. /*  Reset mode  */
  1030.  
  1031.   outbyte(PIO_PORT, PIO_READ);
  1032.   delay(1);
  1033.  
  1034. /*  Reset control lines to enable interrupts  */
  1035.  
  1036.   outbyte(CNT_PORT, INT_ENB);
  1037.   delay(1);
  1038.  
  1039.   outbyte(ADR_PORT, 0x0F);
  1040.   delay(1);
  1041.  
  1042.   return;
  1043.   }
  1044.  
  1045. /*1*********************************************************
  1046. * Function: reset_timers
  1047. *
  1048. * Summary:  Initializes (zero out) all timer slots of the
  1049. *           shared time/date data segment.
  1050. *
  1051. * Invocation: reset_timers();
  1052. *
  1053. * Caveats:  Requires the caller to obtain access the shared
  1054. *           time/date data segment.
  1055. ***********************************************************/
  1056.  
  1057. void reset_timers(void)
  1058.   {
  1059.   unsigned int    i;
  1060.  
  1061.   for (i = 0 ; i < MAX_TIMERS; i++)
  1062.     {
  1063.     sys_time->timer[i].in_use = FALSE;
  1064.     sys_time->timer[i].sem_tkn = NUL_TKN;
  1065.     sys_time->timer[i].count = 0;
  1066.     sys_time->timer[i].timeout = 0;
  1067.     }
  1068.  
  1069.   return;
  1070.   }
  1071.  
  1072. /*1*********************************************************
  1073. * Function: advance_timers
  1074. *
  1075. * Summary:  Increments all active timers in the shared
  1076. *           time/date data segment by one second.
  1077. *
  1078. * Invocation: advance_timers();
  1079. *
  1080. * Caveats:  Requires the caller to obtain access the shared
  1081. *           time/date data segment.
  1082. ***********************************************************/
  1083.  
  1084. void advance_timers(void)
  1085.   {
  1086.   unsigned int    i;
  1087.   unsigned int    status;
  1088.  
  1089.  
  1090.   for (i = 0 ; i < MAX_TIMERS; i++)
  1091.     {
  1092.     if (sys_time->timer[i].in_use)
  1093.       {
  1094.       sys_time->timer[i].count++;
  1095.  
  1096.       if (sys_time->timer[i].count >=
  1097.         sys_time->timer[i].timeout)
  1098.         {
  1099.         rqsendunits(
  1100.           sys_time->timer[i].sem_tkn, 1, &status);
  1101.         sys_time->timer[i].count = 0;
  1102.         }
  1103.       }
  1104.     }
  1105.  
  1106.   return;
  1107.   }
  1108.  
  1109. /*1*********************************************************
  1110. * Function: advance_time_date
  1111. *
  1112. * Summary:  Increments the time/date (hh:mm:ss mm/dd/yy) in
  1113. *           the shared time/date data segment by one second.
  1114. *
  1115. * Invocation: advance_time_date();
  1116. *
  1117. * Caveats:  Requires the caller to obtain access the shared
  1118. *           time/date data segment.
  1119. ***********************************************************/
  1120.  
  1121. void advance_time_date(void)
  1122.   {
  1123.   if (sys_time->second < 59)
  1124.     {
  1125.     sys_time->second++;
  1126.     }
  1127.   else
  1128.     {
  1129.     sys_time->second = 0;
  1130.  
  1131.     if (sys_time->minute < 59)
  1132.       {
  1133.       sys_time->minute++;
  1134.       }
  1135.     else
  1136.       {
  1137.       sys_time->minute = 0;
  1138.  
  1139.       if (sys_time->hour < 23)
  1140.         {
  1141.         sys_time->hour++;
  1142.         }
  1143.       else
  1144.         {
  1145.         sys_time->hour = 0;
  1146.  
  1147.         if (sys_time->date <
  1148.           days_in_month[sys_time->month - 1])
  1149.           {
  1150.           sys_time->date++;
  1151.           }
  1152.         else
  1153.           {
  1154.           if (sys_time->month == FEBRUARY)
  1155.             {
  1156. /*  Check for leap year (only good through 2100)  */
  1157.  
  1158.             if (((sys_time->year % 4) == 0) &&
  1159.               (sys_time->date == 28))
  1160.               {
  1161.               sys_time->date = 29;
  1162.               }
  1163.             else
  1164.               {
  1165.               sys_time->month = MARCH;
  1166.               sys_time->date = 1;
  1167.               }
  1168.             }
  1169.           else
  1170.             {
  1171.             sys_time->date = 1;
  1172.  
  1173.             if (sys_time->month < DECEMBER)
  1174.               {
  1175.               sys_time->month++;
  1176.               }
  1177.             else
  1178.               {
  1179.               sys_time->month = JANUARY;
  1180.  
  1181.               if (sys_time->year < 99)
  1182.                 {
  1183.                 sys_time->year++;
  1184.                 }
  1185.               else
  1186.                 {
  1187.                 sys_time->year = 0;
  1188.                 }
  1189.               }
  1190.             }
  1191.           }
  1192.         }
  1193.       }
  1194.     }
  1195.  
  1196.   return;
  1197.   }
  1198.  
  1199. /*1*********************************************************
  1200. * Function: start_timer
  1201. *
  1202. * Summary:  Create and start a timer.
  1203. *
  1204. * Invocation: timer_sem = start_timer(timeout);
  1205. *
  1206. * Inputs:   timeout (unsigned int) - timer interval
  1207. *             in seconds
  1208. *
  1209. * Outputs:  timer_sem (selector) - the semaphore that will
  1210. *             receive a unit at each timer interval
  1211. *
  1212. * Caveats:  The interrupt handler will signal the
  1213. *           interrupt task to finish servicing the
  1214. *           interrupt.
  1215. ***********************************************************/
  1216.  
  1217. /*  Tell the compiler that this function is an interrupt  */
  1218. /*  routine so it can generate proper code for entering   */
  1219. /*  and exiting the interrupt routine.                    */
  1220.  
  1221. #pragma interrupt("clockint_handler")
  1222.  
  1223. void clockint_handler(void)
  1224.   {
  1225.   unsigned int  status;
  1226.  
  1227. /*  Signal the interrupt task */
  1228.  
  1229.   rqsignalinterrupt(CLOCK_INT_LEVEL, &status);
  1230.  
  1231.   return;
  1232.   }
  1233.  
  1234. /*1*********************************************************
  1235. * Task:     clock_task
  1236. *
  1237. * Summary:  Services interrupts from the hardware clock.
  1238. *           Also maintains/updates the global time/date
  1239. *           data and services software timers.
  1240. *
  1241. * Caveats:  Communicates with the crt_task() to display the
  1242. *           current time/date.
  1243. ***********************************************************/
  1244.  
  1245. void clock_task(void)
  1246.   {
  1247.   char    time_string[19];
  1248.  
  1249.   unsigned int  status;
  1250.   unsigned int  retry;
  1251.  
  1252.   selector  current_job;
  1253.   selector  init_sem;
  1254.   selector  clock_sem;
  1255.   selector  clock_shtdwn_sem;
  1256.   selector  rsp_seg;
  1257.   selector  req_seg;
  1258.   selector  crt_req_mbx;
  1259.   selector  rsp_mbx;
  1260.  
  1261.   struct CRT_REQ_STR    *req_msg;
  1262.  
  1263.   struct EXCEPTIONSTRUCT    exceptioninfo;
  1264.  
  1265. /*  Disable this task's exception handler */
  1266.  
  1267.   rqgetexceptionhandler(&exceptioninfo, &status);
  1268.   exceptioninfo.exceptionmode = 0;
  1269.   rqsetexceptionhandler(&exceptioninfo, &status);
  1270.  
  1271. /*  Disable any current interrupt task  */
  1272.  
  1273.   rqresetinterrupt(CLOCK_INT_LEVEL, &status);
  1274.  
  1275. /*  Lookup/Create needed objects */
  1276.  
  1277.   current_job = rqgettasktokens(THIS_JOB, &status);
  1278.  
  1279.   init_sem = rqlookupobject(current_job,
  1280.     &init_sem_name, NO_WAIT, &status);
  1281.  
  1282.   clock_sem = rqlookupobject(current_job,
  1283.     &clock_sem_name, NO_WAIT, &status);
  1284.  
  1285.   sys_time_seg = rqlookupobject(current_job,
  1286.     &time_seg_name, NO_WAIT, &status);
  1287.  
  1288.   clock_shtdwn_sem = rqlookupobject(current_job,
  1289.     &clock_shtdwn_sem_name, NO_WAIT, &status);
  1290.  
  1291.   crt_req_mbx = rqlookupobject(current_job,
  1292.     &crt_req_mbx_name, NO_WAIT, &status);
  1293.  
  1294.   sys_time = buildptr(sys_time_seg, 0);
  1295.  
  1296.   rsp_mbx = rqcreatemailbox(FIFO_OBJ_MBX, &status);
  1297.  
  1298. /*  Initialize time string buffer */
  1299.  
  1300.   memset(&time_string, ' ', sizeof(time_string));
  1301.  
  1302. /*  Initialize crt_task() request message and */
  1303. /*  send it to the response mailbox to setup  */
  1304. /*  for the processing loop.                  */
  1305.  
  1306.   req_seg = rqcreatesegment(
  1307.     sizeof(struct CRT_REQ_STR), &status);
  1308.   req_msg = buildptr(req_seg, 0);
  1309.  
  1310.   req_msg->msg_ptr = &time_string;
  1311.   req_msg->row = 1;
  1312.   req_msg->col = 60;
  1313.  
  1314.   rqsendmessage(rsp_mbx, req_seg, NUL_TKN, &status);
  1315.  
  1316. /*  Initialize retry counter and timers */
  1317.  
  1318.   retry = 0;
  1319.   sys_time->change_flg = FALSE;
  1320.   reset_timers();
  1321.  
  1322. /*  Initialize and read hardware clock  */
  1323.  
  1324.   outbyte(PIO_PORT, PIO_READ);
  1325.   delay(1);
  1326.  
  1327.   outbyte(CNT_PORT, INT_ENB);
  1328.   delay(1);
  1329.  
  1330.   outbyte(ADR_PORT, 0x0F);
  1331.   delay(1);
  1332.  
  1333.   read_clock();
  1334.  
  1335. /*  Allow access to time/date memory  */
  1336.  
  1337.   rqsendunits(clock_sem, 1, &status);
  1338.  
  1339. /*  Set interrupt vector  */
  1340.  
  1341.   rqsetinterrupt(CLOCK_INT_LEVEL, 1,
  1342.     &clockint_handler, NUL_TKN, &status);
  1343.  
  1344. /*  Signal initialization complete  */
  1345.  
  1346.   rqsendunits(init_sem, 1, &status);
  1347.  
  1348. /*  Process interrupt signals until shutdown  */
  1349.  
  1350.   rqreceiveunits(clock_shtdwn_sem, 1, NO_WAIT, &status);
  1351.  
  1352.   while (status == ETIME)   /* while no signal received */
  1353.     {
  1354. /*  Wait no longer than 2 seconds for interrupt signal  */
  1355.  
  1356.     rqetimedinterrupt(CLOCK_INT_LEVEL, 200, &status);
  1357.  
  1358. /*  If an interrupt is NOT received, attempt to reset */
  1359. /*  the hardware clock.                               */
  1360.  
  1361.     if (status == ETIME)      /* if no interrupt  */
  1362.       {
  1363.       retry++;
  1364.  
  1365. /*  Once the maximum number of retries is reached,    */
  1366. /*  give up.  Retrieve outstanding display request    */
  1367. /*  and wait for shutdown.  When shutdown signal is   */
  1368. /*  received, disable this interrupt task, signal     */
  1369. /*  shutdown complete and suspend execution.          */
  1370.  
  1371.       if (retry == MAX_CLOCK_RETRIES)
  1372.         {
  1373.         req_seg = rqreceivemessage(rsp_mbx,
  1374.           WAIT_FOREVER, NUL_TKN, &status);
  1375.         rqreceiveunits(clock_shtdwn_sem, 1,
  1376.           WAIT_FOREVER, &status);
  1377.         rqresetinterrupt(CLOCK_INT_LEVEL, &status);
  1378.         rqsendunits(init_sem, 1, &status);
  1379.         rqsuspendtask(NUL_TKN, &status);
  1380.         }
  1381.  
  1382. /*  Reinitialize hardware clock */
  1383.  
  1384.         outbyte(PIO_PORT, PIO_READ);
  1385.         delay(1);
  1386.  
  1387.         outbyte(CNT_PORT, INT_ENB);
  1388.         delay(1);
  1389.  
  1390.         outbyte(ADR_PORT, 0x0F);
  1391.         delay(1);
  1392.  
  1393. /*  Re-read hardware clock  */
  1394.  
  1395.         rqreceiveunits(clock_sem, 1,
  1396.           WAIT_FOREVER, &status);
  1397.  
  1398.         read_clock();
  1399.  
  1400.         rqsendunits(clock_sem, 1, &status);
  1401.         }
  1402.       else
  1403.         {
  1404. /*  Interrupt signal received, reset retry count  */
  1405.  
  1406.         retry = 0;
  1407.  
  1408. /*  Access time/date memory */
  1409.  
  1410.         rqreceiveunits(clock_sem, 1,
  1411.           WAIT_FOREVER, &status);
  1412.  
  1413. /*  If needed, update hardware clock with new */
  1414. /*  time/date data.  Otherwise, advance the   */
  1415. /*  time/data data by one second.             */
  1416.  
  1417.         if (sys_time->change_flg)
  1418.           {
  1419.           write_clock();
  1420.           sys_time->change_flg = 0;
  1421.           }
  1422.         else
  1423.           {
  1424.           advance_time_date();
  1425.           }
  1426.  
  1427. /*  Advance any timers by one second  */
  1428.  
  1429.         advance_timers();
  1430.  
  1431. /*  Prepare time/date data for display  */
  1432.  
  1433.       sprintf(time_string, "%02d:%02d:%02d  %02d/%02d/%02d",
  1434.         sys_time->hour, sys_time->minute, sys_time->second,
  1435.         sys_time->month, sys_time->date, sys_time->year);
  1436.  
  1437. /*  Release time/date memory  */
  1438.  
  1439.       rqsendunits(clock_sem, 1, &status);
  1440.  
  1441. /*  If previous display request has finished(segment    */
  1442. /*  returned), then request new time/date be displayed  */
  1443.  
  1444.       rsp_seg = rqreceivemessage(rsp_mbx,
  1445.         NO_WAIT, NUL_TKN, &status);
  1446.  
  1447.       if (status != ETIME)
  1448.         {
  1449.         rqsendmessage(crt_req_mbx,
  1450.           req_seg, rsp_mbx, &status);
  1451.         }
  1452.       }
  1453.  
  1454. /*  Check for shutdown  */
  1455.  
  1456.     rqreceiveunits(clock_shtdwn_sem, 1, NO_WAIT, &status);
  1457.     }
  1458.  
  1459. /*  Retrieve outstanding display request, disable   */
  1460. /*  this interrupt task, signal shutdown complete   */
  1461. /*  and suspend execution.                          */
  1462.  
  1463.   req_seg = rqreceivemessage(rsp_mbx,
  1464.     WAIT_FOREVER, NUL_TKN, &status);
  1465.  
  1466.   rqsendunits(init_sem, 1, &status);
  1467.  
  1468.   rqresetinterrupt(CLOCK_INT_LEVEL, &status);
  1469.  
  1470.   rqsuspendtask(NUL_TKN, &status);  /* suspend this task  */
  1471.   }
  1472.