找回密碼
 立即注冊(cè)

QQ登錄

只需一步，快速開(kāi)始

搜索
查看: 2674|回復(fù): 4
收起左側(cè)

說(shuō)說(shuō)KEIL自帶RTX-51單片機(jī)操作系統(tǒng)例程 Traffic

[復(fù)制鏈接]
ID:140644 發(fā)表于 2022-3-15 06:09 | 顯示全部樓層 |閱讀模式
51單片機(jī)的容量越來(lái)越大，感覺(jué)RTX-51在小型工程上還是比較適用的,
特別是現(xiàn)在STC新出了51版32位芯片，內(nèi)部FLASH更大了,
懂了RTX-51再進(jìn)一步學(xué)習(xí)FreeRTOS就有基礎(chǔ)了。
但是好像網(wǎng)上很少有RTX-51例程和交流的。
無(wú)意發(fā)現(xiàn)一個(gè)KEIL 自帶RTX-51操作系統(tǒng)例程。
感覺(jué)可以試試。
編譯結(jié)果顯示
Build target 'Demo - Simulator'
compiling TRAFFIC.C...
compiling SERIAL.C...
compiling GETLINE.C...
assembling Conf_tny.A51...
assembling START900.A51...
linking...
Program Size: data=124.1 xdata=0 code=5469
creating hex file from "traffic"...
"traffic" - 0 Error(s), 0 Warning(s).

那么問(wèn)題來(lái)了,編譯的代碼長(zhǎng)度   Size: data=124.1 xdata=0 code=5469
打開(kāi)STC的ISP下載軟件，說(shuō)文件大小超出程序區(qū)范圍，超出部分自動(dòng)移到EEPROM區(qū)。
是什么意思呢？

我把代碼燒寫(xiě)到STC芯片,板子可以運(yùn)行，有興趣的一起聊聊唄

compling.png
單片機(jī)源程序如下:
  1. /******************************************************************************/
  2. /*                                                                            */
  3. /*   TRAFFIC.C:  Traffic Light Controller using the C-51 COMPILER             */
  4. /*                                                                            */
  5. /******************************************************************************/

  7. char code menu[] =
  8.    "\n"
  9.    "+***** TRAFFIC LIGHT CONTROLLER using C51 and RTX-51 tiny *****+\n"
  10.    "| This program is a simple Traffic Light Controller.  Between  |\n"
  11.    "| start time and end time the system controls a traffic light  |\n"
  12.    "| with pedestrian self-service.  Outside of this time range    |\n"
  13.    "| the yellow caution lamp is blinking.                         |\n"
  14.    "+ command -+ syntax -----+ function ---------------------------+\n"
  15.    "| Display  | D           | display times                       |\n"
  16.    "| Time     | T hh:mm:ss  | set clock time                      |\n"
  17.    "| Start    | S hh:mm:ss  | set start time                      |\n"
  18.    "| End      | E hh:mm:ss  | set end time                        |\n"
  19.    "+----------+-------------+-------------------------------------+\n";

  21. #include <REG52.H>                   /* special function registers 8052      */
  22. #include <rtx51tny.h>                 /* RTX-51 tiny functions & defines      */
  23. #include <stdio.h>                    /* standard I/O .h-file                 */
  24. #include <ctype.h>                    /* character functions                  */
  25. #include <string.h>                   /* string and memory functions          */

  27. #include "traffic.h"                  /* project specific header file         */

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

  33. sbit  red    = P2^6;                  /* I/O Pin:  red    lamp output         */
  34. sbit  yellow = P2^7;                  /* I/O Pin:  yellow lamp output         */
  35. sbit  green  = P1^0;                  /* I/O Pin:  green  lamp output         */
  36. sbit  stop   = P1^1;                  /* I/O Pin:  stop   lamp output         */
  37. sbit  walk   = P1^2;                  /* I/O Pin:  walk   lamp output         */
  38. sbit  key    = P3^2;                  /* I/O Pin:  self-service key input     */

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


  43. /******************************************************************************/
  44. /*        Task 0 'init': Initialize                                           */
  45. /******************************************************************************/
  46. void init (void) _task_ INIT  {       /* program execution starts here        */
  47.   serial_init ();                     /* initialize the serial interface      */
  48.                                       /* configure I/O port                   */
  49.   P2M1 = 0x1F;                        /* P2.0-P.2.4 output, P2.5-P2.7 input   */

  51.   os_create_task (CLOCK);             /* start clock task                     */
  52.   os_create_task (COMMAND);           /* start command task                   */
  53.   os_create_task (LIGHTS);            /* start lights task                    */
  54.   os_create_task (KEYREAD);           /* start keyread task                   */
  55.   os_delete_task (INIT);              /* stop init task (no longer needed)    */
  56. }


  59. bit display_time = 0;                 /* flag:  signal cmd state display_time */

  61. /******************************************************************************/
  62. /*        Task 2 'clock'                                                      */
  63. /******************************************************************************/
  64. void clock (void)  _task_ CLOCK  {
  65.   while (1)  {                        /* clock is an endless loop             */
  66.     if (++ctime.sec == 60)  {         /* calculate the second                 */
  67.       ctime.sec = 0;
  68.       if (++ctime.min == 60)  {       /* calculate the minute                 */
  69.         ctime.min = 0;
  70.         if (++ctime.hour == 24)  {    /* calculate the hour                   */
  71.           ctime.hour = 0;
  72.         }
  73.       }
  74.     }
  75.     if (display_time)  {              /* if command_status == display_time    */
  76.       os_send_signal (COMMAND);       /* signal to task command: time changed */
  77.     }
  78.     os_wait (K_IVL, 100, 0);          /* wait interval:  1 second             */
  79.   }
  80. }


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

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

  91.   rtime.sec = 0;                               /* preset second               */
  92.   args = sscanf (buffer, "%bd:%bd:%bd",        /* scan input line for         */
  93.                  &rtime.hour,                  /* hour, minute and second     */
  94.                  &rtime.min,
  95.                  &rtime.sec);
  96.   
  97.   if (rtime.hour > 23  ||  rtime.min > 59  ||  /* check for valid inputs      */
  98.       rtime.sec > 59   ||  args < 2        ||  args == EOF)  {
  99.     printf ("\n*** ERROR: INVALID TIME FORMAT\n");
  100.     return (0);
  101.   }
  102.   return (1);
  103. }



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

  109. static bit   escape;                  /* flag: mark ESCAPE character entered  */

  111. /******************************************************************************/
  112. /*        Task 6 'get_escape': check if ESC (escape character) was entered    */
  113. /******************************************************************************/
  114. void get_escape (void) _task_ GET_ESC  {
  115.   while (1)  {                                 /* endless loop                */
  116.     if (_getkey () == ESC)  escape = 1;        /* set flag if ESC entered     */
  117.     if (escape)  {                             /* if escape flag send signal  */
  118.       os_send_signal (COMMAND);                /* to task 'command'           */
  119.     }
  120.   }
  121. }


  124. /******************************************************************************/
  125. /*        Task 1 'command': command processor */
  126. /******************************************************************************/
  127. void command (void) _task_ COMMAND  {
  128.   unsigned char i;

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

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

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

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

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

  154.         while (!escape)  {                     /* while no ESC entered        */
  155.           printf ("Clock Time: %02bd:%02bd:%02bd\r",      /* display time     */
  156.                    ctime.hour, ctime.min, ctime.sec);
  157.           os_wait (K_SIG, 0, 0);               /* wait for time change or ESC */
  158.         }

  160.         os_delete_task (GET_ESC);              /* ESC check not longer needed */
  161.         display_time = 0;                      /* clear display time flag     */
  162.         printf ("\n\n");
  163.         break;

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

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

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

  189.       default:                                 /* Error Handling              */
  190.         printf (menu);                         /* display command menu        */
  191.         break;
  192.     }   
  193.   }
  194. }


  197. /******************************************************************************/
  198. /*        signalon: check if clock time is between start and end              */
  199. /******************************************************************************/
  200. static bit signalon (void)   {
  201.   if (memcmp (&start, &end, sizeof (struct time)) < 0)  {
  202.     if (memcmp (&start, &ctime, sizeof (struct time)) < 0  &&
  203.         memcmp (&ctime, &end,   sizeof (struct time)) < 0)  return (1);
  204.   }
  205.                                                 
  206.   else  {
  207.     if (memcmp (&end,   &ctime, sizeof (start)) > 0  &&
  208.         memcmp (&ctime, &start, sizeof (start)) > 0)  return (1);
  209.   }
  210.   return (0);                                  /* signal off, blinking on     */
  211. }


  214. /******************************************************************************/
  215. /*        Task 3 'blinking': runs if current time is outside start & end time */
  216. /******************************************************************************/
  217. void blinking (void) _task_ BLINKING  {        /* blink yellow light          */
  218.   red    = 0;                                  /* all lights off              */
  219.   yellow = 0;
  220.   green  = 0;
  221.   stop   = 0;
  222.   walk   = 0;

  224.   while (1)  {                                 /* endless loop                */
  225.     yellow = 1;                                /* yellow light on             */
  226.     os_wait (K_TMO, 150, 0);                   /* wait for timeout: 150 ticks  */
  227.     yellow = 0;                                /* yellow light off            */
  228.     os_wait (K_TMO, 150, 0);                   /* wait for timeout: 150 ticks  */
  229.     if (signalon ())  {                        /* if blinking time over       */
  230.       os_create_task (LIGHTS);                 /* start lights                */
  231.       os_delete_task (BLINKING);               /* and stop blinking           */
  232.     }
  233.   }
  234. }


  237. /******************************************************************************/
  238. /*      Task 4 'lights': executes if current time is between start & end time */
  239. /******************************************************************************/
  240. void lights (void) _task_ LIGHTS  {            /* traffic light operation     */
  241.   red    = 1;                                  /* red & stop lights on        */
  242.   yellow = 0;
  243.   green  = 0;
  244.   stop   = 1;
  245.   walk   = 0;
  246.   while (1)  {                                 /* endless loop                */
  247.     os_wait (K_TMO, 150, 0);                   /* wait for timeout: 150 ticks */
  248.     if (!signalon ())  {                       /* if traffic signal time over */
  249.       os_create_task (BLINKING);               /* start blinking              */
  250.       os_delete_task (LIGHTS);                 /* stop lights                 */
  251.     }
  252.     yellow = 1;
  253.     os_wait (K_TMO, 150, 0);                   /* wait for timeout: 150 ticks */
  254.     red    = 0;                                /* green light for cars        */
  255.     yellow = 0;
  256.     green  = 1;
  257.     os_clear_signal (LIGHTS);
  258.     os_wait (K_TMO, 200, 0);                   /* wait for timeout: 200 ticks */
  259.     os_wait (K_TMO + K_SIG, 250, 0);           /* wait for timeout & signal   */
  260.     yellow = 1;
  261.     green  = 0;
  262.     os_wait (K_TMO, 150, 0);                   /* wait for timeout: 150 ticks */
  263.     red    = 1;                                /* red light for cars          */
  264.     yellow = 0;
  265.     os_wait (K_TMO, 150, 0);                   /* wait for timeout: 150 ticks */
  266.     stop   = 0;                                /* green light for walkers     */   
  267.     walk   = 1;
  268.     os_wait (K_TMO, 250, 0);                   /* wait for timeout: 250 ticks */
  269.     os_wait (K_TMO, 250, 0);                   /* wait for timeout: 250 ticks */
  270.     stop   = 1;                                /* red light for walkers       */        
  271.     walk   = 0;
  272.   }
  273. }


  276. /******************************************************************************/
  277. /*        Task 5 'keyread': process key stroke from pedestrian push button    */
  278. /******************************************************************************/
  279. void keyread (void) _task_ KEYREAD  {
  280.   while (1)  {                                 /* endless loop                */
  281.     if (key)  {                                /* if key pressed              */
  282.       os_send_signal (LIGHTS);                 /* send signal to task lights  */
  283.     }
  284.     os_wait (K_TMO, 2, 0);                     /* wait for timeout: 2 ticks   */
  285.   }
  286. }
復(fù)制代碼
51hei.png

Keil代碼下載: Traffic.rar (104.48 KB, 下載次數(shù): 12)

評(píng)分

參與人數(shù) 1黑幣 +80 收起 理由
admin + 80 共享資料的黑幣獎(jiǎng)勵(lì)！

查看全部評(píng)分

回復(fù)

使用道具 舉報(bào)

ID:301191 發(fā)表于 2022-3-15 23:49 | 顯示全部樓層
頂一下
回復(fù)

使用道具 舉報(bào)

ID:301191 發(fā)表于 2022-3-17 17:47 | 顯示全部樓層
頂一下
回復(fù)

使用道具 舉報(bào)

ID:409831 發(fā)表于 2022-4-7 09:02 | 顯示全部樓層
8位機(jī)也能跑系統(tǒng)那確實(shí)美了
回復(fù)

使用道具 舉報(bào)

ID:879348 發(fā)表于 2022-4-7 11:40 | 顯示全部樓層
但是核心沒(méi)有開(kāi)源，一旦不用keil就用不了
回復(fù)

使用道具 舉報(bào)

本版積分規(guī)則

小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術(shù)交流QQ群281945664

Powered by 單片機(jī)教程網(wǎng)

快速回復(fù) 返回頂部 返回列表