GPS implementation (#216)

Implemented basic GPS support:
- GPS HAL
- GPS Service
- GPS Settings app

TactilityHeadless/Include/Tactility/hal/gps/GpsDevice.h

@@ -0,0 +1,99 @@
+#pragma once
+
+#include "../Device.h"
+#include "../uart/Uart.h"
+#include "GpsDeviceInitDefault.h"
+#include "Satellites.h"
+
+#include <Tactility/Mutex.h>
+#include <Tactility/Thread.h>
+
+#include <minmea.h>
+#include <utility>
+
+namespace tt::hal::gps {
+
+class GpsDevice : public Device {
+
+public:
+
+    typedef int SatelliteSubscriptionId;
+    typedef int LocationSubscriptionId;
+
+    struct Configuration {
+        std::string name;
+        uart_port_t uartPort;
+        uint32_t baudRate;
+        std::function<bool(uart_port_t)> initFunction = initGpsDefault;
+    };
+
+private:
+
+    struct SatelliteSubscription {
+        SatelliteSubscriptionId id;
+        std::shared_ptr<std::function<void(Device::Id id, const minmea_sat_info&)>> onData;
+    };
+
+    struct LocationSubscription {
+        LocationSubscriptionId id;
+        std::shared_ptr<std::function<void(Device::Id id, const minmea_sentence_rmc&)>> onData;
+    };
+
+    const Configuration configuration;
+    Mutex mutex;
+    std::unique_ptr<Thread> thread;
+    bool threadInterrupted = false;
+    std::vector<SatelliteSubscription> satelliteSubscriptions;
+    std::vector<LocationSubscription> locationSubscriptions;
+    SatelliteSubscriptionId lastSatelliteSubscriptionId = 0;
+    LocationSubscriptionId lastLocationSubscriptionId = 0;
+
+    static int32_t threadMainStatic(void* parameter);
+    int32_t threadMain();
+
+    bool isThreadInterrupted() const;
+
+public:
+
+    explicit GpsDevice(Configuration configuration) : configuration(std::move(configuration)) {
+        assert(this->configuration.initFunction != nullptr);
+    }
+
+    ~GpsDevice() override = default;
+
+    Type getType() const override { return Type::Gps; }
+
+    std::string getName() const override { return configuration.name; }
+    std::string getDescription() const override { return ""; }
+
+    bool start();
+    bool stop();
+
+    bool isStarted() const;
+
+    SatelliteSubscriptionId subscribeSatellites(const std::function<void(Device::Id deviceId, const minmea_sat_info&)>& onData) {
+        satelliteSubscriptions.push_back({
+            .id = ++lastSatelliteSubscriptionId,
+            .onData = std::make_shared<std::function<void(Device::Id, const minmea_sat_info&)>>(onData)
+        });
+        return lastSatelliteSubscriptionId;
+    }
+
+    void unsubscribeSatellites(SatelliteSubscriptionId subscriptionId) {
+        std::erase_if(satelliteSubscriptions, [subscriptionId](auto& subscription) { return subscription.id == subscriptionId; });
+    }
+
+    LocationSubscriptionId subscribeLocations(const std::function<void(Device::Id deviceId, const minmea_sentence_rmc&)>& onData) {
+        locationSubscriptions.push_back({
+            .id = ++lastLocationSubscriptionId,
+            .onData = std::make_shared<std::function<void(Device::Id, const minmea_sentence_rmc&)>>(onData)
+        });
+        return lastLocationSubscriptionId;
+    }
+
+    void unsubscribeLocations(SatelliteSubscriptionId subscriptionId) {
+        std::erase_if(locationSubscriptions, [subscriptionId](auto& subscription) { return subscription.id == subscriptionId; });
+    }
+};
+
+}

TactilityHeadless/Include/Tactility/hal/gps/GpsDeviceInitDefault.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <Tactility/hal/uart/Uart.h>
+
+namespace tt::hal::gps {
+
+bool initGpsDefault(uart_port_t port);
+
+}

TactilityHeadless/Include/Tactility/hal/gps/Satellites.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <Tactility/RtosCompat.h>
+#include <Tactility/Mutex.h>
+
+#include <minmea.h>
+
+#include <ranges>
+#include <memory>
+
+namespace tt::hal::gps {
+
+/** Thread-safe storage of recent satellites */
+class SatelliteStorage {
+
+public:
+
+    static constexpr size_t recordCount = 32;
+
+private:
+
+    struct SatelliteRecord {
+        minmea_sat_info data {
+            .nr = 0,
+            .elevation = 0,
+            .azimuth = 0,
+            .snr = 0
+        };
+        TickType_t lastUpdated = 0;
+        bool inUse = false;
+    };
+
+    Mutex mutex = Mutex(Mutex::Type::Recursive);
+    std::array<SatelliteRecord, recordCount> records;
+    uint16_t recycleTimeSeconds;
+    uint16_t recentTimeSeconds;
+
+    SatelliteRecord* findRecord(int number);
+
+    SatelliteRecord* findUnusedRecord();
+
+    SatelliteRecord* findRecordToRecycle();
+
+    /** Tries to find an existing record, otherwise return a free one, otherwise return the oldest active one */
+    SatelliteRecord* findWithFallback(int number);
+
+public:
+
+    explicit SatelliteStorage(
+        uint16_t recycleTimeSeconds = 120,
+        uint16_t recentTimeSeconds = 60
+    ) : recycleTimeSeconds(recycleTimeSeconds), recentTimeSeconds(recentTimeSeconds) {}
+
+    void notify(const minmea_sat_info& info);
+
+    void getRecords(const std::function<void(const minmea_sat_info&)>& onRecord) const;
+};
+
+} // namespace tt::hal::gps