www.pudn.com > test_megbox_vc.rar > pc.c, change:2005-05-06,size:15256b


/* 
   ********************************************************************************************************* 
   * 
   *                                          PC SUPPORT FUNCTIONS for WIN32 
   * 
   *                          (c) Copyright 2004-2005, Werner.Zimmermann@fht-esslingen.de 
   *                      (Functions similar to the 80x86 Real Mode port by Jean J. Labrosse) 
   *                                           All Rights Reserved 
   * 
   * File : PC.C 
   * By   : Werner Zimmermann 
   ********************************************************************************************************* 
 */ 
 
#include "includes.h" 
 
BOOLEAN lock=FALSE; 
HANDLE  hStdOut = NULL; 
extern void (*interruptTable[])(); 
 
/* 
   ********************************************************************************************************* 
   *                                        CHECK AND GET KEYBOARD KEY 
   * 
   * Description: This function checks to see if a key has been pressed at the keyboard and returns TRUE if 
   *              so.  Also, if a key is pressed, the key is read and copied where the argument is pointing 
   *              to. 
   * 
   * Arguments  : c     is a pointer to where the read key will be stored. 
   * 
   * Returns    : TRUE  if a key was pressed 
   *              FALSE otherwise 
   ********************************************************************************************************* 
 */ 
BOOLEAN PC_GetKey(INT16S *c) 
{    
  if (PC_CHECK_RECURSIVE_CALLS && lock)			// Check and avoid recursive calls 
   {   MessageBox(NULL, "Recursive call in PC_GetKey", "ucos-II", MB_OK); 
       exit(-1); 
   } else if (lock) 
    {	return FALSE; 
   } else 
    {   lock = TRUE; 
    } 
     
    if (kbhit())						// See if a key has been pressed 
    {   *c = getch();	                                	// Get key pressed 
        lock = FALSE; 
    
        return (TRUE); 
    } else 
    {   *c = 0x00;                                              // No key pressed 
        lock = FALSE; 
        return (FALSE); 
    } 
} 
 
/* 
   ********************************************************************************************************* 
   *                                 DISPLAY A STRING  AT 'X' & 'Y' COORDINATE 
   * 
   * Description : This function writes an ASCII string anywhere on the PC's screen.  This function writes 
   *               directly to video RAM instead of using the BIOS for speed reasons.  It assumed that the 
   *               video adapter is VGA compatible.  Video RAM starts at absolute address 0x000B8000.  Each 
   *               character on the screen is composed of two bytes: the ASCII character to appear on the 
   *               screen followed by a video attribute.  An attribute of 0x07 displays the character in 
   *               WHITE with a black background. 
   * 
   * Arguments   : x      corresponds to the desired column on the screen.  Valid columns numbers are from 
   *                      0 to 79.  Column 0 corresponds to the leftmost column. 
   *               y      corresponds to the desired row on the screen.  Valid row numbers are from 0 to 24. 
   *                      Line 0 corresponds to the topmost row. 
   *               s      Is the ASCII string to display.  You can also specify a string containing 
   *                      characters with numeric values higher than 128.  In this case, special character 
   *                      based graphics will be displayed. 
   *               color  specifies the foreground/background color to use (see PC.H for available choices) 
   * 
   * Returns     : None 
   ********************************************************************************************************* 
 */ 
void PC_DispStr(INT8U x, INT8U y, INT8U * s, INT8U color) 
{   COORD pos; 
 
#ifdef DEBUG_PC 
    _log("PC_DispStr: \n"); 
	_log(s);//printf("PC_DispStr: %s\n", s); 
	_log("\n"); 
    return; 
#endif 
 
    if (PC_CHECK_RECURSIVE_CALLS && lock)			// Check and avoid recursive calls 
    {   MessageBox(NULL, "Recursive call in PC_DispStr", "ucos-II", MB_OK); 
        exit(-1); 
    } else if (lock) 
    {	return; 
    } else 
    {   lock = TRUE; 
    } 
 
    if (hStdOut==NULL)						// Get the handle for the standard output 
        hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); 
 
    if ((x>79) || (y>24))					// Check for valid cursor position 
        MessageBox(NULL, "Invalid screen position in PC_DispStr()", "ucos-II", MB_OK); 
 
    pos.X = x;							// Set cursor position 
    pos.Y = y; 
    SetConsoleCursorPosition(hStdOut, pos); 
 
    SetConsoleTextAttribute(hStdOut, color);			// Set text color 
    puts(s);							// Display text string 
    lock = FALSE; 
} 
 
/* 
   ********************************************************************************************************* 
   *                           DISPLAY A SINGLE CHARACTER AT 'X' & 'Y' COORDINATE 
   * 
   * Description : This function writes a single character anywhere on the PC's screen.  This function 
   *               writes directly to video RAM instead of using the BIOS for speed reasons.  It assumed 
   *               that the video adapter is VGA compatible.  Video RAM starts at absolute address 
   *               0x000B8000.  Each character on the screen is composed of two bytes: the ASCII character 
   *               to appear on the screen followed by a video attribute.  An attribute of 0x07 displays 
   *               the character in WHITE with a black background. 
   * 
   * Arguments   : x      corresponds to the desired column on the screen.  Valid columns numbers are from 
   *                      0 to 79.  Column 0 corresponds to the leftmost column. 
   *               y      corresponds to the desired row on the screen.  Valid row numbers are from 0 to 24. 
   *                      Line 0 corresponds to the topmost row. 
   *               c      Is the ASCII character to display.  You can also specify a character with a 
   *                      numeric value higher than 128.  In this case, special character based graphics 
   *                      will be displayed. 
   *               color  specifies the foreground/background color to use (see PC.H for available choices) 
   * 
   * Returns     : None 
   ********************************************************************************************************* 
 */ 
void PC_DispChar(INT8U x, INT8U y, INT8U c, INT8U color) 
{   COORD pos; 
 
#ifdef DEBUG_PC 
    _log("PC_DispChar: \n"); 
	_log(s);//printf("PC_DispStr: %s\n", s); 
	_log("\n"); 
    return; 
#endif 
 
    if (PC_CHECK_RECURSIVE_CALLS && lock)			// Check and avoid recursive calls 
    {   MessageBox(NULL, "Recursive call in PC_DispChar", "ucos-II", MB_OK); 
        exit(-1); 
    } else if (lock) 
    {	return; 
    } else 
    {   lock = TRUE; 
    } 
 
    if (hStdOut==NULL)						// Get the handle for the standard output 
        hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); 
 
    if ((x>79) || (y>24))					// Check for valid cursor position 
        MessageBox(NULL, "Invalid screen position in PC_DispChar()", "ucos-II", MB_OK); 
 
    pos.X = x;							// Set cursor position 
    pos.Y = y; 
    SetConsoleCursorPosition(hStdOut, pos); 
    SetConsoleTextAttribute(hStdOut, color);			// Set text color 
    putchar(c);							// Display character 
    lock = FALSE; 
} 
 
 
/* 
   ********************************************************************************************************* 
   *                                              CLEAR SCREEN 
   * 
   * Description : This function clears the PC's screen by directly accessing video RAM instead of using 
   *               the BIOS.  It assumed that the video adapter is VGA compatible.  Video RAM starts at 
   *               absolute address 0x000B8000.  Each character on the screen is composed of two bytes: 
   *               the ASCII character to appear on the screen followed by a video attribute.  An attribute 
   *               of 0x07 displays the character in WHITE with a black background. 
   * 
   * Arguments   : color   specifies the foreground/background color combination to use 
   *                       (see PC.H for available choices) 
   * 
   * Returns     : None 
   ********************************************************************************************************* 
 */ 
void PC_DispClrScr(INT8U color) 
{   COORD pos; 
 
#ifdef DEBUG_PC 
    _log("PC_DispClrScr\n"); 
    return; 
#endif 
 
    if (PC_CHECK_RECURSIVE_CALLS && lock)			// Check and avoid recursive calls 
    {   MessageBox(NULL, "Recursive call in PC_DispClrScr", "ucos-II", MB_OK); 
        exit(-1); 
    } else if (lock) 
    {	return; 
    } else 
    {   lock = TRUE; 
    } 
 
    if (hStdOut==NULL)						// Get the handle for the standard output 
        hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); 
 
    pos.X = 0; 
    pos.Y = 0; 
    SetConsoleCursorPosition(hStdOut, pos);			// Set cursor position to top of window 
    SetConsoleTextAttribute(hStdOut, color);			// Set text color 
 
    system("cls");						// Clear the screen 
 
    lock = FALSE; 
} 
 
/* 
   ********************************************************************************************************* 
   *                                       ELAPSED TIME INITIALIZATION 
   * 
   * Description : This function initialize the elapsed time module by determining how long the START and 
   *               STOP functions take to execute.  In other words, this function calibrates this module 
   *               to account for the processing time of the START and STOP functions. 
   *               Needs to be called only once before any of the timers is started with PC_ElapsedStart(). 
   * 
   * Arguments   : None. 
   * 
   * Returns     : None. 
   ********************************************************************************************************* 
 */ 
#define NTIMERS 16 
static INT16U PC_ElapsedOverhead=0; 
static LARGE_INTEGER PC_startTime[NTIMERS], PC_stopTime[NTIMERS], PC_frequency; 
 
void PC_ElapsedInit(void) 
{   static BOOLEAN initDone=FALSE; 
 
    QueryPerformanceFrequency(&PC_frequency);			// Get the CPU frequency 
 
    if (initDone) 
    	return; 
    PC_ElapsedOverhead = 0;					// Measure the overhead of PC_ElapsedStart 
    PC_ElapsedStart(0);						// ... and PC_ElapsedStop 
    PC_ElapsedOverhead = (INT16U) PC_ElapsedStop(0); 
    initDone=TRUE; 
} 
 
/* 
   ********************************************************************************************************* 
   *                            START A TIMER FOR EXECUTION TIME MEASUREMENT 
   * 
   * Description : Trigger the timer to be used to measure the time between events. 
   *               Timer will be running when the function returns.  
   *		   Time measurement needs to be initalized before by calling PC_ElapsedInit, only 
   *               needed once for all timers together.  
   * 
   * Arguments   : n=0...NTIMERS-1 number of timer 
   * 
   * Returns     : None. 
   ********************************************************************************************************* 
 */ 
void PC_ElapsedStart(INT8U n) 
{   if (n >= NTIMERS) 
        return; 
    QueryPerformanceCounter(&PC_startTime[n]);			// Read the CPU counter and store it 
} 
 
/* 
   ********************************************************************************************************* 
   *                             STOP A TIMER FOR EXECUTION TIMER MEASUREMENT 
   * 
   * Description : This function stops the the timer for execution time measurement and computes the 
   *               time in microseconds since the timer was started with PC_ElapsedStart. 
   * 
   * Arguments   : n=0...NTIMERS-1 number of timer. 
   * 
   * Returns     : The number of micro-seconds since the timer was last started. 
   * 
   * Notes       : - The returned time accounts for the processing time of the START and STOP functions. 
   *                
   ********************************************************************************************************* 
 */ 
INT32U PC_ElapsedStop(INT8U n) 
{   LARGE_INTEGER PC_diffTime; 
 
    if (n >= NTIMERS) 
        return 0; 
    QueryPerformanceCounter(&PC_stopTime[n]);			// Read the CPU counter and store it 
    PC_diffTime.QuadPart = PC_stopTime[n].QuadPart - PC_startTime[n].QuadPart; //Compute the difference and 
								// ... convert it into microseconds 
    return (INT32U) (PC_diffTime.QuadPart * (__int64) 1000000 / PC_frequency.QuadPart - PC_ElapsedOverhead); 
} 
 
/* 
   ********************************************************************************************************* 
   *                                       GET THE CURRENT DATE AND TIME 
   * 
   * Description: This function obtains the current date and time from the PC. 
   * 
   * Arguments  : s     is a pointer to where the ASCII string of the current date and time will be stored. 
   *                    You must allocate at least 21 bytes (includes the NUL) of storage in the return 
   *                    string.  The date and time will be formatted as follows: 
   * 
   *                        "YYYY-MM-DD  HH:MM:SS" 
   * 
   * Returns    : none 
   ********************************************************************************************************* 
 */ 
void PC_GetDateTime(char *s) 
{   SYSTEMTIME now; 
 
    GetLocalTime(&now);						// Get the local date and time 
 
    sprintf(s, "%04d-%02d-%02d  %02d:%02d:%02d",		// Convert into a string 
            now.wYear, 
            now.wMonth, 
            now.wDay, 
            now.wHour, 
            now.wMinute, 
            now.wSecond); 
} 
 
 
 
/* 
********************************************************************************************************* 
*                                        INSTALL INTERRUPT VECTOR 
* 
* Description: This function sets an interrupt vector in the "simulated" interrupt vector table. 
* 
* Arguments  : vect  is the desired interrupt vector number, a number between 1 and 7. 
*              isr   is a pointer to a function to execute when the interrupt or exception occurs. 
* 
*              Interrupt 0 cannot be set, because it is reserved for the timer interrupt. 
* 
* Returns    : none 
********************************************************************************************************* 
*/ 
 
void  PC_IntVectSet(INT8U irq, void (*isr)(void)) 
{    
    if ((irq >0) && (irq < 8)) 
    { 
   // interruptTable[irq]=isr; 
    } 
} 
 
/* 
********************************************************************************************************* 
*                                        OBTAIN INTERRUPT VECTOR 
* 
* Description: This function reads the pointer stored at the specified vector. 
* 
* Arguments  : vect  is the desired interrupt vector number, a number between 0 and 7. 
* 
* Returns    : The address of the Interrupt handler stored at the desired vector location. 
********************************************************************************************************* 
*/ 
 
void *PC_IntVectGet(INT8U irq) 
{   if (irq < 8) 
       return NULL;//interruptTable[irq]; 
    else 
       return NULL; 
}