FADEC.cpp

Go to the documentation of this file.

#include "Module.h"


void Fadec::FrameMove(float fElapsed)
{
        if (fElapsed > 1.0f || !bass)
        {
                if (flightControls.size() == 1 && flightControls.at(0)->IsActive())
                {
                        *fadecFaultPtr |= Systems::Fault::NoSignal; // ENG 1 TLA FAIL
                        bus->EngineThrustCommand[engineOrdinal] = -999.0f;
                }
                return;
        }

#pragma region Command Handler
        for (UINT i = 0; i < bus->commandStream.size(); i++)
        {
                Command command = bus->commandStream.at(i);
                if (command.delay != 0.0f) continue;

                if (command.name == "EngineStart")
                {
                        if (command.ivalue == engineOrdinal)
                        {
                                if (engineStart || engineRun)
                                {
                                        *N1SetFloatPtr *= 0.9f;
                                        // bus->AirDensity *= 2.0f;
                                        // bus->AirDensity *= 0.5f;
                                }
                                else
                                {
                                        engineStart = true;
                                }
                                bus->commandStream.erase(bus->commandStream.begin() + i);
                        }
                }
                else if (command.name == "EngineStop")
                {
                        if (command.ivalue == engineOrdinal)
                        {
                                if (bus->EngineThrustCommand[engineOrdinal] == 0.0f || !engineRun)
                                {
                                        engineStart = engineRun = false;
                                }
                                else
                                {
                                        engineStopError = true;
                                        engineStopTimer = 0.0f;
                                }
                                bus->commandStream.erase(bus->commandStream.begin() + i);
                        }
                }
        }
#pragma endregion


#pragma region Game Controller Processing
        if (flightControls.size() == 1 && flightControls.at(0)->IsActive())
        {
                if (!bus->AFCS.AutothrottleEngaged)
                {
                        bus->EngineThrustCommand[engineOrdinal] = flightControls.at(0)->GetAxis(joystickAxis);

                        static bool moved = false;
                        if (moved || (bus->EngineThrustCommand[engineOrdinal] != 0.5f && bus->EngineThrustCommand[engineOrdinal] != 0.0f))
                                moved = true;
                        else
                                bus->EngineThrustCommand[engineOrdinal] = 0.0f;
                }
                else
                {
                        bus->EngineThrustCommand[engineOrdinal] = bus->AFCS.DesiredThrust;
                }

                *fadecFaultPtr &= ~Systems::Fault::NoSignal; // ENG 1 TLA FAIL
        }
        else
        {
                *fadecFaultPtr |= Systems::Fault::NoSignal; // ENG 1 TLA FAIL
                bus->EngineThrustCommand[engineOrdinal] = -999.0f;
        }
#pragma endregion


        // ENG 1 TLA NOT IDLE
        // set fault on FADEC component?
        if ((bus->EngineThrustCommand[engineOrdinal] > 0.005f && engineStart) || engineStopError)
        {
                *fadecFaultPtr |= Systems::Fault::Status1; // ENG_1_TLA_NOT_IDLE
        }
        else
        {
                *fadecFaultPtr &= ~Systems::Fault::Status1; // ENG_1_TLA_NOT_IDLE
        }

        if (!engineStart && engineRun && !engineLit) // shit is this a FADEC fault or an N1 fault?  same deal with FIRE is that an N1 fault or a fire detection system fault?!
        {
                *fadecFaultPtr |= Systems::Fault::Status2; // FAIL
        }
        else
        {
                *fadecFaultPtr &= ~Systems::Fault::Status2; // FAIL
        }

        if (!engineStart && !engineRun)
        {
                *fadecFaultPtr |= Systems::Fault::Status3; // OFF
        }
        else
        {
                *fadecFaultPtr &= ~Systems::Fault::Status3; // OFF
        }


        if (engineStopError)
        {
                engineStopTimer += fElapsed;
                if (engineStopTimer >= 3.0f)
                        engineStopError = false;
        }


        if (engineStart)
        {
                float maxEffectOfStarter = 0.5f; // 50% N2
                // .5-0 = .5, .5-.5 = 0
                *starterSetFloatPtr = (maxEffectOfStarter - min(maxEffectOfStarter, *N2SetFloatPtr)) / maxEffectOfStarter;

                /* *** here is the starter effectivity *** */
                *N2SetFloatPtr += *starterGetFloatPtr * fElapsed * 0.042f; 

                if (*N2GetFloatPtr >= 0.07f) // reading
                {
                        *ignitionSetFloatPtr = 1.0f; // loop A vs. B? probably need 2 components ... per engine... fadec cycles through them
                }
                if (*N2GetFloatPtr > 0.5f) // reading
                {
                        engineStart = false;
                        engineRun = true;
                        *ignitionSetFloatPtr = 0.0f; // loop A vs. B? probably need 2 components ... per engine... fadec cycles through them
                }
        }
        else
        {
                *starterSetFloatPtr = 0.0f;
                *ignitionSetFloatPtr = 0.0f; // loop A vs. B? probably need 2 components ... per engine... fadec cycles through them
        }
        bass->Play(prefix + "EngineStarter", -1.0f, *starterSetFloatPtr * 0.75f);


        bass->Play(prefix + "EngineN2", *N2SetFloatPtr * 2.0f, min(*N2SetFloatPtr, 1.0f));


        float airFrictionFactor = 7.0f * bus->AirDensity;

        float compressionRatio = (*N1SetFloatPtr + *N2SetFloatPtr) * 19.5f + 1.0f; // (1+1)*19.5 = 39X + 1X = 40X

        float tempN1 = powf(*N2SetFloatPtr, 2.7f); // find N1 speed based on N2 (the sound file info we have is based on N1 speed)
        // should be based on air density, no transfer if there is no density
        /* *** here is the N2 to N1 and vice-versa effectivity *** */
        float tempdiff = tempN1 - *N1SetFloatPtr;
        float N1toN1diff = tempdiff * fElapsed * compressionRatio * airFrictionFactor;
        *N1SetFloatPtr += N1toN1diff;
        *N2SetFloatPtr -= min(N1toN1diff, *N2SetFloatPtr);


        bass->Play(prefix + "EngineN1", *N1SetFloatPtr * 2.0f, min(*N1SetFloatPtr, 1.0f));


        *N1SetFloatPtr += bus->IndicatedAirspeed * fElapsed; // 3 or 4% in a strong wind, airspeed is in m/s strong wind is 0.013

        *N2SetFloatPtr -= min(0.002f * fElapsed, fabsf(*N2SetFloatPtr)) * copysignf(1, *N2SetFloatPtr);
        *N1SetFloatPtr -= min(0.002f * fElapsed, fabsf(*N1SetFloatPtr)) * copysignf(1, *N1SetFloatPtr); // bigger shaft, longer shaft

        /* *** here is the air friction effectivity *** */
        *N2SetFloatPtr -= min(powf(*N2SetFloatPtr, 2.0f) * fElapsed * airFrictionFactor *compressionRatio, fabsf(*N2SetFloatPtr)) * copysignf(1, *N2SetFloatPtr);
        *N1SetFloatPtr -= min(powf(*N1SetFloatPtr, 2.0f) * fElapsed * airFrictionFactor *compressionRatio, fabsf(*N1SetFloatPtr)) * copysignf(1, *N1SetFloatPtr);


        if (*N2GetFloatPtr >= 0.2f && (engineStart || engineRun)) // fuel starts at 20% reading
        {
                // meters idle flow based on N2 reading
                if (*N2GetFloatPtr < 0.5f)
                {
                        //if (!bus->OnGround || *ITTSetFloatPtr <= 120.0f)
                        {
                                // 70 at 20% to 225 at 60% and 186.25 at 50% 
                                // 0.03875 per percent above 20
                                *combustionSetFloatPtr = (*N2GetFloatPtr - 0.2f) * 600.0f + 70.0f; // get it up there a little faster hopefully with gusto

                                lightOffTimer += fElapsed;
                                if (lightOffTimer > 5.0f && !engineLit) // abort start
                                {
                                        engineStart = false;
                                        engineRun = false;
                                        lightOffTimer = 0.0f;
                                }
                        }
                }
                else 
                {
                        lightOffTimer = 0.0f;
                        float desired = max(0, bus->EngineThrustCommand[engineOrdinal]) * 1138.0f + 225.0f; // adjust for altitude?
                        float diff = desired - *combustionSetFloatPtr;
                        if (diff > 190) diff = 190;
                        if (diff < -190) diff = -190;
                        *combustionSetFloatPtr += diff * fElapsed;
                }
        }
        else
        {
                *combustionSetFloatPtr = 0.0f;
                if (*ITTSetFloatPtr < 245.0f) // autoignition temp
                        engineLit = false; 
                lightOffTimer = 0.0f;
        }


        if (*ignitionGetFloatPtr == 1.0f)
        {
                ignitionTimer += fElapsed;
                if (ignitionTimer > 0.25f)
                {
                        ignitionTimer = 0.0f;
                        bass->Play(prefix + "EngineIgniter", -1.0f, 0.1f); // pretty quiet
                        if (*combustionSetFloatPtr > 0.0f)
                        {
                                if (rand() > 16384) // 50% chance, should be dictated by damage, service life
                                {
                                        engineLit = true;
                                }
                        }
                }
        }


        if (engineLit)
        {
                /* *** here is the combustion effectivity *** */
                float thrustEffectivity = 0.000475f;

                float n2increaser = *combustionSetFloatPtr * fElapsed * thrustEffectivity;
                // not sure why but we need to ramp this N2 to N1 nonsense

                float n1rampNonsense = *combustionSetFloatPtr / 1363.0f * 0.975f + 0.025f;
                float n1increaser = n2increaser * n1rampNonsense;


                float ratio = *combustionSetFloatPtr / compressionRatio;
                if (ratio > 35.0f)
                {
                        // complete power loss at 40?  modulate=1 at 35, 0 at 40
                        float modulate = max(40.0f - ratio, 0.0f) / 5.0f;
                        n2increaser *= modulate;
                        n1increaser *= modulate;
                        bass->Play(prefix + "EngineStall");
                }

                *N2SetFloatPtr += n2increaser; // that fuel flow should give us 60% idle N2
                *N1SetFloatPtr += n1increaser; // that fuel flow should give us 60% idle N2

                if (*N2GetFloatPtr > 1.01f)
                        engineRun = false;

                // so if the oncoming pressure is too low for the combustion chamber pressure

                // so there is a maximum pressure you can create in the combustion chamber before you overcome the pressure coming from the n1/n2
                // if you exceed that then you get a compressor stall/surge and lose power and damage n1 and n2 
                // surge?
                // i am thinking surge comes out of high pressure turbine ... the combustion flow goes forward instead of back


                // loudness based on N1?
                //*N1SetFloatPtr *= 0.875f;
                //*N2SetFloatPtr *= 0.875f;
        }
        bass->Play(prefix + "EngineJet", -1.0f, *combustionSetFloatPtr / 1363.0f);


        // airspeed to combustion is temp ramp
        // compression will raise the temperature
        float desiredTemp = bus->OATorTAT * compressionRatio;
        // combustion will raise the temperature
        // for some reason I am 90 degrees off at 25% and perfect on the high end
        float tempeff;
        if (*N1SetFloatPtr < 0.25f)
                tempeff = powf(*N1SetFloatPtr / 0.25f, 0.0001f) * 95.0f;
        else
                tempeff = (1.0f - *N1SetFloatPtr) / 0.75f * 95.0f;
        float combustTemp = desiredTemp + *combustionSetFloatPtr * 1.45f + tempeff; // max adiabatic temp 2,230  1.636
        if (combustTemp > *ITTSetFloatPtr)
                *ITTSetFloatPtr += (combustTemp - *ITTSetFloatPtr) * fElapsed; // not dependant on airdensity because we are filling the chamber with fuel/oxidizer regardless?

        // we are actually injecting ambient air into the combustion chamber at a rate of N1
        *ITTSetFloatPtr += (desiredTemp - *ITTSetFloatPtr) * fElapsed * airFrictionFactor * powf(*N1SetFloatPtr, 2.0f) * 80.0f;


        float radiant = 0.1f; // 1°C per second
        *ITTSetFloatPtr += (desiredTemp - *ITTSetFloatPtr) * fElapsed * airFrictionFactor * radiant;


        bus->EngineThrustOutput[engineOrdinal] = 69690.7724f * *N1SetFloatPtr * *N1SetFloatPtr;







}

Fadec::Fadec(Bus* prmBus, int prmSoundDevice, int prmAxis, int prmOrdinal, std::string prmPrefix) : Module(prmBus)
{
        soundDevice = prmSoundDevice;
        joystickAxis = prmAxis;
        engineOrdinal = prmOrdinal;
        prefix = prmPrefix;

        bus->EngineThrustOutput[engineOrdinal] = 0.0f;
}

void Fadec::Initialize(Devices::Joystick* prmFlightControl, Devices::Bass* prmBass)
{
        if (prmFlightControl)
                flightControls.push_back(prmFlightControl);
        if (prmBass)
                bass = prmBass;
}

void Fadec::ConnectComponent(std::string type, std::string guid)
{
        if (type == "FADEC")
        {
                fadecGetFloatPtr = bus->GetComponentCurrentStatePtr(guid);
                fadecFaultPtr = (DWORD*)bus->GetComponentFaultStatePtr(guid);
        }
        if (type == "Starter")
        {
                starterSetFloatPtr = bus->GetComponentSetStatePtr(guid);
                // we set based on differential ... but then actual work accomplished for the noise level is based on damage...?
                starterGetFloatPtr = bus->GetComponentCurrentStatePtr(guid);
        }
        if (type == "N2")
        {
                N2SetFloatPtr = bus->GetComponentSetStatePtr(guid);
                // not sure how to reconcile differcen between N2 set and get ... there are more complicated things going on than just the speed (core lock fault?)
                N2GetFloatPtr = bus->GetComponentCurrentStatePtr(guid);
        }
        if (type == "N1")
        {
                N1SetFloatPtr = bus->GetComponentSetStatePtr(guid);
                // So we drive the N1 directly ... but it can still run faults which will jack with the indication... and anything that INDICATION is used for in here must use a GET pointer too
                N1FaultPtr = (DWORD*)bus->GetComponentFaultStatePtr(guid);
        }
        if (type == "IgniterA")
        {
                ignitionSetFloatPtr = bus->GetComponentSetStatePtr(guid);
                ignitionGetFloatPtr = bus->GetComponentCurrentStatePtr(guid);
        }
        if (type == "Combustion")
        {
                combustionSetFloatPtr = bus->GetComponentSetStatePtr(guid);
                // starter to N2 ramp - the further apart they are the more noise the starter makes, more load, more heat
                // N2 is in percentage of max, N2 doesn't affect starter if N2 is faster than 50%
        }
        if (type == "ITT")
        {
                ITTSetFloatPtr = bus->GetComponentSetStatePtr(guid);
                *ITTSetFloatPtr = bus->OATorTAT;
        }
}

/*
CAS messages
http://screencast.com/t/HTZAvzFF
http://screencast.com/t/74G6ns10VFtA
*/