home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 September / pcwk_09_96.iso / demo / wgelectr / pk51demo / files.2 / EXAMPLES / MEASURE / MEASURE.C < prev    next >
C/C++ Source or Header  |  1995-08-25  |  15KB  |  294 lines
  1. /*------------------------------------------------------------------------------
  2. MEASURE.C:  Remote Measurement Recorder using the C-51 COMPILER
  3.  
  4. Copyright 1995 KEIL Software, Inc.
  5. ------------------------------------------------------------------------------*/
  6.  
  7. code char menu[] = 
  8.    "\n"
  9.    "+**************** REMOTE MEASUREMENT RECORDER *****************+\n"
  10.    "| This program is a simple Measurement Recorder. It is based   |\n"
  11.    "| on the 80515 CPU and records the state of Port 4 and Port 5  |\n"
  12.    "| and the voltage on the four analog inputs AN0 through AN3.   |\n"
  13.    "+ command -+ syntax -----+ function ---------------------------+\n"
  14.    "| Read     | R [n]       | read <n> recorded measurements      |\n"
  15.    "| Display  | D           | display current measurement values  |\n"
  16.    "| Time     | T hh:mm:ss  | set time                            |\n"
  17.    "| Interval | I mm:ss.ttt | set interval time                   |\n"
  18.    "| Clear    | C           | clear measurement records           |\n"
  19.    "| Quit     | Q           | quit measurement recording          |\n"
  20.    "| Start    | S           | start measurement recording         |\n"
  21.    "+----------+-------------+-------------------------------------+\n";
  22.  
  23. #include <stdio.h>                       /* standard I/O .h-file              */
  24. #include <stdlib.h>                      /* standard library .h-file          */
  25. #include <reg515.h>                      /* special function register 80515   */
  26. #include <ctype.h>                       /* character functions               */
  27.  
  28. struct clock {                           /* structure of the clock record     */
  29.   unsigned char    hour;                 /* hour                              */
  30.   unsigned char     min;                 /* minute                            */
  31.   unsigned char     sec;                 /* second                            */
  32.   unsigned int     msec;                 /* milliseconds                      */
  33. };
  34.  
  35. struct mrec  {                           /* structure for measurement records */
  36.   struct   clock   time;                 /* time of measurement               */
  37.   unsigned char   port4;                 /* state of port 4                   */
  38.   unsigned char   port5;                 /* state of port 5                   */
  39.   unsigned char  analog [4];             /* voltage on analog Pins AN0 .. AN3 */
  40. };
  41.  
  42. struct interval  {                       /* structure for interval record     */
  43.   unsigned char     min;                 /* minute                            */
  44.   unsigned char     sec;                 /* second                            */
  45.   unsigned int     msec;                 /* milli second                      */
  46. };
  47.  
  48. extern getline (char idata *line, char n);  /* external functions: input line */
  49. extern measure_display (struct mrec disp);  /*           display measurements */
  50. extern set_time (char * buffer);            /*           set current time     */
  51. extern set_interval (char * buffer);        /*           set interval time    */
  52.  
  53. struct interval setinterval;                /* interval setting values        */
  54. struct interval interval;                   /* interval counter               */
  55.  
  56. unsigned char intcycle = 0;                 /* Interrupt cycle counter        */
  57.  
  58. bit measurement_interval = 0;               /* measurement interval over      */
  59. bit mdisplay = 0;                           /* measurement display requested  */
  60. bit startflag = 0;                          /* start measurement recording    */
  61.  
  62. struct mrec current;                        /* current measurements           */
  63.  
  64. #define XRAM    8192                        /* size of XDATA RAM is 8 KBytes  */
  65. #define SCNT  XRAM / sizeof (current)       /* number of records in XDATA RAM */
  66.  
  67. xdata struct mrec save_record [SCNT];       /* buffer for measurements        */
  68. unsigned int sindex;                        /* save index                     */
  69. unsigned int savefirst;                     /* save first index               */
  70.  
  71. code char ERROR [] = "\n*** ERROR: %s\n";   /* ERROR message string in code   */
  72.  
  73. #define PERIOD     -250                     /* 250 usec interrupt period      */
  74. #define WRONGINDEX 0xffff                   /* error signal for wrong index   */
  75.  
  76.  
  77. /* 
  78.  * The following function is called from the interrupt service routine.  This
  79.  * means that the code must be generated in the same Register Bank as the
  80.  * interrupt service function.
  81.  */
  82. #pragma REGISTERBANK (1)                    /* use Register Bank 1 for coding */
  83.  
  84. /******************************************************************************/
  85. /*               Save current measurements in save_record                     */
  86. /******************************************************************************/
  87. void save_current_measurements () {
  88.   save_record[sindex++] = current;             /* copy current measurements   */
  89.   if (sindex == SCNT) sindex = 0;              /* check bounds of sindex      */
  90.   if (sindex == savefirst)  {                  /* check circular buffer limits*/
  91.     if (++savefirst == SCNT)  savefirst = 0;   /* check bounds of savefirst   */
  92.   }
  93. }
  94.  
  95.  
  96. /******************************************************************************/
  97. /*                Timer 0 interrupt service function                          */
  98. /*                executes each 250us @ 12 MHz Crystal Clock                  */
  99. /******************************************************************************/
  100. timer0() interrupt 1 using 1 {            /* Int Vector at 000BH, Reg Bank 1  */
  101.  
  102.   unsigned char i;
  103.  
  104.   if (measurement_interval)  {                 /* measurement done ?          */
  105.     save_current_measurements ();              /* yes -> save measurements    */
  106.     measurement_interval = 0;                  /* Save measurements done      */
  107.   }
  108.  
  109.   if (++intcycle == 4)  {                      /* 1 msec = 4 * 250 usec cycle */
  110.     intcycle = 0;
  111.                                                /* check if interval is over   */
  112.     if (interval.min  == 0 && 
  113.         interval.sec  == 0 && 
  114.         interval.msec == 0     )  {
  115.       interval = setinterval;                  /* set interval time again     */
  116.       measurement_interval = startflag;        /* determine measurement flag  */
  117.     }
  118.     else  {                                    /* update interval time        */
  119.       if (interval.msec-- == 0)  {             /* calculate millisecond       */
  120.         interval.msec = 999;
  121.         if (interval.sec-- == 0)  {            /* calculate second            */
  122.           interval.sec = 59;
  123.           interval.min--;                      /* calculate minute            */
  124.         }
  125.       }
  126.     }
  127.                                                /* update current time         */
  128.     if (++current.time.msec == 1000)  {        /* update millisecond cnt      */
  129.       current.time.msec = 0;
  130.  
  131.       if (++current.time.sec == 60)  {         /* update second counter       */
  132.         current.time.sec = 0;
  133.  
  134.         if (++current.time.min == 60)  {       /* update minute counter       */
  135.           current.time.min = 0;
  136.  
  137.           if (++current.time.hour == 24)  {    /* update hour counter         */
  138.             current.time.hour = 0;
  139.           }
  140.         }
  141.       }
  142.     }    /* end of if( ++current.time.msec... */
  143.  
  144.     if (measurement_interval || mdisplay)  {   /* process measurement         */
  145.       current.port4 = P4;                      /* read port 4                 */
  146.       current.port5 = P5;                      /* read port 5                 */
  147.       for (i = 0; i != 4; i++)  {              /* loop for 4 A/D inputs       */
  148.         ADCON &= 0xF8;                         /* strip off prev A/D selection*/
  149.         ADCON |= i;                            /* select A/D input            */
  150.         DAPR = 0;                              /* start conversion            */
  151.         while (BSY);                           /* wait for A/D result         */
  152.         current.analog[i] = ADDAT;             /* result of A/D process       */ 
  153.       }
  154.       mdisplay = 0;                            /* mdisplay = 0 for ready sig. */
  155.     }
  156.   }
  157. }
  158.  
  159.  
  160. /* 
  161.  * The following functions are called from the main routine.  Therefore
  162.  * Register Bank 0 must be used when coding these functions.
  163.  */
  164.  
  165. #pragma REGISTERBANK (0)                    /* use Register Bank 0 for coding */
  166. /******************************************************************************/
  167. /*                       Calculate first Read Index                           */
  168. /******************************************************************************/
  169. unsigned int read_index (char *buffer) {
  170.   int index = 0;
  171.   unsigned char args;
  172.  
  173.   if (setinterval.min == 0     &&              /* check if setinterval is     */
  174.       setinterval.sec == 0     &&              /* below 1 second and          */
  175.       setinterval.msec < 999   &&              /* measurements are collected  */
  176.       startflag                   )  {         
  177.     printf (ERROR, "QUIT MEASUREMENTS BEFORE READ");
  178.     return (WRONGINDEX);                       /* no display on the fly if    */
  179.   }                                            /* interval time < 1 second    */
  180.   args = sscanf (buffer, "%d", &index);        /* scan input for read count   */
  181.   if (args == 0  ||  index == 0  || args == EOF)  index = SCNT-1;
  182.   index = sindex - index;                      /* calculate first read index  */
  183.   if (index < 0) index += SCNT;                /* from read count             */
  184.   return (index);
  185. }
  186.   
  187.  
  188. /******************************************************************************/
  189. /*                         Clear Measurement Records                          */
  190. /******************************************************************************/
  191. void clear_records (void) {
  192.   unsigned int idx;                            /* index for loop              */
  193.  
  194.   startflag = 0;                               /* stop measurement collecting */
  195.   sindex = savefirst = 0;                      /* reset circular buffer index */
  196.   for (idx = 0; idx != SCNT; idx++)  {         /* mark all records unused     */
  197.     save_record[idx].time.hour = 0xff;         /* unused flag: hour = 0xff    */
  198.   }     
  199. }
  200.  
  201.  
  202. /******************************************************************************/
  203. /***************************      MAIN PROGRAM      ***************************/
  204. /******************************************************************************/
  205. void main ( void )  {                          /* main entry for program      */
  206.   idata char cmdbuf [15];                      /* command input buffer        */
  207.   unsigned char i;                             /* index for command buffer    */
  208.   unsigned int idx;                            /* index for circular buffer   */
  209.  
  210.   /* initialize the serial interface */
  211.   SCON = 0x5A;                                 /* initialize UART to mode 1   */
  212.   BD = 1;                                      /* internal Baudrate Generator */
  213.   PCON |= 0x80;                                /* set to 9600 Baud @ 12 MHz   */
  214.  
  215.   /* setup the timer 0 interrupt */
  216.   TH0 = PERIOD;                                /* set timer period            */
  217.   TL0 = PERIOD;
  218.   TMOD = TMOD | 0x02;                          /* select mode 2               */
  219.   TR0 = 1;                                     /* start timer 0               */
  220.   ET0 = 1;                                     /* enable timer 0 interrupt    */
  221.   EAL = 1;                                     /* global interrupt enable     */
  222.  
  223.   clear_records ();                            /* initialize circular buffer  */
  224.   printf ( menu );                             /* display command menu        */
  225.   while (1)  {                                 /* loop forever                */
  226.     printf ("\nCommand: ");                    
  227.     getline (&cmdbuf[0], sizeof (cmdbuf));     /* input command line          */
  228.  
  229.     for (i = 0; cmdbuf[i] != 0; i++)  {        /* convert to upper characters */
  230.       cmdbuf[i] = toupper(cmdbuf[i]);
  231.     }
  232.  
  233.     for (i = 0; cmdbuf[i] == ' '; i++);        /* skip blanks                 */
  234.  
  235.     switch (cmdbuf[i])  {                      /* proceed to command function */
  236.  
  237.       case 'R':                                /* Read circular Buffer        */
  238.         if ((idx = read_index (&cmdbuf[i+1])) == WRONGINDEX)  break;
  239.         while (idx != sindex)  {               /* check end of table          */
  240.           if (RI)  {                           /* check serial interface      */
  241.             if (_getkey() == 0x1B) break;      /* for escape character        */
  242.           }
  243.           if (save_record[idx].time.hour != 0xff)  {
  244.             measure_display (save_record[idx]);      /* display record        */
  245.             printf ("\n");
  246.           }
  247.           if (++idx == SCNT) idx = 0;          /* next circular buffer entry  */
  248.         }
  249.         break;
  250.  
  251.       case 'T':                                /* Enter Current Time          */
  252.         set_time (&cmdbuf[i+1]);
  253.         break;
  254.  
  255.       case 'I':                                /* Enter Interval Time         */
  256.         set_interval (&cmdbuf[i+1]);
  257.         break;
  258.  
  259.       case 'D':                                /* Display Command             */
  260.         printf ("\nDisplay current Measurements: (ESC to abort)\n");
  261.         do  {                                  
  262.           while (! RI)  {                      /* check serial interface      */
  263.             mdisplay = 1;                      /* request measurement         */
  264.             while (mdisplay);                  /* wait for measurement        */
  265.             measure_display (current);         /* display values              */
  266.           }
  267.         } while (_getkey () != 0x1b);          /* escape terminates command   */
  268.         printf ("\n\n");
  269.         break;
  270.  
  271.       case 'S':                                /* Start Command               */
  272.         printf ("\nStart Measurement Recording\n");
  273.         startflag = 1;
  274.         break;
  275.  
  276.       case 'Q':                                /* Quit Command                */
  277.         printf ("\nQuit Measurement Recording\n");
  278.         startflag = 0;
  279.         break;
  280.  
  281.       case 'C':                                /* Clear Command               */
  282.         printf ("\nClear Measurement Records\n");
  283.         clear_records ();
  284.         break;
  285.  
  286.       default:                                 /* Error Handling              */
  287.         printf (ERROR, "UNKNOWN COMMAND");
  288.         printf (menu);                         /* display command menu        */
  289.         break;
  290.     }
  291.   }
  292. }
  293.  
  294.