CAS.cpp

Go to the documentation of this file.

#include "Module.h"
#include <algorithm> // for std::sort



void Cas::FrameMove(float fElapsed)
{
        bool oldpowered = powered;
        powered = *casGetFloatPtr > 0;
        if (!oldpowered) // was unpowered
        {
                if (powered) // now powered, make it look like it was just switched on!
                {
                        secsincelast = -2.0f; // 2 second intro delay
                }
        }
        else
        {
                if (secsincelast < 0.0f) // 2 second power-up delay
                {
                        secsincelast += fElapsed;
                        if (secsincelast >= 0.0f)
                        {
                                secsincelast = 2.0f;
                                UnacknowledgeAllMessages(); // reset on power-up
                                secsincereset = 0.0f; // will delay sending emails for 2 seconds
                        }
                }
                else
                {
                        secsincelast += fElapsed;
                }
        }

        secsincereset += fElapsed;
        if (secsincereset > 500.0f)
                secsincereset = 500.0f;


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

                if (command.name == "AcknowledgeAllMessages")
                {
                        AcknowledgeAllMessages();
                        bus->commandStream.erase(bus->commandStream.begin() + i);
                }
        }


#pragma region Watches
        for (UINT i = 0; i < watches.size(); i++)
        {
                if (!watches.at(i).currentState)
                        watches.at(i).currentState = bus->GetComponentCurrentStatePtr(watches.at(i).guid);
                if (!watches.at(i).faultState)
                        watches.at(i).faultState = bus->GetComponentFaultStatePtr(watches.at(i).guid);

                bool removedOne = false, addedOne = false, breakOut = false;
                for (UINT j = 0; j < watches.at(i).conditions.size(); j++)
                {
                        watches.at(i).conditions.at(j).secondsSinceLast += fElapsed;
                        if (!addedOne && watches.at(i).conditions.at(j).fault.is_set() && watches.at(i).conditions.at(j).fault.get() & *watches.at(i).faultState)
                        {
                                if (!watches.at(i).conditions.at(j).messageOnStack)
                                {
                                        AddMessage(watches.at(i).conditions.at(j).message, watches.at(i).conditions.at(j).level, watches.at(i).sendEmail);
                                        watches.at(i).conditions.at(j).messageOnStack = true;
                                        breakOut = true;
                                }
                                addedOne = true;
                        }
                        else if (!addedOne && watches.at(i).conditions.at(j).below.is_set() && *watches.at(i).currentState < watches.at(i).conditions.at(j).below)
                        {
                                bool reTrip = watches.at(i).conditions.at(j).repeatBelow.is_set() && *watches.at(i).currentState < watches.at(i).conditions.at(j).repeatBelow && watches.at(i).conditions.at(j).secondsSinceLast > 60.0f;
                                if (!watches.at(i).conditions.at(j).messageOnStack || reTrip)
                                {
                                        AddMessage(watches.at(i).conditions.at(j).message, watches.at(i).conditions.at(j).level, watches.at(i).sendEmail);
                                        watches.at(i).conditions.at(j).secondsSinceLast = 0.0f;
                                        watches.at(i).conditions.at(j).messageOnStack = true;
                                        breakOut = true;
                                }
                                addedOne = true;
                        }
                        else if (!addedOne && watches.at(i).conditions.at(j).above.is_set() && *watches.at(i).currentState > watches.at(i).conditions.at(j).above)
                        {
                                bool reTrip = watches.at(i).conditions.at(j).repeatAbove.is_set() && *watches.at(i).currentState > watches.at(i).conditions.at(j).repeatAbove && watches.at(i).conditions.at(j).secondsSinceLast > 60.0f;
                                if (!watches.at(i).conditions.at(j).messageOnStack || reTrip)
                                {
                                        AddMessage(watches.at(i).conditions.at(j).message, watches.at(i).conditions.at(j).level, watches.at(i).sendEmail);
                                        watches.at(i).conditions.at(j).secondsSinceLast = 0.0f;
                                        watches.at(i).conditions.at(j).messageOnStack = true;
                                        breakOut = true;
                                }
                                addedOne = true;
                        }
                        else if (addedOne || watches.at(i).conditions.at(j).messageOnStack)
                        {
                                breakOut = RemoveMessage(watches.at(i).conditions.at(j).message);
                                watches.at(i).conditions.at(j).messageOnStack = false;
                                removedOne = true;
                        }
                }

                if (!addedOne && removedOne && !watches.at(i).onClear.empty())
                {
                        bool quiet = false;
                        if (watches.at(i).quietStart.is_set() && watches.at(i).quietEnd.is_set())
                        {
                                SYSTEMTIME st;
                                GetLocalTime(&st);
                                if (st.wHour > watches.at(i).quietStart.get().wHour || (st.wHour == watches.at(i).quietStart.get().wHour && st.wMinute >= watches.at(i).quietStart.get().wMinute))
                                        quiet = true;
                                if (st.wHour < watches.at(i).quietEnd.get().wHour || (st.wHour == watches.at(i).quietEnd.get().wHour && st.wMinute < watches.at(i).quietEnd.get().wMinute))
                                        quiet = true;
                        }
                        if (!quiet && watches.at(i).sendEmail)
                        {
                                Command command;
                                command.name = "SendEmail";
                                strcpy_s(command.svalue, 64, watches.at(i).onClear.c_str());
                                bus->commandStream.push_back(command);
                        }
                        else
                        {
                                char msg[199];
                                sprintf_s(msg, 199, "Cas::FrameMove Did not send clear message due to quiet time: %s", watches.at(i).onClear.c_str());
                                logger->Log(msg);
                        }
                }
                if (breakOut) break;
        }
#pragma endregion


        bus->MasterWarning = false;
        for (UINT i = 0; i < bus->messages.size(); i++)
        {
                if (!bus->messages.at(i).acknowledged)
                {
                        if (bus->messages.at(i).level == Advisory)
                        {
                                if ((bus->ProgramTime - bus->messages.at(i).time) > 5.0f)
                                {
                                        bus->messages.at(i).acknowledged = true;
                                }
                        }
                        if (bus->messages.at(i).level == Warning)
                        {
                                bus->MasterWarning = true;
                        }
                }
        }
}

Cas::Cas(Bus* prmBus, Logger* prmLogger, std::vector<Watch> prmWatches, float* prmGetFloatPtr) : Module(prmBus)
{
        logger = prmLogger;
        watches = prmWatches;
        casGetFloatPtr = prmGetFloatPtr;
}

void Cas::AcknowledgeAllMessages() const
{
        for (UINT i = 0; i < bus->messages.size(); i++)
        {
                bus->messages.at(i).acknowledged = true;
        }
        logger->Log("CAS::AcknowledgeAllMessages Completed!");
}

bool Cas::IsMessageOnStack(std::wstring text, bool renew) const
{
        for (UINT i = 0; i < bus->messages.size(); i++)
        {
                if (bus->messages.at(i).text == text)
                {
                        if (renew)
                        {
                                bus->messages.at(i).acknowledged = false; // trip again
                                bus->messages.at(i).time = bus->ProgramTime;
                                char msg[99];
                                sprintf_s(msg, 99, "CAS::IsMessageOnStack Retripped: %S", bus->messages.at(i).text.c_str());
                                logger->Log(msg);

                                std::sort(bus->messages.begin(), bus->messages.end());
                        }
                        return true;
                }
        }
        return false;
}

bool Cas::RemoveMessage(std::wstring text) const
{
        for (UINT i = 0; i < bus->messages.size(); i++)
        {
                if (bus->messages.at(i).text == text)
                {
                        bus->messages.erase(bus->messages.begin() + i);
                        char msg[99];
                        sprintf_s(msg, 99, "CAS::RemoveMessage Removed: %S", text.c_str());
                        logger->Log(msg);
                        return true;
                }
        }
        return false;
}

void Cas::AddMessage(std::wstring text, MessageLevel level, bool sendEmail)
{
        if (level == Environmental && sendEmail && secsincereset >= 2.0f)
        {
                Command command;
                command.name = "SendEmail";
                sprintf_s(command.svalue, 64, "%S", text.c_str());
                bus->commandStream.push_back(command);
        }

        if (!IsMessageOnStack(text, true))
        {
                Message message;
                message.acknowledged = false;
                message.text = text;
                message.level = level;
                message.time = bus->ProgramTime;
                bus->messages.push_back(message);
                char msg[99];
                sprintf_s(msg, 99, "CAS::AddMessage Added: %S (%i)", text.c_str(), level);
                logger->Log(msg);

                std::sort(bus->messages.begin(), bus->messages.end());

                if (secsincelast >= 2.0f) // this or VMU?
                {
                        if (level == Warning)
                        {
                                Command newCommand;
                                newCommand.name = "CASMasterWarningChime";
                                bus->commandStream.push_back(newCommand);
                                logger->Log("CAS::AddMessage MasterWarningChime requested!");
                                secsincelast = 0.0f;
                                return;
                        }
                        if (level == Environmental || level == Caution)
                        {
                                Command newCommand;
                                newCommand.name = "CASMasterCautionChime";
                                bus->commandStream.push_back(newCommand);
                                logger->Log("CAS::AddMessage MasterCautionChime requested!");
                                secsincelast = 0.0f;
                        }
                }
        }
}

void Cas::UnacknowledgeAllMessages()
{
        bus->messages.clear();

        for (UINT w = 0; w < watches.size(); w++)
        {
                for (UINT c = 0; c < watches.at(w).conditions.size(); c++)
                {
                        watches.at(w).conditions.at(c).messageOnStack = false;
                }
        }

        logger->Log("CAS::UnacknowledgeAllMessages Completed!");
}