cartridge.h

Go to the documentation of this file.

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

#include <QTimerEvent>
#include <QString>
#include <QStringList>
#include <QVector>
#include <QSettings>
#include <QFileSystemWatcher>
#include <QMutex>
#include <QRunnable>

#include <unistd.h>

#include "tuning.h"
#include "network.h"

#include "CANbus/inireader.h"
#include "CANbus/mcunit.h"
#include "Synthesizer/agilent.h"
#include "Synthesizer/anritsu.h"
#include "PowerMeter/powermeter.h"

#include "GUI/mixer.h"
#include "GUI/lownoiseamplifier.h"
#include "constants.h"

class Cartridge;

QMutex *mutex(Mixer::Polarization pol, Mixer::Element sis);

class PolRunnable : public QRunnable
{
 public:
    PolRunnable(Cartridge *parent, Mixer::Polarization pol);

    virtual void run() = 0;

 protected:
    Cartridge *band;
    Mixer::Polarization m_pol;
};

class SisRunnable : public QRunnable
{
 public:
    SisRunnable(Cartridge *parent, Mixer::Polarization pol, Mixer::Element sis);

    virtual void run() = 0;

 protected:
    Cartridge *band;
    Mixer::Polarization m_pol;
    Mixer::Element m_sis;
};

class BiasSetter : public SisRunnable
{
 public:
    BiasSetter(Cartridge *parent, Mixer::Polarization pol, Mixer::Element sis, float value);

    void run();
 private:
    float m_val;
};

class CoilSetter : public SisRunnable
{
 public:
    CoilSetter(Cartridge *parent, Mixer::Polarization pol, Mixer::Element sis, float value);

    void run();
 private:
    float m_val;
};

class IVscanner : public SisRunnable
{
 public:
    IVscanner(Cartridge *parent, Mixer::Polarization pol, Mixer::Element sis,
              double V0, double V1, int steps);

    void run();
 private:
    double m_v0;
    double m_v1;
    int m_steps;
};

class Demagnetizer : public SisRunnable
{
 public:
    Demagnetizer(Cartridge *parent, Mixer::Polarization pol, Mixer::Element sis);

    void run();
};

class Defluxer : public PolRunnable
{
 public:
    Defluxer(Cartridge *parent, Mixer::Polarization pol);

    void run();
};

class Cartridge : public QObject
{
    Q_OBJECT
    Q_PROPERTY(int yig READ getYIG WRITE updateYIG);
    Q_PROPERTY(InternalState state READ state WRITE setState NOTIFY stateChanged)
    Q_PROPERTY(TuneState tuneState READ tuneState WRITE setTuneState NOTIFY tuneStateChanged)

    friend class BiasSetter;
    friend class CoilSetter;
    static const double lockRange;
    static const float invalid;

 public:
    enum InternalState {
        SHUTDOWN,
        INITIALIZED,
        RESET,
        DISABLED,
        ENABLED,
        FAULTED
    };
    Q_ENUM(InternalState)

    enum TuneState {
        UNTUNED,
        TUNING,
        TUNED
    };
    Q_ENUM(TuneState)

    
    Cartridge(const QString &name, Sepia::Channel channel, double WCAmultiplier, double YIGmultiplier,
               double lowerYigLimit, double upperYigLimit, QObject *parent = 0);
    virtual ~Cartridge();

    InternalState state() const { return m_state; }
    TuneState tuneState() const { return t_state; }

    void setMonitorChannels(const QStringList &channels);

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

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

    float biasOffset(int pol, int sis) const { return offV[pol][sis-1]; }

    float currentOffset(int pol, int sis) const { return offC[pol][sis-1]; }

    float coilCurrentPreset(int pol, int sis) const { return coilC[pol][sis-1]; }

    float gateVoltagePreset(int pol) const { return gateV[pol]; }

    QVector<double> biasTrace(int pol, int sis) const { return t_mV[pol][sis-1]; }

    QVector<double> currentTrace(int pol, int sis) const { return t_uA[pol][sis-1]; }

    QVector<double> powerTrace(int pol, int sis) const { return t_mW[pol][sis-1]; }

    int getYIG() const { return lastYIG; }

    double synthFreq() const { return _synthGHz; }

    double synthLevel() const { return _synthdBm; }

    float sisCurrent(Mixer::Polarization pol, Mixer::Element sis);

    float sisVoltage(Mixer::Polarization pol, Mixer::Element sis);

    float sisPower(Mixer::Polarization pol, Mixer::Element sis);

    float drainVoltage(Mixer::Polarization pol, Mixer::Element sis, LNA::Stage stage);

    float drainCurrent(Mixer::Polarization pol, Mixer::Element sis, LNA::Stage stage);

    float gateVoltage(Mixer::Polarization pol, Mixer::Element sis, LNA::Stage stage);

    float paGateVoltage(Mixer::Polarization pol);

    float paDrainVoltage(Mixer::Polarization pol);

    float paDrainCurrent(Mixer::Polarization pol);

    void setCoilCurrent(Mixer::Polarization pol, Mixer::Element sis, float mA, bool fast = false);

    void setSisVoltage(Mixer::Polarization pol, Mixer::Element sis, float mV, bool fast = false);

    bool sisOpenLoop(Mixer::Polarization pol, Mixer::Element sis);

    void setSisOpenLoop(Mixer::Polarization pol, Mixer::Element sis, bool flag);

    void setDrainVoltage(Mixer::Polarization pol, Mixer::Element sis, LNA::Stage stage, float V);

    void setDrainCurrent(Mixer::Polarization pol, Mixer::Element sis, LNA::Stage, float mA);

    void setLNAenable(Mixer::Polarization pol, Mixer::Element sis, bool flag);

    void setPaGateVoltage(Mixer::Polarization pol, float V);

    void setPaDrainVoltage(Mixer::Polarization pol, float V);

    void setAmcADrainVoltage(float V) { setRealValue("SET_AMC_A_DRAIN_V", V); }

    void setAmcBDrainVoltage(float V) { setRealValue("SET_AMC_B_DRAIN_V", V); }

    void setAmcEDrainVoltage(float V) { setRealValue("SET_AMC_E_DRAIN_V", V); }

    void setAmcAGateVoltage(float V)  { setRealValue("SET_AMC_A_GATE_V", V); }

    void setAmcBGateVoltage(float V)  { setRealValue("SET_AMC_B_GATE_V", V); }

    void setAmcEGateVoltage(float V)  { setRealValue("SET_AMC_E_GATE_V", V); }

    void setAmcDMultVoltage(float V)  { setRealValue("SET_AMC_D_MULT_V", V); }

    float amcAGateVoltage()  { return getRealValue("GET_AMC_A_GATE_V"); }

    float amcADrainVoltage() { return getRealValue("GET_AMC_A_DRAIN_V"); }

    float amcADrainCurrent() { return getRealValue("GET_AMC_A_DRAIN_C"); }

    float amcBGateVoltage()  { return getRealValue("GET_AMC_B_GATE_V"); }

    float amcBDrainVoltage() { return getRealValue("GET_AMC_B_DRAIN_V"); }

    float amcBDrainCurrent() { return getRealValue("GET_AMC_B_DRAIN_C"); }

    float amcEGateVoltage()  { return getRealValue("GET_AMC_E_GATE_V"); }

    float amcEDrainVoltage() { return getRealValue("GET_AMC_E_DRAIN_V"); }

    float amcEDrainCurrent() { return getRealValue("GET_AMC_E_DRAIN_C"); }

    float amcMultiDVoltage() { return getRealValue("GET_AMC_MULT_D_V"); }

    float amcMonitor5V()   { return getRealValue("GET_AMC_5V_MON"); }

    float coilCurrent(Mixer::Polarization pol, Mixer::Element sis);

    float coilVoltage(Mixer::Polarization pol, Mixer::Element sis);

    float heaterCurrent(Mixer::Polarization pol);

    float mixerTemperature(Mixer::Polarization pol);

    void heaterState(Mixer::Polarization pol, bool on);

    void toggleHeater(Mixer::Polarization pol);

    float pllLockVoltage()         { return getRealValue("GET_PLL_LOCK_V"); }

    float pllCorrVoltage()         { return getRealValue("GET_PLL_CORR_V"); }

    float pllRefTotalPower()       { return getRealValue("GET_PLL_REF_TOTAL_P"); }

    float pllIfTotalPower()        { return getRealValue("GET_PLL_IF_TOTAL_P"); }

    float pllAssemblyTemperature() { return getRealValue("GET_PLL_ASSEMBLY_T"); }

    bool LOlockLatch()             { return getFlag("GET_LO_LOCK_LATCH"); }

    void LOclearLatch()            { setFlag("SET_CLEAR_LO_LATCH", true); }

    void setNullPllIntegrator(bool flag)  { setFlag("SET_NULL_PLL_INTEGRATOR", flag); }

    void setPllLoopBandwidth(bool flag)   { setFlag("SET_PLL_LOOP_BW", flag); }

    void setPllSideband(bool lower)       { setFlag("SET_SB_LOCK_POL", lower); }

    void setCoarseTune(unsigned short value)  { setWord("SET_YTO_COARSE_TUNE", value); }

    virtual void tuneLO(double ghz, int harmonic) = 0;

    virtual void tuneMixer(Mixer::Polarization pol, float bias[2], float Igoal, float power, float maxPower) = 0;
    void tuneSynthesizer(double WCAfreq, int harmonic, bool upper);

 public slots:
     void resetBand();

    void run();

    void initialize();
    void reset();
    void shutdown();

    virtual void initBand(bool withDeflux) = 0;

    virtual void shutdownBand() = 0;

    virtual void tuneLO(double ghz);

    virtual void tuneMixer(Mixer::Polarization pol);

    void tuneSystem(double ghz);

    virtual void demagnetize(Mixer::Polarization pol, Mixer::Element sis) = 0;

    virtual void deflux(Mixer::Polarization pol) = 0;

    void disable();

    void enable();

    void demagnetizeMixers(bool p0s1, bool p0s2, bool p1s1, bool p1s2);

    void defluxMixers(bool p0, bool p1);

    void setLNADefaults();

    void cleanup();

    void updateYIG(int value);

    void changeSynthFreq(double ghz);

    void changeSynthLevel(double dBm);

    void switchSynth(bool flag);

    void IVscan(Mixer::Polarization pol, Mixer::Element sis, double from, double to, int steps, bool withPower);

    void scanMixers(double from, double to, int steps);

    void resetSisVoltages();

    void resetCoilCurrents();

    void resetLNAs();

    void setCoilCurrents();

    void setPaGateVoltages();

    void showCurve(Mixer::Polarization pol, Mixer::Element sis,
                   QVector<double> x, QVector<double> y, QVector<double> z,
                   const QString &xlab = QString::fromUtf8("mixer bias [mV]"),
                   const QString &ylab = QString::fromUtf8("mixer current [µA]"));

    bool pllControl(float *vcorr, float *vlock);

    void cryoControl(bool flag);

    void preparePLL(bool upper);

    void addChannel(Sepia::Channel channel);

    void removeChannel(Sepia::Channel channel);

    float getRealValue(QString name);

    bool getFlag(QString name);

    unsigned short getWord(QString name);

    void updateCryo(float T4K, float T12K, float chanC, float chanD, float p);

 protected:
    void setFlag(QString name, bool flag);

    void setRealValue(QString name, float v);

    void setWord(QString name, unsigned short w);

 signals:
    void stateChanged(Cartridge::InternalState s);
    void tuneStateChanged(Cartridge::TuneState s);

    void demagnetized(Mixer::Polarization pol, Mixer::Element sis, bool ok);

    void defluxed(Mixer::Polarization pol, bool ok);

    void faulted(Sepia::ErrorCode code);

    void pllStatus(bool locked, float Vlock, float Vcorr);

    void updateMonitorItem(const QString &name, DWORD addr, float v, char unit, int gain);

    void percentDone(int percent);

    void statusMessage(const QString &msg);

    void synthConnected(bool flag);

    void mcConnected(bool flag);
    void mcEnabled(bool flag);

    void synthSwitched(bool on);

    void synthFreqChanged(double ghz);

    void synthLevelChanged(double dbm);

    void yigChanged(int value);

    void pointReady(Mixer::Polarization pol, Mixer::Element sis,
                    int i, double mV, double mA, double mW);

    void traceReady(Mixer::Polarization pol, Mixer::Element sis,
                    QVector<double> x, QVector<double> y, QVector<double> z,
                    const QString &xlab, const QString &ylab);
    void LOtuned(bool ok);

    void LOmodified(bool flag);

    void newCmdLOfrequency(double ghz);

    void newCmdHarmonic(int harmonic);

    void mixerTuned(Mixer::Polarization pol, bool ok);

    void systemTuned(bool ok);

    void newMixerCurrent(Mixer::Polarization pol, Mixer::Element sis, float mA);

    void newCmdMixerBias(Mixer::Polarization pol, Mixer::Element sis, float mV);

    void newMixerBias(Mixer::Polarization pol, Mixer::Element sis, float mV);

    void newMixerPower(Mixer::Polarization pol, Mixer::Element sis, float mW);

    void newCoilCurrent(Mixer::Polarization pol, Mixer::Element sis, float mA);

    void newCmdCoilCurrent(Mixer::Polarization pol, Mixer::Element sis, float mA);

    void newDrainVoltage(Mixer::Polarization pol, Mixer::Element sis, LNA::Stage stage, float V);

    void newCmdDrainVoltage(Mixer::Polarization pol, Mixer::Element sis, LNA::Stage stage, float V);

    void newDrainCurrent(Mixer::Polarization pol, Mixer::Element sis, LNA::Stage stage, float mA);

    void newCmdDrainCurrent(Mixer::Polarization pol, Mixer::Element sis, LNA::Stage stage, float mA);

    void newGateVoltage(Mixer::Polarization pol, Mixer::Element sis, LNA::Stage stage, float V);

    void newCmdPaDrainVoltage(Mixer::Polarization pol, float V);

    void stabilize(double T);

 private slots:
    void timerEvent(QTimerEvent *event);
    void mcError(DWORD status);
    void getBandSettings();
    void synthConnected();
    void synthDisconnected();
    void setTuneState(TuneState s);

 private:
    void healthCheck();
    void getMonitoring(int i);
    void getHouseKeeping();

    bool needLOTuning();
    void storeTuning();

    int myTimerId;
    QFileSystemWatcher *watcher;

    const QString bandname;
    Sepia::Channel m_band;
    InternalState m_state;
    TuneState t_state;

    IniFileReader sr;
    QSettings settings;

    QStringList monitorChannels;

    MCunit *mc;
    Synthesizer *anritsu;
    PowerMeter *pm;
    bool m_usepm;

    double _synthGHz;
    double _synthdBm;
    bool _synthOn;

    float offV[2][2];
    float offC[2][2];

    float drainV[2][2][3];
    float drainC[2][2][3];

    float coilC[2][2];
    float gateV[2];

    double m_T4Kloop;
    double m_dbm;

    float m_pol0T;
    float m_pol1T;
    float m_T4K;
    float m_chanA;
    float m_chanB;
    float m_chanC;
    float m_chanD;
    float m_mbar;

 protected:
    QMutex canbus;
    QMutex synthesizer;
    QMutex tuning;

    int lastYIG;
    int _harmonic;
    double _ghz;
    double m_range[2];
    double m_wca;
    double m_yig;
    double f_yiglo;
    double f_yighi;
    int lastcoarse;

    bool _isModified;
    bool _isLocked;
    bool _isTuned[2];
    bool _isCold;

    Tuning actTuning;
    Tuning cmdTuning;

    int s_steps;
    double s_range[2];

    QVector<double> t_mV[2][2];
    QVector<double> t_uA[2][2];
    QVector<double> t_mW[2][2];

 protected slots:
    void setState(InternalState s);
};

Q_DECLARE_METATYPE(DWORD)
Q_DECLARE_METATYPE(QVector<double>)

#endif  // CARTRIDGE_H