RangeAlarmWithDelay.h

Go to the documentation of this file.

// (c) IMT - Information Management Technology AG, CH-9470 Buchs, www.imt.ch.
 
#ifndef IMT_BASE_LIB_ALARMS_RANGEALARMWITHDELAY_H
#define IMT_BASE_LIB_ALARMS_RANGEALARMWITHDELAY_H
 
#include <Imt.Base.Core.Platform/Noncopyable.h>
#include <Imt.Base.Core.Platform/Platform.h>
#include <Imt.Base.Core.Util/Range.h>
#include <Imt.Base.Lib.Alarms/AlarmSenderIfc.h>
 
namespace imt {
namespace base {
namespace lib {
namespace alarms {
 
template<typename ValueType>
class RangeAlarmWithDelay : private ::imt::base::core::platform::Noncopyable {
 
public:
 
    using DelayTicks = uint32_t;
 
    static constexpr DelayTicks NULL_DELAY {0U};
 
    RangeAlarmWithDelay(
        AlarmSenderIfc& alarmSender,
        ::imt::base::core::util::Range<ValueType> const& range,
        AlarmIdentifier const lowerAlarmId,
        DelayTicks const lowerAlarmDelayTicks,
        AlarmIdentifier const upperAlarmId,
        DelayTicks const upperAlarmDelayTicks) noexcept;
 
    RangeAlarmWithDelay(
        AlarmSenderIfc& alarmSender,
        ::imt::base::core::util::Range<ValueType> const& range,
        AlarmIdentifier const lowerAlarmId,
        DelayTicks const lowerAlarmActivationDelayTicks,
        DelayTicks const lowerAlarmDeactivationDelayTicks,
        AlarmIdentifier const upperAlarmId,
        DelayTicks const upperAlarmActivationDelayTicks,
        DelayTicks const upperAlarmDeactivationDelayTicks) noexcept;
 
    void updateValue(ValueType const& value);
 
    void forceValue(ValueType const& value);
 
    void deactivateAlarms();
 
    bool isAlarmActive() const;
 
    bool isLowerAlarmActive() const;
 
    bool isUpperAlarmActive() const;
 
    bool isInRange(ValueType const& value) const;
 
    void updateRange(::imt::base::core::util::Range<ValueType> const& range);
 
private:
 
    void activateLowerAlarm();
    void activateUpperAlarm();
    void deactivateLowerAlarm();
    void deactivateUpperAlarm();
    void resetAlarmTick(bool const isAlarmActive, bool const isInAlarmRange, DelayTicks* const pAlarmTick);
    void updateValueUpperRange(ValueType const& value, bool const doForce);
    void updateValueLowerRange(ValueType const& value, bool const doForce);
 
    AlarmSenderIfc& m_alarmSender;
    ::imt::base::core::util::Range<ValueType> m_range;
    AlarmIdentifier const m_lowerAlarmId;
    DelayTicks const m_lowerAlarmActivationDelayTicks;
    DelayTicks const m_lowerAlarmDeactivationDelayTicks;
    AlarmIdentifier const m_upperAlarmId;
    DelayTicks const m_upperAlarmActivationDelayTicks;
    DelayTicks const m_upperAlarmDeactivationDelayTicks;
    // AXIVION Next Codeline AutosarC++19_03-A12.1.3: All data members initialized in custom constructor
    bool m_isLowerAlarmActive;
    DelayTicks m_lowerAlarmTick;
    // AXIVION Next Codeline AutosarC++19_03-A12.1.3: All data members initialized in custom constructor
    bool m_isUpperAlarmActive;
    // AXIVION Next Codeline AutosarC++19_03-A12.1.3: All data members initialized in custom constructor
    DelayTicks m_upperAlarmTick;
    // AXIVION Next Codeline AutosarC++19_03-A12.1.3: All data members initialized in custom constructor
    ValueType m_value;
    // AXIVION Next Codeline AutosarC++19_03-A12.1.3: All data members initialized in custom constructor
    DelayTicks m_tick;
};
 
// AXIVION Next Construct AutosarC++19_03-A12.1.6: false positive Noncopyable has not constructor with the same arguments
template<typename ValueType>
RangeAlarmWithDelay<ValueType>::RangeAlarmWithDelay(
    AlarmSenderIfc& alarmSender,
    ::imt::base::core::util::Range<ValueType> const& range,
    AlarmIdentifier const lowerAlarmId,
    DelayTicks const lowerAlarmDelayTicks,
    AlarmIdentifier const upperAlarmId,
    DelayTicks const upperAlarmDelayTicks) noexcept :
    RangeAlarmWithDelay {alarmSender, range, lowerAlarmId, lowerAlarmDelayTicks, lowerAlarmDelayTicks, upperAlarmId, upperAlarmDelayTicks, upperAlarmDelayTicks} {
}
 
template<typename ValueType>
RangeAlarmWithDelay<ValueType>::RangeAlarmWithDelay(
    AlarmSenderIfc& alarmSender,
    ::imt::base::core::util::Range<ValueType> const& range,
    AlarmIdentifier const lowerAlarmId,
    DelayTicks const lowerAlarmActivationDelayTicks,
    DelayTicks const lowerAlarmDeactivationDelayTicks,
    AlarmIdentifier const upperAlarmId,
    DelayTicks const upperAlarmActivationDelayTicks,
    DelayTicks const upperAlarmDeactivationDelayTicks) noexcept :
    ::imt::base::core::platform::Noncopyable {},
    m_alarmSender {alarmSender},
    m_range {range},
    m_lowerAlarmId {lowerAlarmId},
    m_lowerAlarmActivationDelayTicks {lowerAlarmActivationDelayTicks},
    m_lowerAlarmDeactivationDelayTicks {lowerAlarmDeactivationDelayTicks},
    m_upperAlarmId {upperAlarmId},
    m_upperAlarmActivationDelayTicks {upperAlarmActivationDelayTicks},
    m_upperAlarmDeactivationDelayTicks {upperAlarmDeactivationDelayTicks},
    m_isLowerAlarmActive {false},
    m_lowerAlarmTick {NULL_DELAY},
    m_isUpperAlarmActive {false},
    m_upperAlarmTick {NULL_DELAY},
    m_value {0},
    m_tick {NULL_DELAY} {
}
 
template<typename ValueType>
void RangeAlarmWithDelay<ValueType>::updateValue(ValueType const& value) {
    m_tick++;
    m_value = value;
 
    updateValueUpperRange(value, false);
    updateValueLowerRange(value, false);
}
 
template<typename ValueType>
void RangeAlarmWithDelay<ValueType>::forceValue(ValueType const& value) {
    m_tick++;
    m_value = value;
 
    updateValueUpperRange(value, true);
    updateValueLowerRange(value, true);
}
 
template<typename ValueType>
void RangeAlarmWithDelay<ValueType>::deactivateAlarms() {
    deactivateLowerAlarm();
    deactivateUpperAlarm();
}
 
template<typename ValueType>
bool RangeAlarmWithDelay<ValueType>::isAlarmActive() const {
    return m_isLowerAlarmActive || m_isUpperAlarmActive;
}
 
template<typename ValueType>
bool RangeAlarmWithDelay<ValueType>::isLowerAlarmActive() const {
    return m_isLowerAlarmActive;
}
 
template<typename ValueType>
bool RangeAlarmWithDelay<ValueType>::isUpperAlarmActive() const {
    return m_isUpperAlarmActive;
}
 
template<typename ValueType>
bool RangeAlarmWithDelay<ValueType>::isInRange(ValueType const& value) const {
    return m_range.isInRange(value);
}
 
template<typename ValueType>
void RangeAlarmWithDelay<ValueType>::updateRange(::imt::base::core::util::Range<ValueType> const& range) {
    m_range = range;
}
 
// private
 
template<typename ValueType>
void RangeAlarmWithDelay<ValueType>::activateLowerAlarm() {
    // reset delay
    m_lowerAlarmTick = m_tick;
 
    if (!m_isLowerAlarmActive) {
        if (m_lowerAlarmId != NO_ALARM) {
            m_alarmSender.activateAlarm(m_lowerAlarmId);
            m_isLowerAlarmActive = true;
            deactivateUpperAlarm();
        }
    }
}
 
template<typename ValueType>
void RangeAlarmWithDelay<ValueType>::activateUpperAlarm() {
    // reset delay
    m_upperAlarmTick = m_tick;
 
    if (!m_isUpperAlarmActive) {
        if (m_upperAlarmId != NO_ALARM) {
            m_alarmSender.activateAlarm(m_upperAlarmId);
            m_isUpperAlarmActive = true;
            deactivateLowerAlarm();
        }
    }
}
 
template<typename ValueType>
void RangeAlarmWithDelay<ValueType>::deactivateLowerAlarm() {
    // reset delay
    m_lowerAlarmTick = m_tick;
 
    if (m_isLowerAlarmActive) {
        if (m_lowerAlarmId != NO_ALARM) {
            m_alarmSender.deactivateAlarm(m_lowerAlarmId);
        }
        m_isLowerAlarmActive = false;
    }
}
 
template<typename ValueType>
void RangeAlarmWithDelay<ValueType>::deactivateUpperAlarm() {
    // reset delay
    m_upperAlarmTick = m_tick;
 
    if (m_isUpperAlarmActive) {
        if (m_upperAlarmId != NO_ALARM) {
            m_alarmSender.deactivateAlarm(m_upperAlarmId);
        }
        m_isUpperAlarmActive = false;
    }
}
 
template<typename ValueType>
void RangeAlarmWithDelay<ValueType>::resetAlarmTick(bool const isAlarmActive, bool const isInAlarmRange, DelayTicks* const pAlarmTick) {
    if (pAlarmTick == nullptr) {
        return;
    }
 
    if (isAlarmActive) {
        if (isInAlarmRange) {
            // value in alarm range, reset delay for deactivation
            *pAlarmTick = m_tick;
        }
        else {
            // value not in alarm range, keep delay for deactivation running
        }
    }
    else {
        if (isInAlarmRange) {
            // value in alarm range, keep delay for alarm activation running
        }
        else {
            // value not in alarm range, reset delay for alarm activation
            *pAlarmTick = m_tick;
        }
    }
}
 
template<typename ValueType>
void RangeAlarmWithDelay<ValueType>::updateValueUpperRange(ValueType const& value, bool const doForce) {
    resetAlarmTick(m_isUpperAlarmActive, m_range.isAbove(value), &m_upperAlarmTick);
 
    DelayTicks const ticksPassedUpper {m_tick - m_upperAlarmTick};
    if (m_range.isAbove(value)) {
        if ((ticksPassedUpper >= m_upperAlarmActivationDelayTicks) || doForce) {
            activateUpperAlarm();
        }
    }
    else {
        if ((ticksPassedUpper >= m_upperAlarmDeactivationDelayTicks) || doForce) {
            deactivateUpperAlarm();
        }
    }
}
 
template<typename ValueType>
void RangeAlarmWithDelay<ValueType>::updateValueLowerRange(ValueType const& value, bool const doForce) {
    resetAlarmTick(m_isLowerAlarmActive, m_range.isBelow(value), &m_lowerAlarmTick);
 
    DelayTicks const ticksPassedLower {m_tick - m_lowerAlarmTick};
    if (m_range.isBelow(value)) {
        if ((ticksPassedLower >= m_lowerAlarmActivationDelayTicks) || doForce) {
            activateLowerAlarm();
        }
    }
    else {
        if ((ticksPassedLower >= m_lowerAlarmDeactivationDelayTicks) || doForce) {
            deactivateLowerAlarm();
        }
    }
}
 
} // namespace alarms
} // namespace lib
} // namespace base
} // namespace imt
 
#endif // IMT_BASE_LIB_ALARMS_RANGEALARMWITHDELAY_H