meson.build

 project('RadAngel', 'cpp', default_options : ['cpp_std=c++17'], license : ['AGPL3','GPL3'], version : '0.1')
 
 thread_dep = dependency('threads')
+boost_dep = dependency('boost', modules : 'program_options')
+zmqpp_dep = dependency('libzmqpp')
 
 udev_dir = get_option('udev-dir')
 install_udev_dir = (udev_dir != 'no')
 endif
 
 subdir('radangeld')
+subdir('radangeldump')
 #subdir('radangel-webmon')
 #subdir('src')
 

meson_options.txt

 option('udev-dir', type: 'string', value: '', description: 'Absolute path of the udev base directory. Set to \'no\' not to install the udev rule')
-option('systemd-unit-dir', type: 'string', value: '', description: 'systemd service directory')
+option('systemd-unit-dir', type: 'string', value: '', description: 'Absolute path of the systemd service directory. Set to \'no\' not to install the radangeld service file.')

radangeld/main.cpp

 #include <thread>
 #include <atomic>
 #include <csignal>
+#include <cstdio>
 
 #include <wchar.h>
 
 		}
 	}
 	while (true);
+
+	eventpublisher.close();
+	std::remove("radangel.events");
 }
 
 void publish_cpm (zmqpp::context &zmqc)
 			if (validevents > 0)
 			{
 				cpm << timestamp
-				    << static_cast<double> (validevents / (timestamp - oldtimestamp) * 1000 * 60);
+				    << static_cast<double> (validevents / ((timestamp - oldtimestamp) / 1000.0 / 1000.0 ) * 60.0);
 
 				cpmsocket.send (cpm);
 
 		}
 	}
 	while (true);
+
+	cpmsocket.close();
+	std::remove("radangel.cpm");
 }
 
 int main (int argc, char *argv[])

radangeld/meson.build

 
 tz_dep = dependency('tz', fallback : ['hinnant-date', 'tz_dep'], default_options : ['use_system_tzdb=true'])
 hidapi_usb_dep = dependency('hidapi-libusb')
-boost_dep = dependency('boost', modules : 'program_options')
 libconfigpp_dep = dependency('libconfig++')
-zmqpp_dep = dependency('libzmqpp')
 libsystemd_dep = dependency('libsystemd')
 
-executable('radangeld', 'main.cpp', dependencies : [hidapi_usb_dep, boost_dep, libconfigpp_dep, libsystemd_dep, thread_dep, zmqpp_dep, tz_dep])
+executable('radangeld', 'main.cpp', dependencies : [hidapi_usb_dep, boost_dep, libconfigpp_dep, libsystemd_dep, thread_dep, zmqpp_dep, tz_dep], install : true)

radangeldump/main.cpp

+/*
+radangeldump -- a simple shell that displays data distributed by a radageld
+Copyright (C) 2020 Matthias Janke <matthias.janke@physi.uni-heidelberg.de>
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU Affero General Public License as published by the Free
+Software Foundation, version 3.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License along
+with this program. If not, see <https://www.gnu.org/licenses/>
+*/
+// SPDX-License-Identifier: AGPL-3.0-only
+
+#include <iostream>
+
+// program option parser
+#include <boost/program_options.hpp>
+
+// thread/ipc/tcp communications
+#include <zmqpp/zmqpp.hpp>
+
+int main(int argc, char *argv[])
+{
+    int64_t timestamp{0};
+    uint16_t event{0};
+    double countrate{0.0};
+
+    bool events;
+    bool cpm;
+
+    std::string socket;
+
+    zmqpp::context zmqc;
+
+    boost::program_options::options_description desc ("Available options:");
+	desc.add_options()
+	("help,?", "Prints this list of available options.")
+	("events,e", boost::program_options::value<bool> (&events)->implicit_value (true)->default_value (true), "Socket publishes events.")
+	("cpm,c", boost::program_options::value<bool> (&cpm)->implicit_value (true)->default_value (false), "Socket publishes counts per minute.")
+	("socket,s", boost::program_options::value<std::string> (&socket)->default_value("ipc://radangel.events"), "Socket to connect to.")
+	;
+
+	boost::program_options::positional_options_description p;
+	p.add ("socket", -1);
+
+	boost::program_options::variables_map vm;
+	boost::program_options::store (boost::program_options::command_line_parser (argc, argv).options (desc).positional (p).run(), vm);
+	boost::program_options::notify (vm);
+
+    if (vm.count ("help") )
+	{
+		std::cout << "Usage: " << argv[0] << " [options] [socket]\n";
+		std::cout << desc;
+		return 0;
+	}
+
+    if (vm["events"].defaulted() && !vm["cpm"].defaulted())
+        events = false;
+
+    if (events == cpm)
+    {
+        std::cerr << "Please decide if you either want events or counts per minute displayed! Only one of both options is valid." << std::endl;
+        return -1;
+    }
+
+    if (cpm && vm["socket"].defaulted())
+        socket = "ipc://radangel.cpm";
+
+    zmqpp::socket radangelsocket (zmqc, zmqpp::socket_type::subscribe);
+	radangelsocket.connect (socket);
+	radangelsocket.subscribe ("");
+	zmqpp::message messages;
+
+    if(events)
+        std::cout << "Energy [Ch]\trelative  timestamp[µs]\n";
+    else if (cpm)
+        std::cout << "relative  timestamp[µs]\tCoutrate [1/min]\n";
+
+    do
+    {
+        radangelsocket.receive(messages);
+
+        if(events)
+        {
+            messages >> event
+                     >> timestamp;
+            std::cout << event << "\t"
+                      << timestamp << "\n";
+        }
+        else if(cpm)
+        {
+            messages >> timestamp
+                     >> countrate;
+            std::cout << timestamp << "\t"
+                      << countrate << "\n";
+        }
+        else
+            break;
+    }
+    while(true);
+
+    return 0;
+}

radangeldump/meson.build

+executable('radangeldump', 'main.cpp', dependencies: [boost_dep, zmqpp_dep])