Praveen/json pipeline

.gitignore

@@ -0,0 +1,10 @@
+main
+cmake_install.cmake
+CMakeFiles/
+tags
+CMakeCache.txt
+CTestTestfile.cmake
+main_autogen/
+pul
+screenshot.png
+

CMakeLists.txt

@@ -0,0 +1,36 @@
+cmake_minimum_required(VERSION 3.7.0)
+
+project(pulse VERSION 1.0.0 LANGUAGES CXX)
+
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  set(CMAKE_BUILD_TYPE "RelWithDebInfo")
+endif()
+add_compile_options(-Wall -Wconversion -Wextra -pedantic)
+add_library(cpptimer STATIC CppTimer.cpp)
+TARGET_LINK_LIBRARIES(cpptimer rt fcgi ${CMAKE_THREAD_LIBS_INIT} curl)
+set_target_properties(cpptimer PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTORCC ON)
+set(CMAKE_AUTOUIC ON)
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+
+find_package(Qt5 COMPONENTS Widgets PrintSupport REQUIRED)
+find_package(QCustomPlot)
+find_library(wiringPi_LIB wiringPi)
+find_package(Threads REQUIRED)
+find_package( CURL )
+
+add_executable(main
+  CppTimer.cpp
+  mainwindow.cpp
+  main.cpp
+)
+
+target_link_libraries(main
+  Qt5::Widgets Qt5::PrintSupport Threads::Threads cpptimer ${QCustomPlot_LIBRARIES} ${wiringPi_LIB  fcgi rt ${CMAKE_THREAD_LIBS_INIT} curl}
+  )
+

CppTimer.cpp

@@ -0,0 +1,96 @@
+#include "CppTimer.h"
+
+/**
+ * GNU GENERAL PUBLIC LICENSE
+ * Version 3, 29 June 2007
+ *
+ * (C) 2020-2021, Bernd Porr <mail@bernporr.me.uk>
+ * 
+ * This is inspired by the timer_create man page.
+ **/
+
+CppTimer::CppTimer(const int signo)
+{
+	// We create a static handler catches the signal SIG
+	sa.sa_flags = SA_SIGINFO;
+	sa.sa_sigaction = handler;
+	sigemptyset(&sa.sa_mask);
+	if (sigaction(signo, &sa, NULL) == -1)
+		throw("Could not create signal handler");
+
+	// Create the timer
+	sev.sigev_notify = SIGEV_SIGNAL;
+	sev.sigev_signo = signo;
+	// Cruical is that the signal carries the pointer to this class instance here
+	// because the handler just handles anything that comes in!
+	sev.sigev_value.sival_ptr = this;
+	// create the timer
+	if (timer_create(CLOCKID, &sev, &timerid) == -1)
+		throw("Could not create timer");
+}
+
+void CppTimer::startns(long nanosecs, cppTimerType_t type)
+{
+	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 (timer_settime(timerid, 0, &its, NULL) == -1)
+		throw("Could not start timer");
+}
+
+void CppTimer::startms(long millisecs, cppTimerType_t type)
+{
+	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 (timer_settime(timerid, 0, &its, NULL) == -1)
+		throw("Could not start timer");
+}
+
+void CppTimer::stop()
+{
+	// 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;
+	timer_settime(timerid, 0, &itsnew, &its);
+}
+
+CppTimer::~CppTimer()
+{
+	stop();
+	// delete the timer
+	timer_delete(timerid);
+	// default action for signal handling
+	signal(sev.sigev_signo, SIG_IGN);
+}

CppTimer.h

@@ -0,0 +1,100 @@
+#ifndef __CPP_TIMER_H_
+#define __CPP_TIMER_H_
+
+/**
+ * GNU GENERAL PUBLIC LICENSE
+ * Version 3, 29 June 2007
+ *
+ * (C) 2020-2021, 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 <signal.h>
+#include <time.h>
+
+#define CLOCKID CLOCK_MONOTONIC
+
+/**
+ * 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:
+	/**
+	 * Creates an instance of the timer and connects the
+	 * signal handler to the timer. The default signal which
+	 * is being used is SIGRTMIN but can be changed to other
+	 * signals if other processes / threads use them.
+	 * @param signo The signal used by the timer.
+	 **/
+	CppTimer(const int signo = SIGRTMIN);
+
+	/**
+	 * 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);
+
+	/**
+	 * 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);
+
+	/**
+	* Stops the timer by disarming it. It can be re-started
+	* with start().
+	**/
+	virtual void stop();
+
+	/**
+	 * Destructor disarms the timer, deletes it and
+	 * disconnect the signal handler.
+	 **/
+	virtual ~CppTimer();
+
+protected:
+	/**
+	 * Abstract function which needs to be implemented by the children.
+	 * This is called every time the timer fires.
+	 **/
+	virtual void timerEvent() = 0;
+
+private:
+	timer_t timerid = 0;
+	struct sigevent sev;
+	struct sigaction sa;
+	struct itimerspec its;
+
+	inline static void handler(int, siginfo_t *si, void *)
+	{
+		(reinterpret_cast<CppTimer *>(si->si_value.sival_ptr))->timerEvent();
+	}
+};
+
+#endif

CppTimerCallback.h

@@ -0,0 +1,36 @@
+#ifndef __CPP_TIMER_CALLBACK
+#define __CPP_TIMER_CALLBACK
+#include <stdio.h>
+#include "CppTimer.h"
+#include <unistd.h>
+
+
+class CppTimerCallback : public CppTimer {
+
+public:
+	class Runnable {
+	public:
+		virtual void run() = 0;
+	};
+
+	void registerEventRunnable(Runnable &h) {
+		cppTimerEventRunnable = &h;
+	}
+
+	void unregisterEventRunnable() {
+		cppTimerEventRunnable = NULL;
+	}
+
+        void timerEvent() {
+		if (cppTimerEventRunnable) {
+			cppTimerEventRunnable->run();
+		}
+	}
+
+private:
+	Runnable* cppTimerEventRunnable = NULL;
+
+};
+
+
+#endif