traffic2.c

RTX51 example use. Inside are example on how to use RTX51 RTOS. it uses memory pool, messages, RTXba

/****************************************************************************/
/*                                                                          */
/*   TRAFFIC2.C:  Traffic Light Controller using RTX-51                     */
/*                                                                          */
/*   17-NOV-1994 / EG                                                       */
/****************************************************************************/
/*   Derived from TRAFFIC.C (originally written for RTX tiny).              */
/*   Shows advanced features of the full version of RTX-51.                 */
/****************************************************************************/

#pragma CODE DEBUG OBJECTEXTEND

code char menu[] = 
   "\n"
   "+******* TRAFFIC LIGHT CONTROLLER using C51 and RTX-51 ********+\n"
   "| This program is a simple Traffic Light Controller.  Between  |\n"
   "| start time and end time the system controls a traffic light  |\n"
   "| with pedestrian self-service and approaching car detection.  |\n"
   "| Outside of this time range the yellow caution lamp is blink- |\n"
   "| ing.                                                         |\n"
   "+ command -+ syntax -----+ function ---------------------------+\n"
   "| Display  | D           | display times                       |\n"
   "| Time     | T hh:mm:ss  | set clock time                      |\n"
   "| Start    | S hh:mm:ss  | set start time                      |\n"
   "| End      | E hh:mm:ss  | set end time                        |\n"
   "+----------+-------------+-------------------------------------+\n";


#include <reg517.h>                   /* special function registers 80517   */
#include <rtx51.h>                    /* RTX-51 functions & defines         */
#include <stdio.h>                    /* standard I/O .h-file               */
#include <ctype.h>                    /* character functions                */
#include <string.h>                   /* string and memory functions        */


extern getline (char idata *, char);  /* external function: input line      */
extern serial_init ();                /* external function: init serial UART*/

#define INIT      0                   /* task number of task:  init         */
#define COMMAND   1                   /* task number of task:  command      */
#define CLOCK     2                   /* task number of task:  clock        */
#define BLINKING  3                   /* task number of task:  blinking     */
#define LIGHTS    4                   /* task number of task:  signal       */
#define KEYREAD   5                   /* task number of task:  keyread      */
#define GET_ESC   6                   /* task number of task:  get_escape   */
#define CAR_DET1  7                   /* task number of task:  car_det1     */
#define CAR_DET2  8                   /* task number of task:  car_det2     */

struct time  {                        /* structure of the time record       */
  unsigned char hour;                 /* hour                               */
  unsigned char min;                  /* minute                             */
  unsigned char sec;                  /* second                             */
};

struct time ctime = { 12,  0,  0 };   /* storage for clock time values      */
struct time start = {  7, 30,  0 };   /* storage for start time values      */
struct time end   = { 18, 30,  0 };   /* storage for end   time values      */

unsigned char keypressed1;            /* status flag: pedestrian button 1   */
unsigned char keypressed2;            /* status flag: pedestrian button 2   */
unsigned char cardetected1;           /* status flag: car detector 1        */
unsigned char cardetected2;           /* status flag: car detector 2        */

unsigned char phaseno;                /* Traffic control phase number       */

                                      /* Direction 1                        */
sbit  red___1 = P1^2;                 /* I/O Pin:  red    lamp output       */
sbit  yellow1 = P1^1;                 /* I/O Pin:  yellow lamp output       */
sbit  green_1 = P1^0;                 /* I/O Pin:  green  lamp output       */
sbit  stop__1 = P1^3;                 /* I/O Pin:  stop   lamp output       */
sbit  walk__1 = P1^4;                 /* I/O Pin:  walk   lamp output       */
sbit  key1    = P1^5;                 /* I/O Pin:  self-service key input   */
                                                                           
                                      /* Direction 2                        */
sbit  red___2 = P4^2;                 /* I/O Pin:  red    lamp output       */
sbit  yellow2 = P4^1;                 /* I/O Pin:  yellow lamp output       */
sbit  green_2 = P4^0;                 /* I/O Pin:  green  lamp output       */
sbit  stop__2 = P4^3;                 /* I/O Pin:  stop   lamp output       */
sbit  walk__2 = P4^4;                 /* I/O Pin:  walk   lamp output       */
sbit  key2    = P4^5;                 /* I/O Pin:  self-service key input   */

idata    char inline[16];             /* storage for command input line     */


/****************************************************************************/
/*        Task 0 'init': Initialize                                         */
/****************************************************************************/
void init (void) _task_ INIT  {       /* program execution starts here      */
  serial_init ();                     /* initialize the serial interface    */
  os_set_slice (10000);               /* set the system timebase to 10ms    */
  os_create_task (CLOCK);             /* start clock task                   */
  os_create_task (COMMAND);           /* start command task                 */
  os_create_task (LIGHTS);            /* start lights task                  */
  os_create_task (KEYREAD);           /* start keyread task                 */
  os_create_task (CAR_DET1);          /* start cardet1 task                 */
  os_create_task (CAR_DET2);          /* start cardet2 task                 */
  os_delete_task (INIT);              /* stop init task (no longer needed)  */
}


bit display_time = 0;                 /* flag: cmd state display_time       */

/****************************************************************************/
/*        Task 2 'clock'                                                    */
/****************************************************************************/
void clock (void)  _task_ CLOCK _priority_ 1 {
  while (1)  {                        /* clock is an endless loop           */
    if (++ctime.sec == 60)  {         /* calculate the second               */
      ctime.sec = 0;
      if (++ctime.min == 60)  {       /* calculate the minute               */
        ctime.min = 0;
        if (++ctime.hour == 24)  {    /* calculate the hour                 */
          ctime.hour = 0;
        }
      }
    }
    if (display_time)  {              /* if command_status == display_time  */
      os_send_signal (COMMAND);       /* signal to 'command': time changed  */
    }
    os_wait (K_TMO, 100, 0);          /* wait for 1 second                  */
  }
}


struct time rtime;                    /* temporary storage for entry time   */

/****************************************************************************/
/*        readtime: convert line input to time values & store in rtime      */
/****************************************************************************/
bit readtime (char idata *buffer)  {
  unsigned char args;                          /* number of arguments       */

  rtime.sec = 0;                               /* preset second             */
  args = sscanf (buffer, "%bd:%bd:%bd",        /* scan input line for       */
                 &rtime.hour,                  /* hour, minute and second   */
                 &rtime.min,
                 &rtime.sec);
  
  if (rtime.hour > 23  ||  rtime.min > 59  ||  /* check for valid inputs    */
      rtime.sec > 59   ||  args < 2        ||  args == EOF)  {
    printf ("\n*** ERROR: INVALID TIME FORMAT\n");
    return (0);
  }
  return (1);
}



#define ESC  0x1B                     /* ESCAPE character code              */

bit   escape;                         /* flag: mark ESC character entered   */

/****************************************************************************/
/*        Task 6 'get_escape': check if ESC (escape character) was entered  */
/****************************************************************************/
void get_escape (void) _task_ GET_ESC  {
  while (1)  {                                 /* endless loop              */
    if (_getkey () == ESC)  escape = 1;        /* set flag if ESC entered   */
    if (escape)  {                             /* if esc flag send signal   */
      os_send_signal (COMMAND);                /* to task 'command'         */
    }
  }
}


/****************************************************************************/
/*        Task 1 'command': command processor                               */
/****************************************************************************/
void command (void) _task_ COMMAND  {
  unsigned char i;

  printf (menu);                               /* display command menu      */
  while (1)  {                                 /* endless loop              */
    printf ("\nCommand: ");                    /* display prompt            */
    getline (&inline, sizeof (inline));        /* get command line input    */

    for (i = 0; inline[i] != 0; i++)  {        /* convert to uppercase      */
      inline[i] = toupper(inline[i]);
    }

    for (i = 0; inline[i] == ' '; i++);        /* skip blanks               */

    switch (inline[i])  {                      /* proceed to cmd function   */
      case 'D':                                /* Display Time Command      */
        printf ("Start Time: %02bd:%02bd:%02bd    "
                "End Time: %02bd:%02bd:%02bd\n",
                 start.hour, start.min, start.sec,
                 end.hour,   end.min,   end.sec);
        printf ("                        type ESC to abort\r");

        os_create_task (GET_ESC);              /* ESC check in display loop */
        escape = 0;                            /* clear escape flag         */
        display_time = 1;                      /* set display time flag     */
        os_clear_signal (COMMAND);             /* clear pending signals     */

        while (!escape)  {                     /* while no ESC entered      */
          printf ("Clock Time: %02bd:%02bd:%02bd\r",      /* display time   */
                   ctime.hour, ctime.min, ctime.sec);
          os_wait (K_SIG, 0, 0);               /* wait for time change/ESC  */
        }
                                               
        os_delete_task (GET_ESC);              /* ESC check not longer needd*/
        display_time = 0;                      /* clear display time flag   */
        printf ("\n\n");
        break;

      case 'T':                                /* Set Time Command          */
        if (readtime (&inline[i+1]))  {        /* read time input and       */
          ctime.hour = rtime.hour;             /* store in 'ctime'          */
          ctime.min  = rtime.min;
          ctime.sec  = rtime.sec;
        }
        break;

      case 'E':                                /* Set End Time Command      */
        if (readtime (&inline[i+1]))  {        /* read time input and       */
          end.hour = rtime.hour;               /* store in 'end'            */
          end.min  = rtime.min;
          end.sec  = rtime.sec;
        }
        break;

      case 'S':                                /* Set Start Time Command    */
        if (readtime (&inline[i+1]))  {        /* read time input and       */
          start.hour = rtime.hour;             /* store in 'start'          */
          start.min  = rtime.min;
          start.sec  = rtime.sec;
        }
        break;

      default:                                 /* Error Handling            */
        printf (menu);                         /* display command menu      */
        break;