How can I use EventWaitHandle to create an event?

Question

I'm writing a program that listens on a Serial Port. I already have code that utilizes the VCP drivers (Virtual COM Port) to open a serial connection and then add an event handler for any time data is received. That code roughly looks like this:

public void OpenPort(string portNumber)
{
    _port = new SerialPort(
        portName: portNumber,
        baudRate: 9600,
        parity: Parity.None,
        dataBits: 8,
        stopBits: StopBits.One
    );
    _port.DataReceived += ReadData;
}

private void ReadData(object sender, SerialDataReceivedEventArgs e)
{
    string data = _port.ReadExisting().Trim();
    Console.WriteLine("Received: " + data);
}

This works great. It's very easy for me to understand how to set up events using the += notation. But I'm trying to switch over from using the VCP drivers to instead using the D2XX drivers provided by FTDI. I have most of the equivalent code that I need written, with the notable exception of being able to read data whenever a "data received" event occurs.

The D2XX driver includes one method for setting up event handlers whenever data is received, called SetEventNotification. Here's what the method signature looks like:

SetEventNotification(UInt32 eventMask, EventWaitHandle eventHandle);

The first parameter is straight-forward enough (they have some predefined uints you can pass in to determine when the event should trigger), but I've never worked directly with EventWaitHandles before, and I found the documentation difficult to grasp, so I'm having trouble getting started.

At the end of the day... I would like to have an event listener method which performs a read task, and which I can assign using the += operator, as I did above with the VCP driver.

Based on what I was reading, it looks like I'll have to create a new Thread that essentially polls continuously for the EventWaitHandle's signal? Or something like that? Any examples or sample code to get me started (or finished!) would be appreciated.

Here's what I have so far:

public void OpenPort(string portNumber)
{
    _port = new FTDI();
    var status = _port.OpenBySerialNumber(portNumber);
    if (FTDI.FT_STATUS.FT_OK != status) throw new Exception();

    status = _port.SetBaudRate((UInt32) 9600);
    if (FTDI.FT_STATUS.FT_OK != status) throw new Exception();

    status = _port.SetDataCharacteristics(
        DataBits: FTDI.FT_DATA_BITS.FT_BITS_8,
        StopBits: FTDI.FT_STOP_BITS.FT_STOP_BITS_1,
        Parity: FTDI.FT_PARITY.FT_PARITY_NONE
    );
    if (FTDI.FT_STATUS.FT_OK != status) throw new Exception();

    var evHandle = new EventWaitHandle(false, EventResetMode.AutoReset, "");
    _port.SetEventNotification(FTDI.FT_EVENTS.FT_EVENT_RXCHAR, evHandle);

    // ... now what?
}

public void ReadData(object sender, EventArgs e)
{
    UInt32 bytesAvailable = 0;
    _port.GetRxBytesAvailable(ref bytesAvailable);

    string data;
    UInt32 bytesRead = 0;
    _port.Read(out data, bytesAvailable, ref bytesRead);

    data = data.Trim();
    Console.WriteLine("Received: " + data);
}

score 3 · Accepted Answer · answered Mar 29 '15 at 16:26

I'll have to create a new Thread that essentially polls continuously for the EventWaitHandle's signal

Polls, no. But waits, yes. All that an event handle can do is let a thread sleep until the event is signaled. Note that "event" here means something completely different from a C# "event", though of course you can use the former as part of an implementation of the latter.

Frankly, it's not clear at all why you are headed down this part. Are you dealing with data transmitted over the standard serial port? If so, then there should never be any need to use some third-party API; Windows and .NET provide all you need, and you should stick with that. What does using this third-party API gain you that you are unable to accomplish using the standard SerialPort class?

As far as the event itself goes, without more context (and no, it's unlikely anyone would sift through the PDF you linked to figure out how to produce a turn-key solution for you), all one can offer is a general outline of how you can use the event handle to implement an event:

public event EventHandler DataReceived;

private bool _done;

private void PortListener(EventWaitHandle waitHandle)
{
    while (true)
    {
        waitHandle.WaitOne();
        if (_done)
        {
            break;
        }

        EventHandler handler = DataReceived;

        if (handler != null)
        {
            handler(this, EventArgs.Empty);
        }
    }
}

public void StartListening(EventWaitHandle waitHandle)
{
    _done = false;
    new Thread(() => PortListener(waitHandle)).Start()
}

public void StopListening(EventWaitHandle waitHandle)
{
    _done = true;
    waitHandle.Set();
}

The above provides a DataReceived C# event that is raised any time the wait handle is signaled. It assumes an auto-reset event. You can also use manual reset, simply by (of course) manually resetting the event handle any time it's signaled and you've raised the C# event.

To do this, it simply maintains an internal flag _done indicating whether the thread should be running or not, and provides the Start... and Stop... methods, which clear the flag and start the thread with its loop, and set the flag and signal the event, respectively.

Thank you so much! This is perfect and gives me enough to write the rest myself. (I wouldn't have expected anyone to have to dig through that obscure PDF!) To address your concerns, no, I'm not actually sending data over a standard COM port but instead using a USB-to-serial cable (effectively emulating serial communication). There are several documented drawbacks to using the VCP drivers because even though they have a nicer programming interface, they can actually throw framework-level exceptions that you can't catch, and things like that. The FTDI methods are generally more reliable. — soapergem, Mar 29 '15 at 22:51

How can I use EventWaitHandle to create an event?

1 Answers1