Add runtime monitoring, tests, and docs

Author: dev-rajnishg

.gitignore

@@ -0,0 +1,13 @@
+build/
+*.obj
+*.o
+*.pdb
+*.ilk
+*.exe
+*.db
+*.csv
+*.log
+*.user
+*.vcxproj*
+*.sln
+out/

CMakeLists.txt

@@ -0,0 +1,47 @@
+cmake_minimum_required(VERSION 3.16)
+project(DeviceSensorDataLogger VERSION 1.0 LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+option(ENABLE_SQLITE "Enable SQLite logging support" ON)
+include(CTest)
+
+find_package(Threads REQUIRED)
+if(ENABLE_SQLITE)
+  find_package(SQLite3)
+endif()
+
+add_library(device_sensor_core
+  src/TimeUtils.cpp
+  src/Sensor.cpp
+  src/LogSink.cpp
+  src/Stats.cpp
+  src/DataLogger.cpp
+)
+
+target_include_directories(device_sensor_core PUBLIC include)
+target_link_libraries(device_sensor_core PUBLIC Threads::Threads)
+
+if(SQLite3_FOUND)
+  target_compile_definitions(device_sensor_core PRIVATE HAS_SQLITE=1)
+  target_link_libraries(device_sensor_core PUBLIC SQLite::SQLite3)
+else()
+  message(STATUS "SQLite3 not found. SQLite output will be unavailable.")
+endif()
+
+add_executable(device_sensor_logger
+  src/main.cpp
+)
+
+target_link_libraries(device_sensor_logger PRIVATE device_sensor_core)
+
+if(BUILD_TESTING)
+  add_executable(device_sensor_logger_tests
+    tests/device_sensor_logger_tests.cpp
+  )
+
+  target_link_libraries(device_sensor_logger_tests PRIVATE device_sensor_core)
+  add_test(NAME device_sensor_logger_tests COMMAND device_sensor_logger_tests)
+endif()

README.md

@@ -0,0 +1,128 @@
+# Device Sensor Data Logger (C++)
+
+A C++17 sensor logging application for simulated or serial temperature/light sources. It supports CSV or SQLite persistence, threaded sampling, runtime summaries, threshold alerts, and CSV export.
+
+## Features
+
+- Sensor input modes:
+  - Simulated sensor mode (Linux/Windows, no hardware needed)
+  - Serial sensor mode (Linux UART/USB serial device)
+- Logging outputs:
+  - CSV file
+  - SQLite database (when SQLite3 is available)
+- Runtime controls:
+  - Start logging
+  - Stop logging
+  - Show live stats (min/max/avg)
+  - Show runtime status (accepted/rejected samples, failures, last reading)
+  - Reset session statistics without restarting the app
+  - Export logs to CSV
+- Safety and observability:
+  - Input validation rejects invalid readings such as `NaN` and negative lux values
+  - Configurable alert thresholds for temperature and light
+  - Optional `--max-samples` auto-stop for bounded runs and tests
+- Demonstrates:
+  - OOP interfaces (`ISensor`, `ILogSink`)
+  - File I/O and optional SQLite storage
+  - Threaded periodic logging loop
+  - Basic serial communication parsing
+
+## Architecture
+
+- `ISensor` abstracts data sources. `SimulatedSensor` generates drifting readings. `SerialSensor` reads `temp,light` lines from a serial device on non-Windows platforms.
+- `ILogSink` abstracts persistence. `CsvLogSink` appends CSV rows. `SqliteLogSink` stores rows in a `sensor_log` table and can export them back to CSV.
+- `DataLogger` owns one sensor and one sink, runs the sampling loop on a worker thread, tracks aggregated stats, validates samples, counts failures, and raises threshold alerts.
+- `StatsAggregator` maintains min/max/average for temperature and light.
+
+## Build
+
+```bash
+cmake -S . -B build
+cmake --build build
+```
+
+## Test
+
+```bash
+ctest --test-dir build --output-on-failure
+```
+
+The test target covers stats reset logic plus the logger lifecycle, invalid sample rejection, alert tracking, and bounded auto-stop behavior.
+
+## Run
+
+### Interactive mode (simulated sensor + CSV)
+
+```bash
+./build/device_sensor_logger --mode sim --output csv --file sensor_log.csv --interval-ms 1000 --temp-alert-max 28 --light-alert-min 100
+```
+
+Then use commands:
+
+- `start`
+- `stop`
+- `stats`
+- `status`
+- `reset-stats`
+- `export exported.csv`
+- `quit`
+
+### Timed run (auto start/stop)
+
+```bash
+./build/device_sensor_logger --mode sim --output sqlite --file sensor_log.db --duration-sec 20 --max-samples 50 --export out.csv
+```
+
+### Serial mode example (Linux)
+
+```bash
+./build/device_sensor_logger --mode serial --serial-port /dev/ttyUSB0 --baud 115200 --output csv --file serial_log.csv
+```
+
+Expected incoming serial line format:
+
+```text
+24.1,315.5
+```
+
+## Command Line Options
+
+- `--mode sim|serial`
+- `--serial-port <path>`
+- `--baud <rate>`
+- `--interval-ms <milliseconds>`
+- `--output csv|sqlite`
+- `--file <output-path>`
+- `--duration-sec <seconds>`
+- `--max-samples <count>`
+- `--temp-alert-min <value>`
+- `--temp-alert-max <value>`
+- `--light-alert-min <value>`
+- `--light-alert-max <value>`
+- `--export <csv-path>`
+
+## Example Output
+
+```text
+Sensor Data Logger
+Commands:
+  start              Start logging
+  stop               Stop logging
+  stats              Show min/max/avg
+  status             Show runtime counters and last reading
+  reset-stats        Clear collected session statistics
+  export <file.csv>  Export log data to CSV
+  help               Show commands
+  quit               Stop and exit
+> start
+Logging started.
+> status
+running=yes accepted=5 rejected=0 read_failures=0 write_failures=0 alerts=1
+last=2026-03-12T12:00:05Z temp=28.214C light=92.113 lux
+```
+
+## Notes
+
+- If SQLite3 is not found during CMake configure, SQLite output is disabled automatically.
+- In serial mode on Linux, ensure your user has permission to access the serial device (for example, group `dialout`).
+- On Windows, serial mode is stubbed out in the current implementation and simulated mode should be used unless Windows serial support is added.

include/DataLogger.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include "LogSink.h"
+#include "Sensor.h"
+#include "Stats.h"
+
+#include <atomic>
+#include <chrono>
+#include <memory>
+#include <mutex>
+#include <thread>
+
+struct AlertThresholds {
+    bool hasMinTemperatureC = false;
+    double minTemperatureC = 0.0;
+    bool hasMaxTemperatureC = false;
+    double maxTemperatureC = 0.0;
+    bool hasMinLightLux = false;
+    double minLightLux = 0.0;
+    bool hasMaxLightLux = false;
+    double maxLightLux = 0.0;
+};
+
+class DataLogger {
+public:
+    DataLogger(std::unique_ptr<ISensor> sensor,
+               std::unique_ptr<ILogSink> sink,
+               std::chrono::milliseconds interval,
+               AlertThresholds thresholds = {},
+               std::size_t maxSamples = 0);
+    ~DataLogger();
+
+    bool start();
+    void stop();
+    bool isRunning() const;
+
+    LoggerStats stats() const;
+    LoggerRuntimeSummary summary() const;
+    bool exportLogs(const std::string& outputPath);
+    void resetStats();
+
+private:
+    void loop();
+    bool isReadingValid(const SensorReading& reading) const;
+    bool isAlert(const SensorReading& reading) const;
+
+    std::unique_ptr<ISensor> sensor_;
+    std::unique_ptr<ILogSink> sink_;
+    std::chrono::milliseconds interval_;
+    AlertThresholds thresholds_;
+    std::size_t maxSamples_;
+
+    std::atomic<bool> running_;
+    std::thread worker_;
+
+    mutable std::mutex statsMutex_;
+    StatsAggregator stats_;
+    std::size_t acceptedSamples_;
+    std::size_t rejectedSamples_;
+    std::size_t readFailures_;
+    std::size_t writeFailures_;
+    std::size_t alertCount_;
+    bool hasLastReading_;
+    SensorReading lastReading_;
+};

include/LogSink.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "Reading.h"
+
+#include <fstream>
+#include <memory>
+#include <string>
+
+class ILogSink {
+public:
+    virtual ~ILogSink() = default;
+    virtual bool open() = 0;
+    virtual bool write(const SensorReading& reading) = 0;
+    virtual void close() = 0;
+    virtual std::string name() const = 0;
+    virtual bool exportToCsv(const std::string& outputPath) { (void)outputPath; return false; }
+};
+
+class CsvLogSink final : public ILogSink {
+public:
+    explicit CsvLogSink(std::string filePath);
+    bool open() override;
+    bool write(const SensorReading& reading) override;
+    void close() override;
+    std::string name() const override;
+    bool exportToCsv(const std::string& outputPath) override;
+
+private:
+    std::string filePath_;
+    std::ofstream file_;
+};
+
+class SqliteLogSink final : public ILogSink {
+public:
+    explicit SqliteLogSink(std::string dbPath);
+    ~SqliteLogSink() override;
+
+    bool open() override;
+    bool write(const SensorReading& reading) override;
+    void close() override;
+    std::string name() const override;
+    bool exportToCsv(const std::string& outputPath) override;
+
+private:
+    std::string dbPath_;
+
+#if defined(HAS_SQLITE)
+    struct sqlite3* db_;
+#else
+    void* db_;
+#endif
+};

include/Reading.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <chrono>
+
+struct SensorReading {
+    std::chrono::system_clock::time_point timestamp;
+    double temperatureC = 0.0;
+    double lightLux = 0.0;
+};

include/Sensor.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "Reading.h"
+
+#include <random>
+#include <string>
+
+class ISensor {
+public:
+    virtual ~ISensor() = default;
+    virtual bool read(SensorReading& reading) = 0;
+    virtual std::string name() const = 0;
+};
+
+class SimulatedSensor final : public ISensor {
+public:
+    SimulatedSensor();
+    bool read(SensorReading& reading) override;
+    std::string name() const override;
+
+private:
+    std::mt19937 rng_;
+    std::normal_distribution<double> tempNoise_;
+    std::normal_distribution<double> lightNoise_;
+    double temperatureC_;
+    double lightLux_;
+};
+
+class SerialSensor final : public ISensor {
+public:
+    SerialSensor(std::string portName, int baudRate);
+    ~SerialSensor() override;
+
+    bool read(SensorReading& reading) override;
+    std::string name() const override;
+
+private:
+    std::string portName_;
+    int baudRate_;
+    int fd_;
+
+    bool openPort();
+    void closePort();
+};