C / C++ / MFC

typedef struct MyStateStruct_t {
    int a;
} MYSTATE;        // typedef the structure to a name

typedef enum {
    MY_SELECTOR_0 = 0,
    MY_SELECTOR_1 = 1
} MyEnum_e;

const MYSTATE myStates[2];   // use structure name

enum MyEnum_e selector = MY_SELECTOR_0;  // Set selector to 0
int result1 = myStates[selector].a;       // result1 is myStates[0].a

selector = MY_SELECTOR_1;  // Set selector to 1
int result2 = myStates[selector].a;       // result2 is myStates[1].a

// Define a structure to pass to thread
typedef struct _MYWATCHERDATA {
	HWND AppWindow;             // Application window to post message to
	UINT MsgId;			        // Your private message ID will be WM_APP + some number
	WPARAM CmdId;               // Command ID .. perhaps you have multiple of these watchers
	char* FolderToWatch;        // The string nominating the folder to watch
	HANDLE dwChangeHandles[2];  // These will be thread wait handles (1 for it, 1 for me to force exit)
	BOOL threadExitComplete;	// Thread exit completed
} WATCHERDATA;

// This is the thread routine
// Pass an initialized structure in on LPARAM Of CreateThread
DWORD WINAPI NotifyMeOfFolderChangeThread(LPVOID lpParam)    // thread procedure
{
	BOOL exitSignal = FALSE;                                 // Preset exit signal to false
	WATCHERDATA* watchData = (WATCHERDATA*)lpParam;	         // Typecast the lParam to your structure you pass in

	// Watch Handle[0] belongs to this thread 
	watchData->dwChangeHandles[0] =
		FindFirstChangeNotification(watchData->FolderToWatch, // folder path passed in
			FALSE,										      // no subfolders
			FILE_NOTIFY_CHANGE_FILE_NAME);				      // watch for renaming, creating, or deleting a file
	
	if (INVALID_HANDLE_VALUE == watchData->dwChangeHandles[0])// Error something is dorked probably folder doesn't exist
	{
		DWORD dwError = ::GetLastError();
		// handle error
		return dwError;
	}

	while (exitSignal == FALSE) {
		// Okay we wait on the notification signal or exernal exit signal
		DWORD dwWaitStatus = WaitForMultipleObjects(2, 
			watchData->dwChangeHandles, FALSE, INFINITE);
		
		switch (dwWaitStatus) {
			// Wait exit was from directory change
			case WAIT_OBJECT_0:
				// Post off message back to application window.
				PostMessage(watchData->AppWindow, watchData->MsgId,
					watchData->CmdId, (LPARAM)watchData->FolderToWatch);
				FindNextChangeNotification(watchData->dwChangeHandles[0]);
				break;
			// External thread signal forcing thread to break out and exit
			case WAIT_OBJECT_0 + 1:
				exitSignal = TRUE;           // Yep time to exit
				break;
		}
	}
	watchData->threadExitComplete = TRUE; // Thread has finished with watchData .. tell app that
	return 0;
}

// Initialize a WATCHERDATA structure
char* watchDirectory = "c:\\temp\\";                                // Some directory to watch
WATCHERDATA* myWatch = (WATCHERDATA*) malloc(sizeof(WATCHERDATA)); // Allocate memory
myWatch->AppWindow = myAppHandle;                                  // Application window handle
myWatch->MsgId = WM_APP  + 100;									   // Some private application message ID 
myWatch->CmdId = 1;										           // Some private id we might have multiple watches
int len = strlen(watchDirectory) + 1;                               // size of string
myWatch->FolderToWatch = (char*) malloc(len);					   // Allocate string space 
strcpy_s(myWatch->FolderToWatch, len, watchDirectory);			   // Copy string to allocated memory        
myWatch->dwChangeHandles[0] = 0;								   // Clear thread handle one .. thread itself uses that
myWatch->dwChangeHandles[1] = CreateEvent(0, FALSE, FALSE, "EXIT");// Set thread handle two for us to force exit
myWatch->threadExitComplete = FALSE;	                           // Thread will set this on complete
																   
// Use thread
HANDLE workerThread = CreateThread(NULL, 0, NotifyMeOfFolderChangeThread, myWatch, 0, NULL);

// Change thread priority
SetThreadPriority(workerThread, THREAD_PRIORITY_LOWEST);

// This will do a simple 10 sec wait .. simulating doing something
Sleep(10000);

// Ok manually terminate the thread
SetEvent(myWatch->dwChangeHandles[1]);

// Wait for thread to signal it has finished with myWatch
while (myWatch->threadExitComplete == FALSE) {};

// Okay you are free to cleanup myWatch
free(myWatch->FolderToWatch);
free(myWatch);

while (myWatch->threadExitComplete == FALSE) {};

WaitForSingleObject(workerThread, INFINITE)

if (dwWaitStatus == WAIT_OBJECT_0)
    break;

CTimeouts.ReadIntervalTimeout = 20;          // msec between bytes arriving
CTimeouts.ReadTotalTimeoutMultiplier = 10;   // msec*bytes = 2560
CTimeouts.ReadTotalTimeoutConstant = 100;    // Added to above
CTimeouts.WriteTotalTimeoutMultiplier = 0;   //10;  // msec*bytes = 1280
CTimeouts.WriteTotalTimeoutConstant = 0;     //100;

To open a serial port
    - Insert a colon after the communication port pointed to with the first parameter, lpzPortName.
    For example, specify COM1: as the communication port.