Module.h

Go to the documentation of this file.

#include "..\Bass.h"
#include "..\Joystick.h"
#include "Watch.h"
#include "../Library/Solar.h"
#include <atltime.h>

class Module
{
private:
        Module();

protected:
        Bus* bus;

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

        virtual void FrameMove(float fElapsedTime) = 0;

        virtual ~Module()
        {
        };
};


class Gpws : public Module
{
private:
        float secsincelast = 0;

public:
        explicit Gpws(Bus* prmBus);
        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;
};

class Vmu : public Module
{
private:
        Devices::Bass* bass = nullptr; // then initialize wires up the device pointer
        float secsincelast = 0; // TimeSinceAuralWarning was static back in the Viewscreen days

        float* vmuGetFloatPtr = nullptr;
        bool powered = false;
        float secondsPowered = 0.0f;

public:
        int soundDevice = -1; // config sets the device id first

        Vmu(Bus* prmBus, int bassLocation, float* prmGetFloatPtr);
        void Initialize(Devices::Bass* prmBass);
        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;
};

class Cas : public Module
{
private:
        std::vector<Message> messages;
        bool MessageFlashState = false;

        float secsincelast = -2.0f; 
        float secsincereset = 0.0f; 
        Logger* logger = nullptr;
        std::vector<Watch> watches;

        float* casGetFloatPtr = nullptr;
        bool powered = false;

        void AcknowledgeAllMessages() const;
        void UnacknowledgeAllMessages();
        bool IsMessageOnStack(std::wstring text, bool renew) const;
        bool RemoveMessage(std::wstring text) const;
        void AddMessage(std::wstring text, MessageLevel level, bool sendEmail);

public:

        Cas(Bus* prmBus, Logger* prmLogger, std::vector<Watch> watches, float* prmCasGetFloatPtr);
        void FrameMove(float fElapsedTime) override;
};

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]; 
                };

                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;
        struct 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();
};