int StateMachineFeedback::CheckLimits ( const float *  I )

inlineprivate

Definition at line 350 of file feedback.cc.

References Error(), Feedback::State::kCritical, Feedback::State::kInProgress, Feedback::State::kOnStandby, Feedback::State::kWarning, and Dim::SendCommandNB().

    {
        const float fAbsoluteMedianCurrentLimit   = 85;
        const float fRelativePixelCurrentLimit3   = 20;
        const float fRelativePixelCurrentLimit0   = 45;

        const float fAbsolutePixelCurrentLimit3   = fAbsoluteMedianCurrentLimit + fRelativePixelCurrentLimit3;
        const float fAbsolutePixelCurrentLimit0   = fAbsoluteMedianCurrentLimit + fRelativePixelCurrentLimit0;

        const float fRelativeCurrentLimitWarning  = 10;//10;
        const float fRelativeCurrentLimitCritical = 15;//20;
        const float fRelativeCurrentLimitShutdown = 25;

        fTimeoutCritical = 3000; // 5s

        // Copy the calibrated currents
        vector<float> v(I, I+320);

        // Exclude the crazy patches (that's currently the best which could be done)
        v[66]  = 0;
        v[191] = 0;
        v[193] = 0;

        sort(v.begin(), v.end());

        const float &imax0 = v[319];
        const float &imax3 = v[316];
        const float &imed  = v[161];

        const bool shutdown =
            imed >fAbsoluteMedianCurrentLimit+fRelativeCurrentLimitShutdown ||
            imax3>fAbsolutePixelCurrentLimit3+fRelativeCurrentLimitShutdown ||
            imax0>fAbsolutePixelCurrentLimit0+fRelativeCurrentLimitShutdown;

        const bool critical =
            imed >fAbsoluteMedianCurrentLimit+fRelativeCurrentLimitCritical ||
            imax3>fAbsolutePixelCurrentLimit3+fRelativeCurrentLimitCritical ||
            imax0>fAbsolutePixelCurrentLimit0+fRelativeCurrentLimitCritical;

        const bool warning =
            imed >fAbsoluteMedianCurrentLimit+fRelativeCurrentLimitWarning ||
            imax3>fAbsolutePixelCurrentLimit3+fRelativeCurrentLimitWarning ||
            imax0>fAbsolutePixelCurrentLimit0+fRelativeCurrentLimitWarning;

        bool standby = GetCurrentState()==Feedback::State::kOnStandby;

        if (standby)
        {
            // On Standby
            if (fVoltageReduction==0 &&
                imed <fAbsoluteMedianCurrentLimit &&
                imax3<fAbsolutePixelCurrentLimit3 &&
                imax0<fAbsolutePixelCurrentLimit0)
            {
                // Currents are back at nominal value and currents are again
                // below the current limit, switching back to standard operation.
                return Feedback::State::kInProgress;
            }
        }

        // Shutdown level
        if (!standby && shutdown)
        {
            // Currents exceed the shutdown limit, operation is switched
            // immediately to voltage reduced operation

            // Just in case (FIXME: Is that really the right location?)
            Dim::SendCommandNB("FAD_CONTROL/CLOSE_ALL_OPEN_FILES");

            Error("Current limit for shutdown exceeded.... switching to standby mode.");

            standby = true;
        }

        // Critical level
        if (!standby && critical)
        {
            // This is a state transition from InProgress or Warning to Critical.
            // Keep the transition time.
            if (GetCurrentState()==Feedback::State::kInProgress || GetCurrentState()==Feedback::State::kWarning)
            {
                Info("Critical current limit exceeded.... waiting for "+to_string(fTimeoutCritical)+" ms.");
                fTimeCritical = Time();
            }

            // Critical is only allowed for fTimeoutCritical milliseconds.
            // After this time, the operation is changed to reduced voltage.
            if (Time()<fTimeCritical+boost::posix_time::milliseconds(fTimeoutCritical))
                return Feedback::State::kCritical;

            // Just in case (FIXME: Is that really the right location?)
            Dim::SendCommandNB("FAD_CONTROL/CLOSE_ALL_OPEN_FILES");

            // Currents in critical state
            Warn("Critical current limit exceeded timeout.... switching to standby mode.");

            standby = true;
        }

        // Warning level (is just informational)
        if (!standby && warning)
            return Feedback::State::kWarning;

        // keep voltage
        return standby ? Feedback::State::kOnStandby : Feedback::State::kInProgress;
    }

Here is the call graph for this function: