winasync.c

这是经典的卫星编程应用程序

#pragma pack(8)
#include <windows.h>
#include <winbase.h>
#include "g7to.h"
#define PROCX

DCB dcb;
HANDLE hCom;
HANDLE inH;
DWORD BaudRate;
DWORD ByteSize;
DWORD Parity;
DWORD StopBits;
DWORD CmodeSave;
COMMTIMEOUTS lpCommTimeouts;
int console_is_on=0;

PROCX void AsyncSet(int wBaudRate, INT wByteSize, INT wStopBits, INT wParity)
{
	BOOL fSuccess;
	DWORD dwError;

	dcb.BaudRate = wBaudRate;
	dcb.ByteSize = wByteSize;
	dcb.StopBits = wStopBits;
	dcb.Parity = wParity;
	dcb.fRtsControl=RTS_CONTROL_ENABLE;
	dcb.fDtrControl=DTR_CONTROL_ENABLE;
	fSuccess = SetCommState(hCom, &dcb);
	if (!fSuccess) {
	    /* Handle the error. */
	    dwError = GetLastError();
		fprintf(stderr,"Comm error 3. Error returned: %d\n",dwError);
		byebye(7);
	}
} // AsyncSet(int wBaudRate, INT wByteSize, INT wStopBits, INT wParity)

PROCX INT AsyncInit(char *port)
{
	DWORD dwError;
	BOOL fSuccess;

	hCom = CreateFile(port,
	    GENERIC_READ | GENERIC_WRITE,
	    0,    			// comm devices must be opened w/exclusive-access
	    NULL, 			// no security attrs
	    OPEN_EXISTING,	// comm devices must use OPEN_EXISTING
	    0,    			// not overlapped I/O
	    NULL  			// hTemplate must be NULL for comm devices
    );

	if (hCom == INVALID_HANDLE_VALUE) {
	    dwError = GetLastError();
	    /* handle error */
		fprintf(stderr,"Comm error 1. Error returned: %d\n",dwError);
		byebye(7);
	}
/*
 * Omit the call to SetupComm to use the default queue sizes.
 * Get the current configuration.
 */

	fSuccess = GetCommState(hCom, &dcb);

	if (!fSuccess) {
	    /* Handle the error. */
	    dwError = GetLastError();
		fprintf(stderr,"Comm error 2. Error returned: %d\n",dwError);
		byebye(7);
	}

	// Fill in the 'saved' DCB

	BaudRate = dcb.BaudRate;
	ByteSize = dcb.ByteSize;
	Parity	 = dcb.Parity;
	StopBits = dcb.StopBits;
//
// at this point the COM port is opened with default parameters.
//  The routine AsyncSet should be called to finish configuring the port
//
 	return 0;
} // AsyncInit()

PROCX void AsyncStop(void)
{
	BOOL fSuccess;
	DWORD dwError;

	dcb.BaudRate = BaudRate;
	dcb.ByteSize = ByteSize;
	dcb.Parity = Parity;
	dcb.StopBits = StopBits;
	fSuccess = SetCommState(hCom, &dcb);

	if (!fSuccess) {
	    /* Handle the error. */
	    dwError = GetLastError();
		fprintf(stderr,"Comm error 4. Error returned: %d\n",dwError);
		return;
	}
	CloseHandle(hCom);
}

PROCX void AsyncOut(unsigned char * msg, INT count)
{
// must add error checking before release
	int bytes;

	WriteFile(hCom, msg, count, &bytes, NULL);
}

PROCX INT AsyncIn(void)
{
	DWORD bytes;
	unsigned char c;
	
	ReadFile(hCom, &c, 1, &bytes, NULL);
	if(bytes) return (INT)c; 
	else return c+1000;
}

PROCX INT AsyncInStat(void)
{
	COMSTAT b;
	unsigned long along;

	ClearCommError(hCom, &along, &b);
	if(b.cbInQue>0) return 1;
	return 0;
} 

PROCX void conson(void)
{
	DWORD cmode,errorrtn;
	
	if(console_is_on) return;
	inH = GetStdHandle(STD_INPUT_HANDLE);
	if(inH ==INVALID_HANDLE_VALUE) {
		fprintf(stderr,"Invalid Standard Input Handle...aborting\n");
		byebye(1);
	}
	errorrtn=GetConsoleMode(inH,&cmode);
	if(errorrtn==0) {
		errorrtn=GetLastError();
		fprintf(stderr,"GetConsoleMode Last Error:%d\n",errorrtn);
	}
	CmodeSave=cmode;
	errorrtn=SetConsoleMode(inH, ENABLE_PROCESSED_INPUT);
	if(errorrtn==0) {
		errorrtn=GetLastError();
		fprintf(stderr,"SetConsoleMode Last Error:%d\n",errorrtn);
	}
	errorrtn=FlushConsoleInputBuffer(inH);
	if(errorrtn==0) {
		errorrtn=GetLastError();
		fprintf(stderr,"FlushConsoleInput Last Error:%d\n",errorrtn);
	}
	console_is_on=1;
} //conson()

PROCX void consoff(void)
{
	if(console_is_on == 0) return;
	SetConsoleMode(inH, CmodeSave);
	FlushConsoleInputBuffer(inH);
} //consoff()

PROCX INT kbraw(void)
{
	DWORD i;
	INPUT_RECORD lpBuffer;
	DWORD er,events_read, bytesread,ev;
	unsigned char bufin[50];

	conson();
// error checking?
	er=GetNumberOfConsoleInputEvents(inH, &events_read);
	if(er==0) {
		er=GetLastError();
		printf("GetNumberOfConsoleInputEvents Last Error:%d\n",er);
	}
	if(events_read==0) return 0;
//printf("Events read: %d\n",events_read);fflush(stdout);
	for(i=1;i<=events_read;i++) {
		er=ReadConsoleInput(inH, &lpBuffer, 1, &ev);
		if(er==0) {
			er=GetLastError();
			printf("ReadConsoleInput Last Error:%d\n",er);
			return 0;
		}
		if(ev==0) continue;
		if(lpBuffer.EventType != KEY_EVENT) continue;
		if(lpBuffer.Event.KeyEvent.bKeyDown==TRUE) continue; // skip key down
		break;
	}
//printf("returning: %d  %c\n",lpBuffer.Event.KeyEvent.uChar.AsciiChar, lpBuffer.Event.KeyEvent.uChar.AsciiChar);
	return lpBuffer.Event.KeyEvent.uChar.AsciiChar;
}
 
PROCX INT AsyncOutStat(void){return 0;}

#pragma pack()