measure.c

rtl exmple program for keil

    os_evt_set (0x0001, t_interval);
    os_evt_set (0x0001, t_command);
  }
}

/*----------------------------------------------------------------------------
 *        Task 'interval'
 *---------------------------------------------------------------------------*/
__task void interval_task (void) {
  int dly;

  while (1) {                                 /* interval is an endless loop */
    if (!startflag) {
      os_evt_wait_or (0x0010, 0xffff);        /* wait for signal to start    */
      startflag = 1;                          /* measurement recording       */
    }
           
    if (interval == 0) {    
      interval = setinterval;
      os_evt_set (0x0001, t_measure);         /* signal 'measure' task to    */
      os_evt_wait_or (0x0001, 0xffff);        /* take measurements, wait for */
      save_measurements ();                   /* results and save them       */
    }
    if (interval > 100) dly = 100;
    else                dly = interval;
    interval -= dly;
    os_dly_wait (dly);
  }    
}

/*----------------------------------------------------------------------------
 *        Task 'get_escape': check if ESC (escape character) was entered
 *---------------------------------------------------------------------------*/
__task void get_escape (void) {
  while (1) {                                 /* endless loop                */
    if (getkey () == ESC) {                   /* If ESC entered, set flag    */ 
      escape = 1;                             /* 'escape', set event flag of */
      os_evt_set (0x0002, t_command);         /* task 'command' and          */
    }
  }
}

/*----------------------------------------------------------------------------
 *        Task 'command': command processor
 *---------------------------------------------------------------------------*/
__task void command_task (void) {
  char cmdbuf [15];                           /* command input buffer        */
  int i;                                      /* index for command buffer    */
  int idx;                                    /* index for circular buffer   */

  clear_records ();                           /* initialize circular buffer  */
  printf (menu);                              /* display command menu        */
  while (1) {                                 /* loop forever                */
    printf ("\nCommand: ");                    
    getline (&cmdbuf[0], sizeof (cmdbuf));    /* input command line          */

    for (i = 0; cmdbuf[i] != 0; i++)  {       /* convert to upper characters */
      cmdbuf[i] = (char) toupper(cmdbuf[i]);
    }

    for (i = 0; cmdbuf[i] == ' '; i++) { ; }  /* skip blanks                 */

    switch (cmdbuf[i])  {                     /* proceed to command function */

      case 'R':                               /* Read circular Buffer        */
        if ((idx = read_index (&cmdbuf[i+1])) == WRONGINDEX)  break;

        t_getesc = os_tsk_create (get_escape,1);/* ESC check in display loop */
        escape = 0;                           /* clear escape flag           */

        while (idx != sindex)  {              /* check end of table          */
          if (escape) break;                  /* check if ESC key pressed    */  
          if (save_record[idx].time.hour != 0xff)  {
            measure_display (save_record[idx]);  /* display record           */
            printf ("\n");
          }
          if (++idx == SCNT) idx = 0;         /* next circular buffer entry  */
        }
        os_tsk_delete (t_getesc);             /* terminate 'get_escape' task.*/
        break;

      case 'T':                               /* Enter Current Time          */
        set_time (&cmdbuf[i+1]);
        break;

      case 'I':                               /* Enter Interval Time         */
        set_interval (&cmdbuf[i+1]);
        break;

      case 'D':                               /* Display Command             */
        printf ("\nDisplay current Measurements: (ESC to abort)\n");

        t_getesc = os_tsk_create (get_escape, 1);/* ESC check in display loop*/
        escape = 0;                           /* clear escape flag           */
        os_evt_clr (0x0003, t_command);       /* clear pending signals       */

        while (!escape)  {                    /* while no ESC entered        */
          os_evt_set (0x0001, t_measure);
          os_evt_wait_or (0x0003,0xffff);     /* wait for time change or ESC */
          measure_display (current);          /* display values              */
        }

        os_tsk_delete (t_getesc);             /* terminate 'get_escape' task.*/
        printf ("\n\n");
        break;

      case 'S':                               /* Start Command               */
        printf ("\nStart Measurement Recording\n");
        os_evt_set (0x0010, t_interval);      /* signal interval task to     */ 
        break;                                /* start measurement recording */

      case 'Q':                               /* Quit Command                */
        printf ("\nQuit Measurement Recording\n");
        startflag = 0;
        break;

      case 'C':                               /* Clear Command               */
        printf ("\nClear Measurement Records\n");
        clear_records ();
        break;

      default:                                /* Error Handling              */
        printf (ERROR, "UNKNOWN COMMAND");
        printf (menu);                        /* display command menu        */
        break;
    }
  }
}

/*----------------------------------------------------------------------------
 *        Task 'init': Initialize
 *---------------------------------------------------------------------------*/
__task void init_task (void) {

  PINSEL1 = 0x15400000;                       /* Select AIN0..AIN3           */
  IODIR1  = 0xFF0000;                         /* P1.16..23 defined as Outputs*/
  ADCR    = 0x002E0401;                       /* Setup A/D: 10-bit @ 3MHz    */

  serial_init ();                             /* init. the serial interface  */
  t_clock   = os_tsk_create (clock_task, 3);  /* start clock task            */
                                              /* start command task          */
  t_command = os_tsk_create_user (command_task, 1, &cmd_stack, sizeof(cmd_stack));
  t_measure = os_tsk_create (measure_task, 2);/* start measure task          */
  t_interval= os_tsk_create (interval_task,2);/* start interval task         */
  setinterval = 100;
  os_tsk_delete_self ();                      /* stop init task (done)       */
}

/*----------------------------------------------------------------------------
 *        Main: Initialize and start RTX Kernel
 *---------------------------------------------------------------------------*/
int main (void) {                             /* program exec. starts here   */
  os_sys_init_prio (init_task,50);            /* init and start task 'init'  */
}

/*----------------------------------------------------------------------------
 * end of file
 *---------------------------------------------------------------------------*/