RangeAlarmWithHysteresis.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_RANGEALARMWITHHYSTERESIS_H
#define IMT_BASE_LIB_ALARMS_RANGEALARMWITHHYSTERESIS_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 RangeAlarmWithHysteresis final : private ::imt::base::core::platform::Noncopyable {
 
public:
 
    RangeAlarmWithHysteresis(
        AlarmSenderIfc& alarmSender,
        ::imt::base::core::util::Range<ValueType> const& rangeSet,
        ::imt::base::core::util::Range<ValueType> const& rangeReset,
        AlarmIdentifier const lowerAlarmId,
        AlarmIdentifier const upperAlarmId);
 
    void updateValue(ValueType const& value);
 
    void deactivateAlarms();
 
    bool isAlarmActive() const;
 
    bool isLowerAlarmActive() const;
 
    bool isUpperAlarmActive() const;
 
private:
 
    void activateLowerAlarm();
    void activateUpperAlarm();
    void deactivateLowerAlarm();
    void deactivateUpperAlarm();
    void updateValueUpperRange(ValueType const& value);
    void updateValueLowerRange(ValueType const& value);
 
    AlarmSenderIfc& m_alarmSender;
    ::imt::base::core::util::Range<ValueType> const m_rangeSet;
    ::imt::base::core::util::Range<ValueType> const m_rangeReset;
    AlarmIdentifier const m_lowerAlarmId;
    AlarmIdentifier const m_upperAlarmId;
    // AXIVION Next Codeline AutosarC++19_03-A12.1.3: All data members initialized in custom constructor
    bool m_isLowerAlarmActive;
    // AXIVION Next Codeline AutosarC++19_03-A12.1.3: All data members initialized in custom constructor
    bool m_isUpperAlarmActive;
};
 
template<typename ValueType>
RangeAlarmWithHysteresis<ValueType>::RangeAlarmWithHysteresis(
    AlarmSenderIfc& alarmSender,
    ::imt::base::core::util::Range<ValueType> const& rangeSet,
    ::imt::base::core::util::Range<ValueType> const& rangeReset,
    AlarmIdentifier const lowerAlarmId,
    AlarmIdentifier const upperAlarmId) :
    ::imt::base::core::platform::Noncopyable {},
    m_alarmSender {alarmSender},
    m_rangeSet {rangeSet},
    m_rangeReset {rangeReset},
    m_lowerAlarmId {lowerAlarmId},
    m_upperAlarmId {upperAlarmId},
    m_isLowerAlarmActive {false},
    m_isUpperAlarmActive {false} {
}
 
template<typename ValueType>
void RangeAlarmWithHysteresis<ValueType>::updateValue(ValueType const& value) {
    updateValueUpperRange(value);
    updateValueLowerRange(value);
}
 
template<typename ValueType>
void RangeAlarmWithHysteresis<ValueType>::deactivateAlarms() {
    deactivateLowerAlarm();
    deactivateUpperAlarm();
}
 
template<typename ValueType>
bool RangeAlarmWithHysteresis<ValueType>::isAlarmActive() const {
    return m_isLowerAlarmActive || m_isUpperAlarmActive;
}
 
template<typename ValueType>
bool RangeAlarmWithHysteresis<ValueType>::isLowerAlarmActive() const {
    return m_isLowerAlarmActive;
}
 
template<typename ValueType>
bool RangeAlarmWithHysteresis<ValueType>::isUpperAlarmActive() const {
    return m_isUpperAlarmActive;
}
 
// private
 
template<typename ValueType>
void RangeAlarmWithHysteresis<ValueType>::activateLowerAlarm() {
 
    if (!m_isLowerAlarmActive) {
        if (m_lowerAlarmId != NO_ALARM) {
            m_alarmSender.activateAlarm(m_lowerAlarmId);
            m_isLowerAlarmActive = true;
        }
    }
}
 
template<typename ValueType>
void RangeAlarmWithHysteresis<ValueType>::activateUpperAlarm() {
 
    if (!m_isUpperAlarmActive) {
        if (m_upperAlarmId != NO_ALARM) {
            m_alarmSender.activateAlarm(m_upperAlarmId);
            m_isUpperAlarmActive = true;
        }
    }
}
 
template<typename ValueType>
void RangeAlarmWithHysteresis<ValueType>::deactivateLowerAlarm() {
 
    if (m_isLowerAlarmActive) {
        if (m_lowerAlarmId != NO_ALARM) {
            m_alarmSender.deactivateAlarm(m_lowerAlarmId);
        }
        m_isLowerAlarmActive = false;
    }
}
 
template<typename ValueType>
void RangeAlarmWithHysteresis<ValueType>::deactivateUpperAlarm() {
 
    if (m_isUpperAlarmActive) {
        if (m_upperAlarmId != NO_ALARM) {
            m_alarmSender.deactivateAlarm(m_upperAlarmId);
        }
        m_isUpperAlarmActive = false;
    }
}
 
template<typename ValueType>
void RangeAlarmWithHysteresis<ValueType>::updateValueUpperRange(ValueType const& value) {
 
    if (m_rangeSet.isAbove(value)) {
        activateUpperAlarm();
    }
    else if (!m_rangeReset.isAbove(value)) {
        deactivateUpperAlarm();
    }
}
 
template<typename ValueType>
void RangeAlarmWithHysteresis<ValueType>::updateValueLowerRange(ValueType const& value) {
 
    if (m_rangeSet.isBelow(value)) {
        activateLowerAlarm();
    }
    else if (!m_rangeReset.isBelow(value)) {
        deactivateLowerAlarm();
    }
}
 
} // namespace alarms
} // namespace lib
} // namespace base
} // namespace imt
 
#endif // IMT_BASE_LIB_ALARMS_RANGEALARMWITHHYSTERESIS_H