feat: create HotFireInterface

Author: jonapap

projects/HotFire/config.h

@@ -5,6 +5,7 @@
 // clang-format off
 
 #define STATEMACHINE HotFireStateMachine
+#define INTERFACE HotFireInterface
 
 #ifndef USE_SBG
     #define USE_SBG 0

src/init/MainLoop.cpp

@@ -5,9 +5,9 @@
 
 #include "helpers/Helper.h"
 
-#include "IO/InterfaceImpl.h"
 #include "chrono"
 #include "data/UOSMData.h"
+#include "interface/HotFire/HotFireInterface.h"
 #include "spdlog/sinks/basic_file_sink.h"
 #include "spdlog/sinks/dup_filter_sink.h"
 #include "spdlog/sinks/stdout_color_sinks.h"
@@ -74,7 +74,7 @@ int main()
     SPDLOG_INFO("Using {}", TOSTRING(STATEMACHINE));
 
 #if TESTING != 1
-    InterfaceImpl interfaceImpl;
+    INTERFACE interfaceImpl;
 #else
     TestingInterface interfaceImpl;
 #endif

src/interface/HotFire/HotFireInterface.cpp

@@ -0,0 +1,101 @@
+#include "config.h"
+
+#include "HotFireInterface.h"
+#include "common/pch.h"
+#include <chrono>
+#include <spdlog/spdlog.h>
+#include <string>
+
+HotFireInterface::HotFireInterface()
+    : eventQueue(), input(eventQueue), client(eventQueue), arduinoProxy(ArduinoProxy::getInstance())
+{
+    logger = spdlog::default_logger();
+}
+
+HotFireInterface::~HotFireInterface() = default;
+
+void HotFireInterface::initialize()
+{
+    initializeInputs();
+    initializeOutputs();
+}
+
+void HotFireInterface::initializeInputs()
+{
+    SPDLOG_LOGGER_INFO(logger, "Initializing INPUT...");
+    input.initialize();
+    SPDLOG_LOGGER_INFO(logger, "Initializing SOCKET_CLIENT...");
+    client.initialize();
+    SPDLOG_LOGGER_INFO(logger, "Initializing SENSORS...");
+    sensors.initialize();
+}
+
+void HotFireInterface::initializeOutputs()
+{
+    SPDLOG_LOGGER_INFO(logger, "Initializing SENSOR_LOGGER...");
+    sensorLogger.initialize();
+    SPDLOG_LOGGER_INFO(logger, "Initializing GPIO...");
+    gpio.initialize();
+    SPDLOG_LOGGER_INFO(logger, "Initializing Arduino Proxy...");
+    arduinoProxy->initialize();
+}
+
+bool HotFireInterface::updateInputs()
+{
+    latestState = std::make_shared<StateData>();
+
+    latestState->timeStamp =
+        std::chrono::duration_cast<time_point::duration>(std::chrono::steady_clock::now().time_since_epoch()).count();
+
+    // EventQueue
+    latestState->eventNumber = eventQueue.pop();
+    // Logger
+    latestState->loggerIsInitialized = sensorLogger.isInitialized();
+    // Socket Client
+    latestState->clientIsInitialized = client.isInitialized();
+    latestState->lastActiveClientTimestamp = client.getLastConnectionTimestamp();
+    // Input
+    latestState->inputIsInitialized = input.isInitialized();
+    // GPIO
+    latestState->gpioIsInitialized = gpio.isInitialized();
+    latestState->gpioState = gpio.getCurrentState();
+    // Arduino Proxy
+    latestState->arduinoProxyIsInitialized = arduinoProxy->isInitialized();
+    // Sensors
+    latestState->sensorState = sensors.getCurrentState();
+
+    return true;
+}
+
+bool HotFireInterface::updateOutputs(std::shared_ptr<StateData> data)
+{
+
+    data->gpioData = gpio.setOutputs(data->gpioData);
+    sensorLogger.enqueueSensorData(*data);
+    client.enqueueSensorData(*data);
+
+    return true;
+}
+
+void HotFireInterface::createNewGpioOutput(std::string name, int pinNbr)
+{
+    gpio.createNewGpioOutput(name, pinNbr);
+}
+
+void HotFireInterface::createNewGpioPwmOutput(std::string name, int pinNbr, int safePosition, bool softpwm)
+{
+    gpio.createNewGpioPwmOutput(name, pinNbr, safePosition, softpwm);
+}
+
+std::shared_ptr<StateData> HotFireInterface::getLatest()
+{
+
+    latestState->loggerWorking = SensorLogger::working;
+
+    return latestState;
+}
+
+time_point HotFireInterface::getCurrentTime()
+{
+    return std::chrono::steady_clock::now();
+}

src/interface/HotFire/HotFireInterface.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include "config.h"
+#if TESTING != 1
+
+#include "IO/ArduinoProxy.h"
+#include "IO/Input.h"
+#include "IO/Radio.h"
+#include "IO/SBGSensor.h"
+#include "IO/SensorLogger.h"
+#include "IO/gpio/Gpio.h"
+#include "IO/tcp/SocketServer.h"
+#include <IO/Sensors.h>
+#include <interface/Interface.h>
+#include <memory>
+#include <spdlog/logger.h>
+#include <string>
+
+class HotFireInterface : public Interface
+{
+  public:
+    HotFireInterface();
+    ~HotFireInterface();
+
+    void initialize() override;
+
+    // to get the latest rocket state. return a pointer to latestState
+    std::shared_ptr<StateData> getLatest() override;
+
+    // loop over each sensor and update the latestState
+    bool updateInputs() override;
+    bool updateOutputs(std::shared_ptr<StateData> data) override;
+
+    void createNewGpioOutput(std::string name, int pinNbr) override;
+    void createNewGpioPwmOutput(std::string name, int pinNbr, int safePosition, bool softpwm) override;
+
+    time_point getCurrentTime() override;
+
+  private:
+    void initializeInputs();
+    void initializeOutputs();
+
+    std::shared_ptr<spdlog::logger> logger;
+
+    std::shared_ptr<StateData> latestState;
+    EventQueue eventQueue;
+
+    /**
+     * IO instances
+     */
+    Input input;
+    SocketServer client;
+    SensorLogger sensorLogger;
+    Gpio gpio;
+    ArduinoProxy *arduinoProxy;
+    Sensors sensors;
+};
+
+#endif

src/interface/Interface.h

@@ -11,7 +11,7 @@ class Interface
   public:
     virtual void initialize() = 0;
 
-    virtual void calibrateTelemetry() = 0;
+    virtual void calibrateTelemetry(){};
 
     // to get the latest rocket state. return a pointer to latestState
     virtual std::shared_ptr<StateData> getLatest() = 0;
@@ -21,13 +21,9 @@ class Interface
 
     virtual bool updateOutputs(std::shared_ptr<StateData> data) = 0;
 
-#if USE_GPIO == 1
+    virtual void createNewGpioOutput(std::string name, int pinNbr){};
 
-    virtual void createNewGpioOutput(std::string name, int pinNbr) = 0;
-
-    virtual void createNewGpioPwmOutput(std::string name, int pinNbr, int safePosition, bool softpwm) = 0;
-
-#endif
+    virtual void createNewGpioPwmOutput(std::string name, int pinNbr, int safePosition, bool softpwm){};
 
     virtual time_point getCurrentTime() = 0;
 };