localoscillator.h

Go to the documentation of this file.

/* Copyright 2017 Michael Olberg <michael.olberg@chalmers.se> */
#ifndef LOCALOSCILLATOR_H
#define LOCALOSCILLATOR_H

#include <QWidget>
#include <QDoubleSpinBox>
#include <QComboBox>
#include <QPushButton>
#include <QLabel>
#include <QString>
#include <QVariant>

#include "led.h"
#include "propertycontrol.h"
#include "mixer.h"
#include "../property.h"

class LocalOscillator : public QWidget
{
    Q_OBJECT
    Q_PROPERTY(double frequency READ frequency WRITE setFrequency)
    Q_PROPERTY(double IFrequency READ IFrequency WRITE setIFrequency)
    Q_PROPERTY(QString sideband READ sideband WRITE setSideband)
    Q_PROPERTY(bool tuned READ isTuned WRITE setTuned)
    Q_PROPERTY(bool modified READ isModified WRITE setModified)
    Q_PROPERTY(bool expertMode READ expertMode WRITE setExpertMode)

 public:
    enum Sideband {
        DSB = 0,  
        LSB = 1,  
        USB = 2   
    };
    Q_ENUM(Sideband)

    
    enum Polarity {
        NEGATIVE = 400,  
        POSITIVE = 401   
    };

    explicit LocalOscillator(QWidget *parent = 0);

    double frequency() const;
    double IFrequency() const { return m_ifreq; }

    double skyFrequency(bool cmd = true) const;

    Sideband SB(bool cmd = true) const;

    double refFrequency(bool cmd = true) const;

    QString sideband() const;

    bool isTuned() const { return m_tuned; }

    bool isModified() const { return m_modified; }

    double lowerLimit() const { return m_range[0]; }

    double upperLimit() const { return m_range[1]; }

    bool expertMode() const { return m_expert; }
    bool isTuning() const { return m_tuning; }

 public slots:
     void reset();

    void setFrequency(double ghz);
    void setIFrequency(double ghz) { m_ifreq = ghz; }

    void setSkyFrequency(double GHz);

    void setSB(LocalOscillator::Sideband sb);

    void setHarmonic(int n);

    void setSideband(const QString &sb);

    void setSynthGHz(double GHz);

    void setSynthdBm(double dbm);

    // void switchToSideband(Sideband sb);

    void synthConnected(bool state) { synthLED->setState(state); }

    void switchSynth(bool on);

    void setRange(double lower, double upper);

    void setModified(bool flag) { m_modified = flag; }

    // void changeProperty(const QString &name, const QVariant &value);

    void tune();

    void setTuned(bool flag);
    void setExpertMode(bool flag);

    void setPaDrainVoltage(Mixer::Polarization pol, float mV);
    void updatePaDrainVoltage(Mixer::Polarization pol, float mV);

 signals:
    void LOtuning(double GHz);
    void newCmdLOfrequency(double GHz);

 private slots:
    void changeLO(double ghz);
    void changeSynthGHz(double ghz);
    void changeSynthdBm(double dbm);
    void updateSidebands();
    void changeSideband(int index);
    void showProperties();

 private:
    Property<double> fSky;
    Property<Sideband> sb;
    Property<double> fSynth;
    Property<float> att;

    QLabel *usbFreq;
    QLabel *lsbFreq;

    PropertyControl *LOFreqCtrl;
    QComboBox *cmdSideband;
    QLabel *harmonic;
    QLabel *synthFreq;
    QLabel *synthLevel;
    LED *synthLED;

    QLabel *paAcmd;
    QLabel *paBcmd;

    Property<float> m_paa;
    Property<float> m_pab;
    int m_harmonic;
    double m_range[2];
    double m_ifreq;
    bool m_tuning;
    bool m_tuned;
    bool m_modified;
    bool m_expert;
};

#endif  // LOCALOSCILLATOR_H