"Could not find a package configuration file provided by "Qt5" with any of the following names: Qt5Config.cmake qt5-config.cmake"

CMakeLists.txt

@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.7.0)
+
+project(qwt-example-app VERSION 1.0.0 LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTORCC ON)
+set(CMAKE_AUTOUIC ON)
+
+find_package(Qt5 COMPONENTS Widgets REQUIRED)
+
+add_executable(qwt-example
+  window.cpp
+  main.cpp
+)
+
+target_link_libraries(qwt-example Qt5::Widgets)
+target_link_libraries(qwt-example qwt-qt5)
+
+install(TARGETS qwt-example)

CppTimer.h

@@ -0,0 +1,162 @@
+#ifndef __CPP_TIMER_H_
+#define __CPP_TIMER_H_
+
+/**
+ * GNU GENERAL PUBLIC LICENSE
+ * Version 3, 29 June 2007
+ *
+ * (C) 2020-2024, Bernd Porr <mail@bernporr.me.uk>
+ * 
+ * This is inspired by the timer_create man page.
+ **/
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <time.h>
+#include <thread>
+#include <sys/timerfd.h>
+
+/**
+ * Enumeration of CppTimer types
+ **/
+enum cppTimerType_t
+{
+    PERIODIC,
+    ONESHOT
+};
+
+/**
+ * Timer class which repeatedly fires. It's wrapper around the
+ * POSIX per-process timer.
+ **/
+class CppTimer
+{
+
+public:
+    /**
+     * Starts the timer. The timer fires first after
+     * the specified time in nanoseconds and then at
+     * that interval in PERIODIC mode. In ONESHOT mode
+     * the timer fires once after the specified time in
+     * nanoseconds.
+     * @param nanosecs Time in nanoseconds
+     * @param type Either PERIODIC or ONESHOT
+     **/
+    virtual void startns(long nanosecs, cppTimerType_t type = PERIODIC) {
+	if (running) return;
+	fd = timerfd_create(CLOCK_MONOTONIC, 0);
+	if (fd < 0)
+	    throw("Could not start timer");
+	switch (type)
+	{
+	case (PERIODIC):
+	    //starts after specified period of nanoseconds
+	    its.it_value.tv_sec = nanosecs / 1000000000;
+	    its.it_value.tv_nsec = nanosecs % 1000000000;
+	    its.it_interval.tv_sec = nanosecs / 1000000000;
+	    its.it_interval.tv_nsec = nanosecs % 1000000000;
+	    break;
+	case (ONESHOT):
+	    //fires once after specified period of nanoseconds
+	    its.it_value.tv_sec = nanosecs / 1000000000;
+	    its.it_value.tv_nsec = nanosecs % 1000000000;
+	    its.it_interval.tv_sec = 0;
+	    its.it_interval.tv_nsec = 0;
+	    break;
+	}
+	if (timerfd_settime(fd, 0, &its, NULL) == -1)
+	    throw("Could not start timer");
+	uthread = std::thread(&CppTimer::worker,this);
+    }
+
+    /**
+     * Starts the timer. The timer fires first after
+     * the specified time in milliseconds and then at
+     * that interval in PERIODIC mode. In ONESHOT mode
+     * the timer fires once after the specified time in
+     * milliseconds.
+     * @param millisecs Time in milliseconds
+     * @param type Either PERIODIC or ONESHOT
+     **/
+    virtual void startms(long millisecs, cppTimerType_t type = PERIODIC) {
+	if (running) return;
+	fd = timerfd_create(CLOCK_MONOTONIC, 0);
+	if (fd < 0)
+	    throw("Could not start timer");
+	switch (type)
+	{
+	case (PERIODIC):
+	    //starts after specified period of milliseconds
+	    its.it_value.tv_sec = millisecs / 1000;
+	    its.it_value.tv_nsec = (millisecs % 1000) * 1000000;
+	    its.it_interval.tv_sec = millisecs / 1000;
+	    its.it_interval.tv_nsec = (millisecs % 1000) * 1000000;
+	    break;
+	case (ONESHOT):
+	    //fires once after specified period of milliseconds
+	    its.it_value.tv_sec = millisecs / 1000;
+	    its.it_value.tv_nsec = (millisecs % 1000) * 1000000;
+	    its.it_interval.tv_sec = 0;
+	    its.it_interval.tv_nsec = 0;
+	    break;
+	}
+	if (timerfd_settime(fd, 0, &its, NULL) == -1)
+	    throw("Could not start timer");
+	uthread = std::thread(&CppTimer::worker,this);
+    }
+
+    /**
+     * Stops the timer by disarming it. It can be re-started
+     * with start().
+     **/
+    virtual void stop() {
+	if (!running) return;
+	running = false;
+	uthread.join();
+    }
+
+    /**
+     * Destructor disarms the timer, deletes it and
+     * disconnect the signal handler.
+     **/
+    virtual ~CppTimer() {
+	stop();
+    }
+
+protected:
+    /**
+     * Abstract function which needs to be implemented by the children.
+     * This is called every time the timer fires.
+     **/
+    virtual void timerEvent() = 0;
+
+private:
+    int fd = 0;
+    struct itimerspec its;
+    bool running = false;
+    std::thread uthread;
+    void worker() {
+	running = true;
+	while (running) {
+	    uint64_t exp;
+	    const long int s = read(fd, &exp, sizeof(uint64_t));
+	    if (s != sizeof(uint64_t) ) {
+		running = false;
+		return;
+	    }
+	    timerEvent();
+	}
+	// disarm
+	struct itimerspec itsnew;
+	itsnew.it_value.tv_sec = 0;
+	itsnew.it_value.tv_nsec = 0;
+	itsnew.it_interval.tv_sec = 0;
+	itsnew.it_interval.tv_nsec = 0;
+	timerfd_settime(fd, 0, &itsnew, &its);
+	close(fd);
+	fd = -1;
+    }
+};
+
+#endif

README.md

@@ -1,31 +1,27 @@
-QwtExample
-===========
+# QwtExample
 
-A simple example program using Qt/Qwt widgets to be used as a base for students doing Raspberry Pi data acquisition.
+A simple example program using QT and Qwt widgets.
 
-Qt is a cross platform framework for developing graphical applications, for more information please visit the links below:
-* [Qt Homepage](http://qt-project.org/)
-* [Qt 4.8 Class List](http://qt-project.org/doc/qt-4.8/classes.html)
-* [Wikpedia](http://en.wikipedia.org/wiki/Qt_%28framework%29)
-* [Signals and Slots](http://qt-project.org/doc/qt-4.8/signalsandslots.html)
+![alt tag](screenshot.png)
 
-Qwt is a technical widget library based on Qt, please see:
-* [Qwt Hompage](http://qwt.sourceforge.net/)
+## Required packages
 
+Install the QT5 and Qwt development packages:
 
-Making it work
---------------
+```
+    apt-get install qtdeclarative5-dev-tools qt5-qmake qt5-qmake-bin qtbase5-dev qtbase5-dev-tools
+    apt-get install libqwt-qt5-dev
+```
 
-To clone the git repository:
+## Build it
 
-    git clone https://github.com/glasgow-bio/qwt-example
-
-To build:
-
-    cd qwt-example
-    qmake
+```
+    cmake .
     make
+```
 
-To run (assuming you are logged into the RPi over ssh and no X-server is running):
+## Run it
 
-    startx ./QwtExample
+```
+    ./qwt-example
+```

fakesensor.h

@@ -0,0 +1,20 @@
+#ifndef __FAKESENSOR_H
+#define __FAKESENSOR_H
+
+#include "CppTimer.h"
+#include <math.h>
+
+class FakeSensor : public CppTimer {
+    public:
+	virtual void fakeSensorHasData(double inVal) = 0;
+	void timerEvent() {
+	    const double inVal = gain * sin( M_PI * (float)(count++) / 50.0 );
+	    fakeSensorHasData(inVal);
+	}
+    private:
+	int count = 0;
+	static constexpr double gain = 7.5;
+};
+
+
+#endif

main.cpp

@@ -1,17 +1,15 @@
-#include <window.h>
+#include "window.h"
 
 #include <QApplication>
 
+// Main program
 int main(int argc, char *argv[])
 {
 	QApplication app(argc, argv);
 
 	// create the window
 	Window window;
-	window.showMaximized();
-
-	// call the window.timerEvent function every 40 ms
-	window.startTimer(40);
+	window.show();
 
 	// execute the application
 	return app.exec();