Event-Driven Serial Port Read MFC - c++

Question

I am trying to implement an event-driven serial receive in my MFC dialog application.
I am using this class for access to the Win32 APIs dealing with serial ports.
I want to be notified whenever new data is received and from the description it seems like the ReadFileEx function (CSerialPort::ReadExin the Naughter class) could help me achieve this.
ReadFileEx function:
Reads data from the specified file or input/output (I/O) device. It reports its completion status asynchronously, calling the specified completion routine when reading is completed or canceled and the calling thread is in an alertable wait state.
If I have understood it correctly, I can specify a routine (function?) that would get called when serial data is received. But it is the last part that confuses me: "and the calling thread is in an alertable wait state". From the documentation the application can enter an alertable wait state by calling the following functions:
An application uses the MsgWaitForMultipleObjectsEx, WaitForSingleObjectEx, WaitForMultipleObjectsEx, and SleepEx functions to enter an alertable wait state.
Based on this I have the following code in my MFC application:
CSerialPort arduino;
OVERLAPPED overlapped{};
HANDLE hEvent = nullptr;
char command_Arduino[1];
void CTAB1::OnBnClickedButton()
{
hEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
ATLASSERT(hEvent != nullptr);
overlapped.hEvent = hEvent;
arduino.SetMask(EV_RXCHAR);
arduino.ReadEx(command_Arduino, 1, &overlapped, Run);
WaitForSingleObjectEx(hEvent, INFINITE, TRUE);
}
However this gives me an unhandled exception:
0xC0000005: Access violation executing location 0x0000000000000000.
Where am I going wrong here? Any help would be greatly appreciated.
Update: Thanks to all the helpful comments, I was able to achieve asynchronous serial receive in a separate worker thread.
Declarations and definitions:
#define WM_USER1 (WM_USER + 1)
CSerialPort arduino;
HANDLE WorkerThread = nullptr;
DWORD WINAPI SerialInputMotorControl_Thread(LPVOID WndPtr);
LRESULT CTAB1::on_wm_user1(WPARAM, LPARAM);
Creating the thread:
void CTAB1::OnBnClickedButtonMotorRun()
{
m_MotorRun.EnableWindow(FALSE); //Disable run button
m_MotorStop.EnableWindow(TRUE); //Enable stop button
//Create worker thread for dealing with serial receive
WorkerThread = CreateThread(NULL, 0, SerialInputMotorControl_Thread, (LPVOID)m_hWnd, 0, NULL);
}
Terminating the thread:
void CTAB1::OnBnClickedButtonMotorStop()
{
m_MotorRun.EnableWindow(TRUE);
m_MotorStop.EnableWindow(FALSE);
if (WorkerThread != nullptr)
{
if (!TerminateThread(WorkerThread, 0)) //Delete worker thread
{
DWORD err = GetLastError();
MessageBox(_T("Error: %d", err), _T("ERROR"), MB_OK | MB_ICONWARNING);
}
}
else
MessageBox(_T("Error: Thread not terminated"), _T("ERROR"), MB_OK | MB_ICONWARNING);
CloseHandle(WorkerThread); //Clean-up
}
The thread:
DWORD WINAPI SerialInputMotorControl_Thread(LPVOID WndPtr)
{
HWND hWnd = (HWND)WndPtr;
char command_Arduino[1] = {};
int prev_command = 100;
while(1)
{
try
{
arduino.Read(command_Arduino, 1);
}
catch (CSerialException& e)
{
if (e.m_dwError == ERROR_IO_PENDING)
{
DWORD dwBytesTransferred = 0;
}
}
char command;
command = command_Arduino[0];
if (prev_command != command)
{
if (command < 1) {
command = 0;
}
if (command > 16) {
command = 16;
}
PostMessage(hWnd, WM_USER1, command, 0); //Send message to GUI
prev_command = command;
}
}
return 0;
}
Then handle the command in the GUI message handler.