comsystem.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_AVIATION_COMSYSTEM_H
#define SWIFT_MISC_AVIATION_COMSYSTEM_H
 
#include <tuple>
 
#include <QHash>
#include <QJsonObject>
#include <QMetaType>
#include <QString>
 
#include "misc/aviation/modulator.h"
#include "misc/metaclass.h"
#include "misc/mixin/mixinhash.h"
#include "misc/mixin/mixinindex.h"
#include "misc/mixin/mixinjson.h"
#include "misc/mixin/mixinmetatype.h"
#include "misc/pq/constants.h"
#include "misc/pq/frequency.h"
#include "misc/pq/physicalquantity.h"
#include "misc/pq/pqstring.h"
#include "misc/pq/units.h"
#include "misc/swiftmiscexport.h"
 
namespace swift::misc::aviation
{
    class SWIFT_MISC_EXPORT CComSystem :
        public CModulator<CComSystem>,
        public mixin::MetaType<CComSystem>,
        public mixin::JsonOperators<CComSystem>,
        public mixin::Index<CComSystem>
    {
    public:
        using base_type = CModulator<CComSystem>;
 
        SWIFT_MISC_DECLARE_USING_MIXIN_METATYPE(CComSystem)
        SWIFT_MISC_DECLARE_USING_MIXIN_INDEX(CComSystem)
 
        
        enum ChannelSpacing
        {
            ChannelSpacing50KHz, 
            ChannelSpacing25KHz, 
            ChannelSpacing8_33KHz 
        };
 
        enum ComUnit
        {
            Com1,
            Com2
        };
 
        CComSystem() {}
 
        CComSystem(const QString &name, const physical_quantities::CFrequency &activeFrequency,
                   const physical_quantities::CFrequency
                       &standbyFrequency = { 0, physical_quantities::CFrequencyUnit::nullUnit() })
            : CModulator(name, activeFrequency, standbyFrequency.isNull() ? activeFrequency : standbyFrequency)
        {}
 
        void setFrequencyActiveMHz(double frequencyMHz);
 
        void setFrequencyStandbyMHz(double frequencyMHz);
 
        void setFrequencyActive(const physical_quantities::CFrequency &frequency);
 
        void setFrequencyStandby(const physical_quantities::CFrequency &frequency);
 
        bool isActiveFrequencySameFrequency(const physical_quantities::CFrequency &comFrequency) const;
 
        void setActiveUnicom();
 
        ChannelSpacing getChannelSpacing() const { return m_channelSpacing; }
 
        void setChannelSpacing(ChannelSpacing spacing) { m_channelSpacing = spacing; }
 
        static CComSystem getCom1System(double activeFrequencyMHz, double standbyFrequencyMHz = -1);
 
        static CComSystem getCom1System(const physical_quantities::CFrequency &activeFrequency,
                                        const physical_quantities::CFrequency &standbyFrequency = {
                                            0, physical_quantities::CFrequencyUnit::nullUnit() });
        static CComSystem getCom2System(double activeFrequencyMHz, double standbyFrequencyMHz = -1);
 
        static CComSystem getCom2System(const physical_quantities::CFrequency &activeFrequency,
                                        const physical_quantities::CFrequency &standbyFrequency = {
                                            0, physical_quantities::CFrequencyUnit::nullUnit() });
 
        static bool isValidCivilAviationFrequency(const physical_quantities::CFrequency &f);
 
        static bool isValidMilitaryFrequency(const physical_quantities::CFrequency &f);
 
        static bool isValidComFrequency(const physical_quantities::CFrequency &f);
 
        static void roundToChannelSpacing(physical_quantities::CFrequency &frequency, ChannelSpacing channelSpacing);
 
        static bool isSameFrequency(const physical_quantities::CFrequency &freq1,
                                    const physical_quantities::CFrequency &freq2);
 
        static bool isValid8_33kHzChannel(int fKHz);
 
        static int round8_33kHzChannel(int fKHz);
 
        static bool isExclusiveWithin8_33kHzChannel(const physical_quantities::CFrequency &freq);
 
        static bool isWithin25kHzChannel(const physical_quantities::CFrequency &freq);
 
        static physical_quantities::CFrequency parseComFrequency(const QString &input,
                                                                 physical_quantities::CPqString::SeparatorMode sep);
 
        static void registerMetadata();
 
    private:
        ChannelSpacing m_channelSpacing = ChannelSpacing8_33KHz; 
 
        static double channelSpacingToFrequencyKHz(ChannelSpacing channelSpacing);
 
        SWIFT_METACLASS(
            CComSystem,
            SWIFT_METAMEMBER(channelSpacing));
    };
} // namespace swift::misc::aviation
 
Q_DECLARE_METATYPE(swift::misc::aviation::CComSystem)
Q_DECLARE_METATYPE(swift::misc::aviation::CComSystem::ChannelSpacing)
Q_DECLARE_METATYPE(swift::misc::aviation::CComSystem::ComUnit)
 
#endif // SWIFT_MISC_AVIATION_COMSYSTEM_H