PC.C
上传用户:zddz2006
上传日期:2020-12-03
资源大小:261k
文件大小:28k
源码类别:

中间件编程

开发平台:

Visual C++

  1. /*
  2. *********************************************************************************************************
  3. *                                          PC SUPPORT FUNCTIONS
  4. *
  5. *                          (c) Copyright 1992-2002, Jean J. Labrosse, Weston, FL
  6. *                                           All Rights Reserved
  7. *
  8. * File : PC.C
  9. * By   : Jean J. Labrosse
  10. *********************************************************************************************************
  11. */
  12. //change by cmj
  13. #include "config.h"
  14. //#include "includes.h"
  15. /*
  16. *********************************************************************************************************
  17. *                                               CONSTANTS
  18. *********************************************************************************************************
  19. */
  20. #define  DISP_BASE                  0xB800       /* Base segment of display (0xB800=VGA, 0xB000=Mono)  */
  21. #define  DISP_MAX_X                     80       /* Maximum number of columns                          */
  22. #define  DISP_MAX_Y                     25       /* Maximum number of rows                             */
  23. #define  TICK_T0_8254_CWR             0x43       /* 8254 PIT Control Word Register address.            */
  24. #define  TICK_T0_8254_CTR0            0x40       /* 8254 PIT Timer 0 Register address.                 */
  25. #define  TICK_T0_8254_CTR1            0x41       /* 8254 PIT Timer 1 Register address.                 */
  26. #define  TICK_T0_8254_CTR2            0x42       /* 8254 PIT Timer 2 Register address.                 */
  27. #define  TICK_T0_8254_CTR0_MODE3      0x36       /* 8254 PIT Binary Mode 3 for Counter 0 control word. */
  28. #define  TICK_T0_8254_CTR2_MODE0      0xB0       /* 8254 PIT Binary Mode 0 for Counter 2 control word. */
  29. #define  TICK_T0_8254_CTR2_LATCH      0x80       /* 8254 PIT Latch command control word                */
  30. #define  VECT_TICK                    0x08       /* Vector number for 82C54 timer tick                 */
  31. #define  VECT_DOS_CHAIN               0x81       /* Vector number used to chain DOS                    */
  32. /*
  33. *********************************************************************************************************
  34. *                                       LOCAL GLOBAL VARIABLES
  35. *********************************************************************************************************
  36. */
  37.              
  38. static INT16U    PC_ElapsedOverhead;
  39. //static jmp_buf   PC_JumpBuf;          //del by cmj 
  40. //static BOOLEAN   PC_ExitFlag;         //del by cmj
  41. //void           (*PC_TickISR)(void);   //del by cmj
  42. /*$PAGE*/
  43. /*
  44. *********************************************************************************************************
  45. *                           DISPLAY A SINGLE CHARACTER AT 'X' & 'Y' COORDINATE
  46. *
  47. * Description : This function writes a single character anywhere on the PC's screen.  This function
  48. *               writes directly to video RAM instead of using the BIOS for speed reasons.  It assumed 
  49. *               that the video adapter is VGA compatible.  Video RAM starts at absolute address 
  50. *               0x000B8000.  Each character on the screen is composed of two bytes: the ASCII character 
  51. *               to appear on the screen followed by a video attribute.  An attribute of 0x07 displays 
  52. *               the character in WHITE with a black background.
  53. *
  54. * Arguments   : x      corresponds to the desired column on the screen.  Valid columns numbers are from
  55. *                      0 to 79.  Column 0 corresponds to the leftmost column.
  56. *               y      corresponds to the desired row on the screen.  Valid row numbers are from 0 to 24.
  57. *                      Line 0 corresponds to the topmost row.
  58. *               c      Is the ASCII character to display.  You can also specify a character with a 
  59. *                      numeric value higher than 128.  In this case, special character based graphics
  60. *                      will be displayed.
  61. *               color  specifies the foreground/background color to use (see PC.H for available choices)
  62. *                      and whether the character will blink or not.
  63. *
  64. * Returns     : None
  65. *********************************************************************************************************
  66. */
  67.         void Uart_SendChar(INT8U data)
  68. {
  69.     while((U0LSR & 0x00000020) == 0);
  70.     U0THR = data;
  71. }
  72. //change by cmj
  73.         void PC_DispChar (INT8U x, INT8U y, INT8U c, INT8U color)
  74. {
  75.     //OS_ENTER_CRITICAL();
  76.     OSSchedLock();
  77.     
  78.     Uart_SendChar(0xff);
  79.     Uart_SendChar(x);
  80.     Uart_SendChar(y);
  81.     Uart_SendChar(c);
  82.     Uart_SendChar(color);
  83.   
  84.     //OS_EXIT_CRITICAL();
  85.     OSSchedUnlock();
  86. }
  87. //void PC_DispChar (INT8U x, INT8U y, INT8U c, INT8U color)
  88. //{
  89. //    INT8U  far *pscr;
  90. //    INT16U      offset;
  91. //    offset  = (INT16U)y * DISP_MAX_X * 2 + (INT16U)x * 2;  /* Calculate position on the screen         */
  92. //    pscr    = (INT8U far *)MK_FP(DISP_BASE, offset);
  93. //    *pscr++ = c;                                           /* Put character in video RAM               */
  94. //    *pscr   = color;                                       /* Put video attribute in video RAM         */
  95. //}
  96. /*$PAGE*/
  97. /*
  98. *********************************************************************************************************
  99. *                                            CLEAR A COLUMN
  100. *
  101. * Description : This function clears one of the 80 columns on the PC's screen by directly accessing video 
  102. *               RAM instead of using the BIOS.  It assumed that the video adapter is VGA compatible.  
  103. *               Video RAM starts at absolute address 0x000B8000.  Each character on the screen is 
  104. *               composed of two bytes: the ASCII character to appear on the screen followed by a video 
  105. *               attribute.  An attribute of 0x07 displays the character in WHITE with a black background.
  106. *
  107. * Arguments   : x            corresponds to the desired column to clear.  Valid column numbers are from 
  108. *                            0 to 79.  Column 0 corresponds to the leftmost column.
  109. *
  110. *               color        specifies the foreground/background color combination to use 
  111. *                            (see PC.H for available choices)
  112. *
  113. * Returns     : None
  114. *********************************************************************************************************
  115. */
  116. //change by cmj
  117.         void PC_DispClrCol (INT8U x, INT8U color)
  118. {
  119.     INT8U      i;
  120.     for (i = 0; i < DISP_MAX_Y; i++)
  121.     {
  122.         PC_DispChar(x, i, ' ', color);
  123.     }
  124. }
  125. //void PC_DispClrCol (INT8U x, INT8U color)
  126. //{
  127. //    INT8U far *pscr;
  128. //    INT8U      i;
  129. //    pscr = (INT8U far *)MK_FP(DISP_BASE, (INT16U)x * 2);
  130. //    for (i = 0; i < DISP_MAX_Y; i++) {
  131. //        *pscr++ = ' ';                           /* Put ' ' character in video RAM                     */
  132. //        *pscr-- = color;                         /* Put video attribute in video RAM                   */
  133. //        pscr    = pscr + DISP_MAX_X * 2;         /* Position on next row                               */
  134. //    }
  135. //}
  136. /*$PAGE*/
  137. /*
  138. *********************************************************************************************************
  139. *                                             CLEAR A ROW
  140. *
  141. * Description : This function clears one of the 25 lines on the PC's screen by directly accessing video 
  142. *               RAM instead of using the BIOS.  It assumed that the video adapter is VGA compatible.  
  143. *               Video RAM starts at absolute address 0x000B8000.  Each character on the screen is 
  144. *               composed of two bytes: the ASCII character to appear on the screen followed by a video 
  145. *               attribute.  An attribute of 0x07 displays the character in WHITE with a black background.
  146. *
  147. * Arguments   : y            corresponds to the desired row to clear.  Valid row numbers are from 
  148. *                            0 to 24.  Row 0 corresponds to the topmost line.
  149. *
  150. *               color        specifies the foreground/background color combination to use 
  151. *                            (see PC.H for available choices)
  152. *
  153. * Returns     : None
  154. *********************************************************************************************************
  155. */
  156. //change by cmj
  157.         void PC_DispClrRow (INT8U y, INT8U color)
  158. {
  159.     INT8U      i;
  160.     for (i = 0; i < DISP_MAX_X; i++)
  161.     {
  162.         PC_DispChar(i, y, ' ', color);
  163.     }
  164. }
  165. //void PC_DispClrRow (INT8U y, INT8U color)
  166. //{
  167. //    INT8U far *pscr;
  168. //    INT8U      i;
  169. //    pscr = (INT8U far *)MK_FP(DISP_BASE, (INT16U)y * DISP_MAX_X * 2);
  170. //    for (i = 0; i < DISP_MAX_X; i++) {
  171. //        *pscr++ = ' ';                           /* Put ' ' character in video RAM                     */
  172. //        *pscr++ = color;                         /* Put video attribute in video RAM                   */
  173. //    }
  174. //}
  175. /*$PAGE*/
  176. /*
  177. *********************************************************************************************************
  178. *                                              CLEAR SCREEN
  179. *
  180. * Description : This function clears the PC's screen by directly accessing video RAM instead of using
  181. *               the BIOS.  It assumed that the video adapter is VGA compatible.  Video RAM starts at
  182. *               absolute address 0x000B8000.  Each character on the screen is composed of two bytes:
  183. *               the ASCII character to appear on the screen followed by a video attribute.  An attribute
  184. *               of 0x07 displays the character in WHITE with a black background.
  185. *
  186. * Arguments   : color   specifies the foreground/background color combination to use 
  187. *                       (see PC.H for available choices)
  188. *
  189. * Returns     : None
  190. *********************************************************************************************************
  191. */
  192. //change by cmj
  193.         void PC_DispClrScr (INT8U color)
  194. {
  195.     INT16U      i,j;
  196.     for (i = 0; i < DISP_MAX_Y; i++)
  197.     {
  198.         for (j = 0; j < DISP_MAX_X; j++)
  199.         {
  200.             PC_DispChar(j, i, ' ', color);
  201.         }
  202.     }
  203. }
  204. //void PC_DispClrScr (INT8U color)
  205. //{
  206. //    INT8U  far *pscr;
  207. //    INT16U      i;
  208. //    pscr = (INT8U far *)MK_FP(DISP_BASE, 0x0000);
  209. //    for (i = 0; i < (DISP_MAX_X * DISP_MAX_Y); i++) { /* PC display has 80 columns and 25 lines        */
  210. //        *pscr++ = ' ';                                /* Put ' ' character in video RAM                */
  211. //        *pscr++ = color;                              /* Put video attribute in video RAM              */
  212. //    }
  213. //}
  214. /*$PAGE*/
  215. /*
  216. *********************************************************************************************************
  217. *                                 DISPLAY A STRING  AT 'X' & 'Y' COORDINATE
  218. *
  219. * Description : This function writes an ASCII string anywhere on the PC's screen.  This function writes
  220. *               directly to video RAM instead of using the BIOS for speed reasons.  It assumed that the 
  221. *               video adapter is VGA compatible.  Video RAM starts at absolute address 0x000B8000.  Each 
  222. *               character on the screen is composed of two bytes: the ASCII character to appear on the 
  223. *               screen followed by a video attribute.  An attribute of 0x07 displays the character in 
  224. *               WHITE with a black background.
  225. *
  226. * Arguments   : x      corresponds to the desired column on the screen.  Valid columns numbers are from
  227. *                      0 to 79.  Column 0 corresponds to the leftmost column.
  228. *               y      corresponds to the desired row on the screen.  Valid row numbers are from 0 to 24.
  229. *                      Line 0 corresponds to the topmost row.
  230. *               s      Is the ASCII string to display.  You can also specify a string containing 
  231. *                      characters with numeric values higher than 128.  In this case, special character 
  232. *                      based graphics will be displayed.
  233. *               color  specifies the foreground/background color to use (see PC.H for available choices)
  234. *                      and whether the characters will blink or not.
  235. *
  236. * Returns     : None
  237. *********************************************************************************************************
  238. */
  239. //change by cmj
  240.         void PC_DispStr (INT8U x, INT8U y, const char *s, INT8U color)
  241. {
  242.     while (*s)
  243.     {
  244.         if (x >= DISP_MAX_X)
  245.         {
  246.             x = 0;
  247.             y++;
  248.         }
  249.         PC_DispChar(x, y, *s++, color);
  250.         x++;
  251.     }
  252. }
  253. //void PC_DispStr (INT8U x, INT8U y, INT8U *s, INT8U color)
  254. //{
  255. //    INT8U  far *pscr;
  256. //    INT16U      offset;
  257. //    offset  = (INT16U)y * DISP_MAX_X * 2 + (INT16U)x * 2;   /* Calculate position of 1st character     */
  258. //    pscr    = (INT8U far *)MK_FP(DISP_BASE, offset);
  259. //    while (*s) {
  260. //        *pscr++ = *s++;                                     /* Put character in video RAM              */
  261. //        *pscr++ = color;                                    /* Put video attribute in video RAM        */
  262. //    }
  263. //}
  264. /*$PAGE*/
  265. /*
  266. *********************************************************************************************************
  267. *                                             RETURN TO DOS
  268. *
  269. * Description : This functions returns control back to DOS by doing a 'long jump' back to the saved
  270. *               location stored in 'PC_JumpBuf'.  The saved location was established by the function
  271. *               'PC_DOSSaveReturn()'.  After execution of the long jump, execution will resume at the 
  272. *               line following the 'set jump' back in 'PC_DOSSaveReturn()'.  Setting the flag 
  273. *               'PC_ExitFlag' to TRUE ensures that the 'if' statement in 'PC_DOSSaveReturn()' executes.
  274. *
  275. * Arguments   : None
  276. *
  277. * Returns     : None
  278. *********************************************************************************************************
  279. */
  280. //change by cmj
  281.         void PC_DOSReturn (void)
  282. {
  283.     Reset();
  284. }
  285. //void PC_DOSReturn (void)
  286. //{
  287. //    PC_ExitFlag = TRUE;                                    /* Indicate we are returning to DOS         */
  288. //    longjmp(PC_JumpBuf, 1);                                /* Jump back to saved environment           */
  289. //}
  290. /*$PAGE*/
  291. /*
  292. *********************************************************************************************************
  293. *                                        SAVE DOS RETURN LOCATION
  294. *
  295. * Description : This function saves the location of where we are in DOS so that it can be recovered.
  296. *               This allows us to abort multitasking under uC/OS-II and return back to DOS as if we had
  297. *               never left.  When this function is called by 'main()', it sets 'PC_ExitFlag' to FALSE
  298. *               so that we don't take the 'if' branch.  Instead, the CPU registers are saved in the
  299. *               long jump buffer 'PC_JumpBuf' and we simply return to the caller.  If a 'long jump' is
  300. *               performed using the jump buffer then, execution would resume at the 'if' statement and
  301. *               this time, if 'PC_ExitFlag' is set to TRUE then we would execute the 'if' statements and
  302. *               restore the DOS environment.
  303. *
  304. * Arguments   : None
  305. *
  306. * Returns     : None
  307. *********************************************************************************************************
  308. */
  309. void PC_DOSSaveReturn (void)
  310. {
  311. //change by cmj
  312. //#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  313. //    OS_CPU_SR  cpu_sr;
  314. //#endif    
  315. //    PC_ExitFlag  = FALSE;                                  /* Indicate that we are not exiting yet!    */
  316. //    OSTickDOSCtr =     1;                                  /* Initialize the DOS tick counter          */
  317. //    PC_TickISR   = PC_VectGet(VECT_TICK);                  /* Get MS-DOS's tick vector                 */
  318.     
  319. //    PC_VectSet(VECT_DOS_CHAIN, PC_TickISR);                /* Store MS-DOS's tick to chain             */
  320.     
  321. //    setjmp(PC_JumpBuf);                                    /* Capture where we are in DOS              */
  322. //    if (PC_ExitFlag == TRUE) {                             /* See if we are exiting back to DOS        */
  323. //        OS_ENTER_CRITICAL();
  324. //        PC_SetTickRate(18);                                /* Restore tick rate to 18.2 Hz             */
  325. //        OS_EXIT_CRITICAL();
  326. //        PC_VectSet(VECT_TICK, PC_TickISR);                 /* Restore DOS's tick vector                */
  327. //        PC_DispClrScr(DISP_FGND_WHITE + DISP_BGND_BLACK);  /* Clear the display                        */
  328. //        exit(0);                                           /* Return to DOS                            */
  329. //    }
  330. }
  331. /*$PAGE*/
  332. /*
  333. *********************************************************************************************************
  334. *                                       ELAPSED TIME INITIALIZATION
  335. *
  336. * Description : This function initialize the elapsed time module by determining how long the START and
  337. *               STOP functions take to execute.  In other words, this function calibrates this module
  338. *               to account for the processing time of the START and STOP functions.
  339. *
  340. * Arguments   : None.
  341. *
  342. * Returns     : None.
  343. *********************************************************************************************************
  344. */
  345. void PC_ElapsedInit(void)
  346. {
  347.     PC_ElapsedOverhead = 0;
  348.     PC_ElapsedStart();
  349.     PC_ElapsedOverhead = PC_ElapsedStop();
  350. }
  351. /*$PAGE*/
  352. /*
  353. *********************************************************************************************************
  354. *                                         INITIALIZE PC'S TIMER #2
  355. *
  356. * Description : This function initialize the PC's Timer #2 to be used to measure the time between events.
  357. *               Timer #2 will be running when the function returns.
  358. *
  359. * Arguments   : None.
  360. *
  361. * Returns     : None.
  362. *********************************************************************************************************
  363. */
  364. //change by cmj
  365.         void PC_ElapsedStart(void)
  366. {
  367.     PC_ElapsedOverhead = T0TC;
  368. }
  369. //void PC_ElapsedStart(void)
  370. //{
  371. //#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  372. //    OS_CPU_SR  cpu_sr;
  373. //#endif    
  374. //    INT8U      data;
  375. //    OS_ENTER_CRITICAL();
  376. //    data  = (INT8U)inp(0x61);                              /* Disable timer #2                         */
  377. //    data &= 0xFE;
  378. //    outp(0x61, data);
  379. //    outp(TICK_T0_8254_CWR,  TICK_T0_8254_CTR2_MODE0);      /* Program timer #2 for Mode 0              */
  380. //    outp(TICK_T0_8254_CTR2, 0xFF);
  381. //    outp(TICK_T0_8254_CTR2, 0xFF);
  382. //    data |= 0x01;                                          /* Start the timer                          */
  383. //    outp(0x61, data);
  384. //    OS_EXIT_CRITICAL();
  385. //}
  386. /*$PAGE*/
  387. /*
  388. *********************************************************************************************************
  389. *                                 STOP THE PC'S TIMER #2 AND GET ELAPSED TIME
  390. *
  391. * Description : This function stops the PC's Timer #2, obtains the elapsed counts from when it was
  392. *               started and converts the elapsed counts to micro-seconds.
  393. *
  394. * Arguments   : None.
  395. *
  396. * Returns     : The number of micro-seconds since the timer was last started.
  397. *
  398. * Notes       : - The returned time accounts for the processing time of the START and STOP functions.
  399. *               - 54926 represents 54926S-16 or, 0.838097 which is used to convert timer counts to
  400. *                 micro-seconds.  The clock source for the PC's timer #2 is 1.19318 MHz (or 0.838097 uS)
  401. *********************************************************************************************************
  402. */
  403. //change by cmj
  404.         INT16U PC_ElapsedStop(void)
  405. {
  406.     return ((T0TC - PC_ElapsedOverhead) / (Fpclk / 1000000));
  407. }
  408. //INT16U PC_ElapsedStop(void)
  409. //{
  410. //#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  411. //    OS_CPU_SR  cpu_sr;
  412. //#endif    
  413. //    INT8U      data;
  414. //    INT8U      low;
  415. //    INT8U      high;
  416. //    INT16U     cnts;
  417. //    OS_ENTER_CRITICAL();
  418. //    data  = (INT8U)inp(0x61);                                    /* Disable the timer                  */
  419. //    data &= 0xFE;
  420. //    outp(0x61, data);
  421. //    outp(TICK_T0_8254_CWR, TICK_T0_8254_CTR2_LATCH);             /* Latch the timer value              */
  422. //    low  = inp(TICK_T0_8254_CTR2);
  423. //    high = inp(TICK_T0_8254_CTR2);
  424. //    cnts = (INT16U)0xFFFF - (((INT16U)high << 8) + (INT16U)low); /* Compute time it took for operation */
  425. //    OS_EXIT_CRITICAL();
  426. //    return ((INT16U)((INT32U)cnts * 54926L >> 16) - PC_ElapsedOverhead);
  427. //}
  428. /*$PAGE*/
  429. /*
  430. *********************************************************************************************************
  431. *                                       GET THE CURRENT DATE AND TIME
  432. *
  433. * Description: This function obtains the current date and time from the PC.
  434. *
  435. * Arguments  : s     is a pointer to where the ASCII string of the current date and time will be stored.
  436. *                    You must allocate at least 21 bytes (includes the NUL) of storage in the return 
  437. *                    string.  The date and time will be formatted as follows:
  438. *
  439. *                        "YYYY-MM-DD  HH:MM:SS"
  440. *
  441. * Returns    : none
  442. *********************************************************************************************************
  443. */
  444. //change by cmj
  445.         void PC_GetDateTime (char *s)
  446. {
  447.     INT32U da_year,da_mon,da_day,ti_hour,ti_min,ti_sec;
  448.     
  449.     ti_sec = SEC;
  450.     ti_min = MIN;
  451.     ti_hour = HOUR;
  452.     da_day = DOM;
  453.     da_mon = MONTH;
  454.     da_year = YEAR;
  455.     sprintf(s, "%04d-%02d-%02d  %02d:%02d:%02d",
  456.                da_year,da_mon,da_day,ti_hour,ti_min,ti_sec);
  457. }
  458. //void PC_GetDateTime (char *s)
  459. //{
  460. //    struct time now;
  461. //    struct date today;
  462. //    gettime(&now);
  463. //    getdate(&today);
  464. //    sprintf(s, "%04d-%02d-%02d  %02d:%02d:%02d",
  465. //               today.da_year,
  466. //               today.da_mon,
  467. //               today.da_day,
  468. //               now.ti_hour,
  469. //               now.ti_min,
  470. //               now.ti_sec);
  471. //}
  472. /*$PAGE*/
  473. /*
  474. *********************************************************************************************************
  475. *                                        CHECK AND GET KEYBOARD KEY
  476. *
  477. * Description: This function checks to see if a key has been pressed at the keyboard and returns TRUE if
  478. *              so.  Also, if a key is pressed, the key is read and copied where the argument is pointing
  479. *              to.
  480. *
  481. * Arguments  : c     is a pointer to where the read key will be stored.
  482. *
  483. * Returns    : TRUE  if a key was pressed
  484. *              FALSE otherwise
  485. *********************************************************************************************************
  486. */
  487. //change by cmj
  488.     BOOLEAN PC_GetKey (INT16S *c)
  489. {
  490.     if ((U0LSR & 0x00000001) != 0)
  491.     {
  492.         *c = U0RBR;
  493.         return (TRUE);
  494.     }
  495.     else
  496.     {
  497.         *c = 0x00;
  498.         return (FALSE);
  499.     }
  500. }
  501. //BOOLEAN PC_GetKey (INT16S *c)
  502. //{
  503. //    if (kbhit()) {                                         /* See if a key has been pressed            */
  504. //        *c = (INT16S)getch();                              /* Get key pressed                          */
  505. //        return (TRUE);
  506. //    } else {
  507. //        *c = 0x00;                                         /* No key pressed                           */
  508. //        return (FALSE);
  509. //    }
  510. //}
  511. /*$PAGE*/
  512. /*
  513. *********************************************************************************************************
  514. *                                      SET THE PC'S TICK FREQUENCY
  515. *
  516. * Description: This function is called to change the tick rate of a PC.
  517. *
  518. * Arguments  : freq      is the desired frequency of the ticker (in Hz)
  519. *
  520. * Returns    : none
  521. *
  522. * Notes      : 1) The magic number 2386360 is actually twice the input frequency of the 8254 chip which
  523. *                 is always 1.193180 MHz.
  524. *              2) The equation computes the counts needed to load into the 8254.  The strange equation
  525. *                 is actually used to round the number using integer arithmetic.  This is equivalent to
  526. *                 the floating point equation:
  527. *
  528. *                             1193180.0 Hz
  529. *                     count = ------------ + 0.5
  530. *                                 freq
  531. *********************************************************************************************************
  532. */
  533. //del by cmj
  534. //void PC_SetTickRate (INT16U freq)
  535. //{
  536. //#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  537. //    OS_CPU_SR  cpu_sr;
  538. //#endif    
  539. //    INT16U     count;
  540. //    if (freq == 18) {                            /* See if we need to restore the DOS frequency        */
  541. //        count = 0;
  542. //    } else if (freq > 0) {                        
  543.                                                  /* Compute 8254 counts for desired frequency and ...  */
  544.                                                  /* ... round to nearest count                         */
  545. //        count = (INT16U)(((INT32U)2386360L / freq + 1) >> 1); 
  546. //    } else {
  547. //        count = 0;
  548. //    }
  549. //    OS_ENTER_CRITICAL();
  550. //    outp(TICK_T0_8254_CWR,  TICK_T0_8254_CTR0_MODE3); /* Load the 8254 with desired frequency          */  
  551. //    outp(TICK_T0_8254_CTR0, count & 0xFF);            /* Low  byte                                     */
  552. //    outp(TICK_T0_8254_CTR0, (count >> 8) & 0xFF);     /* High byte                                     */
  553. //    OS_EXIT_CRITICAL();
  554. //}
  555. /*$PAGE*/
  556. /*
  557. *********************************************************************************************************
  558. *                                        OBTAIN INTERRUPT VECTOR
  559. *
  560. * Description: This function reads the pointer stored at the specified vector.
  561. *
  562. * Arguments  : vect  is the desired interrupt vector number, a number between 0 and 255.
  563. *
  564. * Returns    : The address of the Interrupt handler stored at the desired vector location.
  565. *********************************************************************************************************
  566. */
  567. //del by cmj
  568. //void *PC_VectGet (INT8U vect)
  569. //{
  570. //#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  571. //    OS_CPU_SR  cpu_sr;
  572. //#endif    
  573. //    INT16U    *pvect;
  574. //    INT16U     off;
  575. //    INT16U     seg;
  576.     
  577.     
  578. //    pvect = (INT16U *)MK_FP(0x0000, vect * 4);        /* Point into IVT at desired vector location     */
  579. //    OS_ENTER_CRITICAL();
  580. //    off   = *pvect++;                                 /* Obtain the vector's OFFSET                    */
  581. //    seg   = *pvect;                                   /* Obtain the vector's SEGMENT                   */
  582. //    OS_EXIT_CRITICAL();
  583. //    return (MK_FP(seg, off));
  584. //}
  585. /*
  586. *********************************************************************************************************
  587. *                                        INSTALL INTERRUPT VECTOR
  588. *
  589. * Description: This function sets an interrupt vector in the interrupt vector table.
  590. *
  591. * Arguments  : vect  is the desired interrupt vector number, a number between 0 and 255.
  592. *              isr   is a pointer to a function to execute when the interrupt or exception occurs.
  593. *
  594. * Returns    : none
  595. *********************************************************************************************************
  596. */
  597. //del by cmj
  598. //void PC_VectSet (INT8U vect, void (*isr)(void))
  599. //{
  600. //#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
  601. //    OS_CPU_SR  cpu_sr;
  602. //#endif    
  603. //    INT16U    *pvect;
  604.     
  605.     
  606. //    pvect    = (INT16U *)MK_FP(0x0000, vect * 4);     /* Point into IVT at desired vector location     */
  607. //    OS_ENTER_CRITICAL();
  608. //    *pvect++ = (INT16U)FP_OFF(isr);                   /* Store ISR offset                              */
  609. //    *pvect   = (INT16U)FP_SEG(isr);                   /* Store ISR segment                             */
  610. //    OS_EXIT_CRITICAL();
  611. //}
  612. //add by cmj
  613.         INT8U random(INT8U seed)
  614. {
  615.     uint16 temp;
  616.     temp = rand();
  617.     temp = temp % seed;
  618. return temp;
  619. }
  620. /*********************************************************************************************************
  621. **                            End Of File
  622. ********************************************************************************************************/