Edit 2: It looks like Qt 5.0 will now give us public access to QWinEventNotifier, so the contents of this article are definitely still useful. Thank you Leo (see the comments below) for pointing that out!
Edit: On April 30, 2011, Sebastian informed me that this approach no longer works in Qt 4.7.2. It looks like we no longer have access to the private header files. See the comments for more information where I describe what has changed and mention a few workarounds. My post continues unmodified below in case people are using older versions, or if we regain access to the QWinEventNotifier class in the future.
Lately I’ve been working with a CAN-USB adapter. I’ve been interfacing to it through a Qt GUI app. When you’re dealing with CAN, you need some kind of notification that you’ve received a message. On a microcontroller, an interrupt tells you when a message has arrived. With this CAN adapter, the driver needs to send some kind of notification to your app. Otherwise, you’re constantly polling to see if a new CAN message has arrived (and using up your computer’s CPU time needlessly).
This particular CAN adapter has both Linux and Windows drivers. The two drivers use slightly different APIs, so I’ve been using #ifdefs for the Qt app to work on both platforms.
On Linux, the driver gives you a file descriptor that you can pass to select() or a similar function to wait for activity, similar to how you’d wait for activity from a socket. In fact, that’s exactly how you handle it in Qt — you make a QSocketNotifier with the file descriptor the driver library gave you, and then the QSocketNotifier fires its activated() signal whenever a CAN message comes in. So this effectively integrates the USB to CAN adapter into the main thread’s event loop.
Dealing with this device in Windows is a little more complicated. First of all, the driver DLL doesn’t work with MinGW out of the box, but there are tutorials on the web with instructions to get a DLL compiled with Microsoft’s compiler to work correctly with MinGW. I can’t remember exactly how I did it, but those tutorials helped me with that. It was something about the way the functions in the DLL export file were named. Maybe I’ll write another blog post about that later, if I can figure out how I did it the first time. Bad Doug!
Anyway, the other thing about the Windows driver is that it doesn’t give a file descriptor to notify you that a CAN message has arrived. Instead, you’re supposed to pass it a Windows event handle, which it will then put into the signaled state whenever a message comes in. So you’re supposed to create a Windows event object with CreateEvent() and give the newly created event handle to the CAN library. Then, in a Windows app, you would use WaitForSingleObject() or something like that to wait for the driver to signal you.
Using this info, you could already solve the problem in a Qt app. Create a new thread in Qt that sits in a while loop, calling WaitForSingleObject() with an unlimited timeout. Whenever the event object is signaled, emit a Qt signal. You can then attach a slot in the main thread to that signal, and then you will be notified whenever a new CAN message is ready. This approach works, but it just seems like overkill because you’re creating a new thread with its own mini event loop just to forward the event to Qt’s event loop. Qt’s main thread already has an event loop, so why not just get the main thread’s event loop to listen for the event directly?
It turns out this is definitely possible to do with Qt. It’s just that the class is kind of hidden in the bowels of Qt, probably because it’s a Windows-specific thing. The class is called QWinEventNotifier, and you can use it in a Qt app by doing:
#include <QtCore/private/qwineventnotifier_p.h>
(Thanks, QExtSerialPort, for showing how to #include this class in your code–I saw it in Qt’s source code, but I couldn’t figure out how to add it in my program.)
From this point on, it’s simple. 3weyuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu (Sorry, that was the kitten.) Just create a QWinEventNotifier, passing the event handle returned from CreateEvent() to the constructor. Connect the QWinEventNotifier’s activated(HANDLE) signal to a slot. That’s it! Qt will take care of it from there, giving you a notification whenever a CAN message is ready for reading.
You don’t have to do anything special to be able to call CreateEvent, at least in my experience. Just #include <windows.h> and then you have complete access to CreateEvent and whatever other Windows function you need. It all just works.
I’m sure this can be adapted to work with other Windows event type stuff. Since my description of this solution was a little abstract, I’ll provide a concrete (silly) code example. I create a thread that does nothing other than signal a Windows event object every second or so. This is basically simulating the CAN library signaling when a message is received. Other than that, the main thread just creates a QWinEventNotifier that receives that signal. Here ya go:
wineventtestthread.h:
#ifndef WINEVENTTESTTHREAD_H
#define WINEVENTTESTTHREAD_H
#include <windows.h>
#include <QThread>
class WinEventTestThread : public QThread
{
Q_OBJECT
public:
explicit WinEventTestThread(void *eventH, QObject *parent = 0);
void run();
private:
HANDLE eventHandle;
bool keepRunning;
signals:
public slots:
};
#endif // WINEVENTTESTTHREAD_H
wineventtestthread.cpp:
#include "wineventtestthread.h"
#include <QDebug>
WinEventTestThread::WinEventTestThread(HANDLE eventH, QObject *parent) :
QThread(parent)
{
this->eventHandle = eventH;
this->keepRunning = false;
}
void WinEventTestThread::run()
{
qDebug() << "Test thread ID: " << QThread::currentThreadId();
this->keepRunning = true;
while (this->keepRunning)
{
// wait a second
sleep(1);
// signal the windows event
if (SetEvent(this->eventHandle) == 0)
{
qDebug() << "Test thread: Error signaling event";
}
else
{
qDebug() << "Signaled event in thread " << QThread::currentThreadId();
}
}
}
mainwindow.h:
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <windows.h>
#include <QMainWindow>
#include <QtCore/private/qwineventnotifier_p.h>
#include "wineventtestthread.h"
namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
private:
Ui::MainWindow *ui;
WinEventTestThread *thread;
HANDLE eventHandle;
QWinEventNotifier *notifier;
private slots:
void eventSignaled(HANDLE h);
};
#endif // MAINWINDOW_H
mainwindow.cpp:
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QDebug>
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
// create the windows event
qDebug() << "Main thread ID: " << QThread::currentThreadId();
this->eventHandle = CreateEvent(NULL, FALSE, FALSE, NULL);
if (this->eventHandle == NULL)
{
qDebug() << "Error creating event handle.";
}
else
{
// set up notifications when it's signaled
notifier = new QWinEventNotifier(this->eventHandle);
connect(notifier, SIGNAL(activated(HANDLE)), SLOT(eventSignaled(HANDLE)));
thread = new WinEventTestThread(this->eventHandle);
// start the test thread (it will start signaling the windows event)
thread->start();
}
}
MainWindow::~MainWindow()
{
delete ui;
}
void MainWindow::eventSignaled(HANDLE h)
{
qDebug() << "Signal received in thread " << QThread::currentThreadId();
}
Voilà!
