Module.h

Go to the documentation of this file.

#pragma once

// @brief Abstract base class for modules
// By definition, instruments don't do any of the work (they don't modify bus values)
// If you have something that takes data like VSI and AGL and then triggers GPWS messages on the bus then that would be in a module
// It is a computer but not on the component level, it only has access to bus values from other modules

#include "../Bus.h"
#include "../GridProperties.h"
#include "../Sound.h"

class Module
{
        Module();

protected:
        Bus* bus;

public:
        Module(Bus* prmBus)
        {
                bus = prmBus;
        };

        virtual void FrameMove(float fElapsedTime) = 0;

        // Polymorphism gotcha - if this isn't here then std::vector embedded in derived classes don't clean up!
        // My theory is that they won't inherit a public destructor if one isn't declared in the base class
        virtual ~Module() = default;;
};

// Forward definitions for the modules are below

// Ground Proximity Warning System
class Gpws : public Module
{
        Logger* logger = nullptr;

        float secsincelast = 0.0f;
        float oldradioaltitude = 0.0f;
        bool mode3active = false;
        float mode3altitude = 0.0f;
        Reference oldReference = REF_ACLMODE;
        float oldIndicatedAirspeedKms = FLT_MAX;
        float oldWindSpeedMs = 0.0f;

public:
        Gpws(Bus* prmBus, Logger* prmLogger);
        void FrameMove(float fElapsedTime) override;
};

//class Tcas : public Module
//{
//private:
//      float secsincelast = 0;
//      int testProgress = 0;
//
//public:
//      explicit Tcas(Bus* prmBus);
//      void FrameMove(float fElapsedTime) override;
//};

// Voice Messaging Unit
class Vmu : public Module
{
        Logger* logger = nullptr;
        Sound* sound = nullptr;

        float holdForSeconds = 0;
        bool powered = false;
        float secondsPowered = 0.0f;
        int testMode = SOUND_AURALUNITOKAY + 1;

public:
        Vmu(Bus* prmBus, Logger* prmLogger, Sound* prmSound);
        void FrameMove(float fElapsedTime) override;
};

//class Fcs : public Module
//{
//private:
//      struct Location
//      {
//              bool priorityButtonDown = false;
//              float priorityHeldDownSec = 0.0f;
//      };
//
//      std::vector<Location> locations;
//
//      int ControlPriorityLocation = -1;
//      bool ControlPriorityLatched = false;
//
//      std::vector<Devices::Joystick*> flightControls;
//
//      DWORD* fcsFaultPtr = nullptr;
//      float* fcsGetFloatPtr = nullptr;
//
//public:
//      Fcs(Bus* prmBus, int joysticks);
//      void Initialize(Devices::Joystick* prmFlightControl);
//      void ConnectComponent(std::string name, std::string guid);
//      void FrameMove(float fElapsedTime) override;
//};
//
//class Fadec : public Module
//{
//private:
//      std::vector<Devices::Joystick*> flightControls;
//      Devices::Bass* bass = nullptr;
//
//      bool engineStart = false;
//      bool engineRun = false;
//      bool engineLit = false;
//      float lightOffTimer = 0.0f;
//      float ignitionTimer = 0.0f;
//      bool engineStopError = false;
//      float engineStopTimer = 0.0f;
//
//      DWORD* fadecFaultPtr = nullptr;
//      float* fadecGetFloatPtr = nullptr;
//      float* starterSetFloatPtr = nullptr;
//      float* starterGetFloatPtr = nullptr;
//      float* N2SetFloatPtr = nullptr;
//      float* N2GetFloatPtr = nullptr;
//      DWORD* N1FaultPtr = nullptr;
//      float* N1SetFloatPtr = nullptr;
//      float* ignitionSetFloatPtr = nullptr;
//      float* ignitionGetFloatPtr = nullptr;
//      float* combustionSetFloatPtr = nullptr;
//      float* ITTSetFloatPtr = nullptr;
//
//public:
//      int soundDevice = -1; // config sets the device id first
//      int joystickAxis = 0;
//      int engineOrdinal = 0;
//      std::string prefix = "Left";
//
//      Fadec(Bus* prmBus, int prmSoundDevice, int prmAxis, int prmOrdinal, std::string prmPrefix);
//      void Initialize(Devices::Joystick* prmFlightControl, Devices::Bass* prmBass);
//      void ConnectComponent(std::string name, std::string guid);
//      void FrameMove(float fElapsedTime) override;
//};

// Crew Alerting System
class Cas : public Module
{
        std::vector<Message> messages;

        float secsincelast = -2.0f; // 2 second power up delay
        int evaluating = 0;
        bool inhibit = false;
        float weightOffWheelsTime = 0.0f;
        float weightOnWheelsTime = 0.0f;
        float below400Time = 0.0f;
        WCHAR temporaryMessage[99];

        Logger* logger = nullptr;
        Sound* sound = nullptr;

        void AcknowledgeAllMessages() const;
        bool IsMessageOnStack(std::wstring text, MessageLevel level, bool renew) const;
        bool RemoveMessage(const std::wstring& text, bool onlyIfAcknowledged = false) const;
        bool AddMessage(const std::wstring& text, MessageLevel level, bool renew);

public:
        Cas(Bus* prmBus, Logger* prmLogger, Sound* prmSound);
        void FrameMove(float fElapsedTime) override;
};

// Ice Detector
class IceDetector : public Module
{
        Logger* logger = nullptr;

        float heatOnTime = 0.0f;
        float heatOffTime = 0.0f;

public:
        IceDetector(Bus* prmBus, Logger* prmLogger);
        void FrameMove(float fElapsedTime) override;
};

// Radio Tuning Unit
//class Rtu : public Module
//{
//private:
//      Logger* logger;
//public:
//      Rtu(Bus* prmBus, Logger* prmLogger);
//      void FrameMove(float fElapsedTime) override;
//};
//
//class Mcu : public Module
//{
//private:
//      int sequencer = 0;
//      // 0 is off, safe
//      // 1 is caution lights on, wait 5 seconds
//      // 2 is motion power on, wait 5 seconds
//      // 3 is load mid-level, wait 5 seconds
//      // 4 is motion running, watch emer stop
//      // 5 is load mid-level, wait 5 seconds
//      // 6 is load off-level, wait 5 seconds
//      // 7 is motion power off, wait 5 seconds
//      // 8 is caution lights off
//      float timer = 0.0f;
//      int testmode = 0;
//      float* emergencyStopGetPtr = nullptr;
//
//      struct SSnap
//      {
//              float fl, fr, bl, br;
//      };
//
//      SSnap Locations[11];
//      SSnap current;
//
//      Logger* logger;
//
//public:
//      Mcu(Bus* prmBus, Logger* prmLogger);
//      void FrameMove(float fElapsedTime) override;
//};
//
//class Pfd : public Module
//{
//private:
//      Logger* logger;
//
//      struct SLight
//      {
//              std::string command;
//              bool currentState, requestedState;
//              int strategy; // 0=off, 1=blink, 2=solid
//      } lights[10];
//
//      float timer = 0.0f;
//public:
//      Pfd(Bus* prmBus, Logger* prmLogger);
//      void FrameMove(float fElapsedTime) override;
//};
//
//class Afcs : public Module
//{
//private:
//      Logger* logger;
//      Bus* bus;
//      float oldDesiredVsi = 0.0f;
//      const float PitchAggression = 2.0f; // agressiveness for pitch on autopilot (2 is standard)
//      const float RollAggression = 2.0f; // agressiveness for roll on autopilot (1 is standard)
//      const float Vs1 = 0.030f; // kms for speeds
//      bool rightSide = true;
//      float oldRollAttitude = 0.0f;
//      float oldPitchAttitude = 0.0f;
//
//public:
//      Afcs(Bus* prmBus, Logger* prmLogger);
//      void FrameMove(float fElapsedTime) override;
//
//      Afcs& operator=(const Afcs&)
//      {
//              return *this;
//      }
//};
//
//class Ase : public Module
//{
//public:
//      struct SVoice
//      {
//              std::string eid;
//              std::string lid;
//              std::string vid;
//              std::string fxtype;
//              std::string fxlevel;
//      };
//
//      struct SVocalware
//      {
//              std::string acc;
//              std::string api;
//              std::string secret;
//              std::vector<SVoice> voices;
//      };
//
//private:
//      UINT currentStep = 0;
//      int subStep = 0;
//      bool scenarioLoaded = false;
//      float occupantControlAuthority = 0.0f;
//      HSTREAM stream = 0;
//
//      struct SCommand
//      {
//              std::string vmu;
//              UINT voice = 0;
//
//              std::string name;
//
//              union
//              {
//                      int ivalue;
//                      float fvalue;
//                      bool bvalue;
//                      char svalue[64]; /// @todo union doesn't allow std::string, see note below about emailBody
//              };
//
//              std::string jump;
//
//              std::string wait;
//              float timeout = 600.0f;
//              float timeoutLeft;
//              std::string timeoutStep;
//              DWORD conditionsMet;
//
//              std::string help;
//              std::string element;
//      };
//
//      struct SStep
//      {
//              std::string name;
//              std::vector<SCommand> commands;
//      };
//
//      std::vector<SStep> steps;
//
//
//      Bus* bus;
//      Logger* logger;
//      Devices::Bass* bass = nullptr;
//      SVocalware vocalware;
//
//      void Ase::LoadScenario(std::string path);
//      bool Ase::GenerateTextToSpeech(std::string url, UINT voice, std::string outputPath);
//      UINT Ase::FindStep(std::string stepName);
//      void Ase::AdvanceToNextStep();
//
//public:
//      int soundDevice = -1; // config sets the device id first
//      Ase(Bus* prmBus, Logger* prmLogger, int prmSoundDevice, SVocalware vocalware);
//      void Initialize(Devices::Bass* prmBass);
//      void FrameMove(float fElapsedTime) override;
//};
//
//class Fms : public Module
//{
//private:
//      Logger* logger;
//      Bus* bus;
//
//public:
//      Fms(Bus* prmBus, Logger* prmLogger);
//      void FrameMove(float fElapsedTime) override;
//};
//
//class Fdr : public Module
//{
//private:
//      Logger* logger;
//      Bus* bus;
//      float secSinceLast = 0.0f;
//      int fdrfile;
//
//public:
//      Fdr(Bus* prmBus, Logger* prmLogger);
//      void FrameMove(float fElapsedTime) override;
//      ~Fdr();
//};
//
//class Door : public Module
//{
//private:
//      Logger* logger;
//      Bus* bus;
//
//      bool open = false;
//      float timeSinceLast = 0.0f;
//
//      float* sensorPsi = nullptr;
//      float* doorSensor = nullptr;
//      float* compressorOn = nullptr;
//
//      float dutyTime = 0.0f;
//
//public:
//      Door(Bus* prmBus, Logger* prmLogger);
//      void FrameMove(float fElapsedTime) override;
//      ~Door();
//};
//
//class Logo : public Module
//{
//private:
//      Logger* logger;
//      Bus* bus;
//      float latitude = 0.0f, longitude = 0.0f, altitudeFeet = 0.0f, zenithDegrees = 0.0f;
//      float timeSinceLast = 60.0f;
//
//      float* sunrise = nullptr;
//      float* sunset = nullptr;
//      float* status = nullptr;
//      
//      time_t t = 0;
//      tm* lt = nullptr;
//      TIME_ZONE_INFORMATION tz;
//      Library::Solar solar;
//      CTime cTime;
//
//public:
//      Logo(Bus* prmBus, Logger* prmLogger, float prmLatitude, float prmLongitude, float prmAltitudeFeet, float prmZenithDegrees);
//      void FrameMove(float fElapsedTime) override;
//      ~Logo();
//};

class MarkerBeacons : public Module
{
        Logger* logger = nullptr;
        Sound* sound = nullptr;

        Bus::MarkerBeaconTypes checking = Bus::MarkerBeaconTypes::None;
        GridProperties* gridProperties = nullptr;

        void Check(const D3DXVECTOR3& marker) const;

public:
        MarkerBeacons(Bus* prmBus, Logger* prmLogger, Sound* prmSound, GridProperties* prmGridProperties);
        void FrameMove(float fElapsedTime) override;
};

class TCAS : public Module
{
        Logger* logger = nullptr;
        D3DXMATRIX* matrixView = nullptr;

        Bus::TcasEnum tcasmode = Bus::TcasEnum::Clear_Of_Conflict;
        float secsincelast = 0.0f;
        float coctime = 0.0f;
        float advanceframe = 0.0f;
        float olddistance[MAX_SCAN];

public:
        TCAS(Bus* prmBus, Logger* prmLogger, D3DXMATRIX* prmMatrixView);
        void FrameMove(float fElapsedTime) override;
};