scriptrunner.h

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

#include <QObject>
#include <QVector>
#include <QScriptable>
#include <QScriptEngine>
#include <QScriptContext>
#include <QScriptValue>

class Cartridge;
class Channel;

class PLL : public QObject, public QScriptable
{
    Q_OBJECT
    Q_PROPERTY(double corrVoltage READ corrVoltage)
    Q_PROPERTY(double lockVoltage READ lockVoltage)
    Q_PROPERTY(double referencePower READ refTotalPower)
    Q_PROPERTY(double ifPower READ ifTotalPower)
    Q_PROPERTY(double assemblyTemperature READ assemblyTemperature)
    Q_PROPERTY(bool locked READ locked);

 public:
    explicit PLL(Channel *parent = 0);
    void setCartridge(Cartridge *band) { m_cart = band; }
    Cartridge *cartridge() const { return m_cart; }
    Q_INVOKABLE double corrVoltage();
    Q_INVOKABLE double lockVoltage();
    Q_INVOKABLE double refTotalPower();
    Q_INVOKABLE double ifTotalPower();
    Q_INVOKABLE double assemblyTemperature();
    Q_INVOKABLE bool locked() const;

 public slots:
    void setPllLoopBandwidth(bool flag);
    void setNullPllIntegrator(bool flag);
    void setPllSideband(bool lower);

 private:
    Cartridge *m_cart;
    int m_pol;
    int m_sis;
    int m_stage;
};

class Multiplier : public QObject, public QScriptable
{
    Q_OBJECT

 public:
    explicit Multiplier(Channel *parent = 0);                    // AMC
    void setCartridge(Cartridge *band) { m_cart = band; }
    Cartridge *cartridge() const { return m_cart; }
    Q_INVOKABLE double drainVoltage(int amc);
    Q_INVOKABLE double drainCurrent(int amc);
    Q_INVOKABLE double gateVoltage(int amc);
    Q_INVOKABLE double monitor5V();
    Q_INVOKABLE double multiDVoltage();

 public slots:
    void setDrainVoltage(int amc, double mV);
    // void setDrainCurrent(int amc, double mA);
    // void setGateVoltage(int amc, double mV);

 private:
    Cartridge *m_cart;
};

class Amplifier : public QObject, public QScriptable
{
    Q_OBJECT
    Q_PROPERTY(double drainVoltage READ drainVoltage WRITE setDrainVoltage)
    Q_PROPERTY(double drainCurrent READ drainCurrent WRITE setDrainCurrent)
    Q_PROPERTY(double gateVoltage READ gateVoltage WRITE setGateVoltage)

 public:
    explicit Amplifier(int pol, Channel *parent = 0);                      // PA
    explicit Amplifier(int pol, int sis, int stage, Channel *parent = 0);  // LNA
    void setCartridge(Cartridge *band) { m_cart = band; }
    Cartridge *cartridge() const { return m_cart; }
    Q_INVOKABLE double drainVoltage();
    Q_INVOKABLE double drainCurrent();
    Q_INVOKABLE double gateVoltage();

 public slots:
    void setDrainVoltage(double mV);
    void setDrainCurrent(double mA);
    void setGateVoltage(double mV);

 private:
    Cartridge *m_cart;
    int m_pol;
    int m_sis;
    int m_stage;
};

class Element :  public QObject, public QScriptable
{
    Q_OBJECT
    Q_PROPERTY(double bias READ bias WRITE setBias)
    Q_PROPERTY(bool mode READ sisOpenLoop WRITE setSisOpenLoop)
    Q_PROPERTY(double current READ current)
    Q_PROPERTY(double coilCurrent READ coilCurrent WRITE setCoilCurrent)
    Q_PROPERTY(double coilVoltage READ coilVoltage)
    // Q_PROPERTY(double biasOffset READ biasOffset WRITE setBiasOffset)
    // Q_PROPERTY(double currentOffset READ currentOffset WRITE setCurrentOffset)
    Q_PROPERTY(double heaterCurrent READ heaterCurrent)
    Q_PROPERTY(double mixerTemperature READ mixerTemperature)
    // Q_PROPERTY(double PAdrainVoltage READ paDrainVoltage WRITE setPaDrainVoltage)
    // Q_PROPERTY(double PAgateVoltage READ paGateVoltage WRITE setPaGateVoltage)
    // Q_PROPERTY(double PAdrainCurrent READ paDrainCurrent)

 public:
    Element(int pol, int sis, Channel *parent = 0);
    void setCartridge(Cartridge *band) { m_cart = band; }
    Cartridge *cartridge() const { return m_cart; }
    Q_INVOKABLE double bias();
    Q_INVOKABLE double current();
    Q_INVOKABLE double coilCurrent();
    Q_INVOKABLE double coilVoltage();
    // Q_INVOKABLE double biasOffset() const;
    // Q_INVOKABLE double currentOffset() const;
    Q_INVOKABLE double heaterCurrent() const;
    Q_INVOKABLE double mixerTemperature() const;
    // Q_INVOKABLE double paGateVoltage() const;
    // Q_INVOKABLE double paDrainVoltage() const;
    // Q_INVOKABLE double paDrainCurrent() const;
    Q_INVOKABLE QVector<double> biasTrace() const;
    Q_INVOKABLE QVector<double> currentTrace() const;
    Q_INVOKABLE QVector<double> powerTrace() const;
    Q_INVOKABLE bool sisOpenLoop() const;

 public slots:
    void setBias(double mV);
    void setCoilCurrent(double mA);
    // void setBiasOffset(double mV);
    // void setCurrentOffset(double mA);
    void setSisOpenLoop(bool flag);
    void setLNAenable(bool flag);
    // void setPaGateVoltage(double mV);
    // void setPaDrainVoltage(double mV);
    void toggleHeater();
    void setHeaterState(bool flag);
    void tune(double bias1, double bias2, double Igoal, double maxPower);
    void demagnetize();
    void deflux();
    void scan(double from, double to, int steps, bool withPower=false);
    void saveTrace();
    void plotTrace(QVector<double> x, QVector<double> y,
                   const QString &xlab, const QString &ylab);

 private:
    Cartridge *m_cart;
    int m_pol;
    int m_sis;
};

class Oscillator : public QObject, public QScriptable
{
    Q_OBJECT
    Q_PROPERTY(int YIG READ getYIG WRITE updateYIG);
    Q_PROPERTY(double synthGHz READ synthFreq WRITE setSynthFreq);
    Q_PROPERTY(double synthdBm READ synthLevel WRITE setSynthLevel);
    Q_PROPERTY(bool lockLatch READ lockLatch);

 public:
    explicit Oscillator(Channel *parent = 0);
    void setCartridge(Cartridge *band) { m_cart = band; }
    Cartridge *cartridge() const { return m_cart; }
    Q_INVOKABLE int getYIG() const;
    Q_INVOKABLE double synthFreq() const;
    Q_INVOKABLE double synthLevel() const;
    Q_INVOKABLE bool lockLatch() const;

 public slots:
    void updateYIG(int value);
    void tune(double ghz, int harmonic);
    void setSynthFreq(double ghz);
    void setSynthLevel(double dBm);
    void setSynthPower(bool on);
    void clearLatch();

 private:
    Cartridge *m_cart;
};

class Channel : public QObject, public QScriptable
{
    Q_OBJECT

 public:
    enum Pol { POL0 = 0, POL1 = 1 };
    Q_ENUM(Pol)
    enum Sis { SIS1 = 1, SIS2 = 2 };
    Q_ENUM(Sis)
    enum Stage { STAGE1 = 1, STAGE2 = 2, STAGE3 = 3 };
    Q_ENUM(Stage)
    enum Amc { AMCA = 1, AMCB = 2, AMCE = 3 };
    Q_ENUM(Amc)

    explicit Channel(Cartridge *band, QObject *parent = 0);
    Cartridge *band() const { return m_cart; }

    static bool validPolarization(int p);
    static bool validElement(int s);
    static bool validStage(int s);
    static bool validAmc(int a);
    Q_INVOKABLE double getValue(const QString &keyword);

 public slots:
    static QScriptValue multiplier(QScriptContext *context, QScriptEngine *engine);
    static QScriptValue amplifier(QScriptContext *context, QScriptEngine *engine);
    static QScriptValue element(QScriptContext *context, QScriptEngine *engine);
    // static QScriptValue mixer(QScriptContext *context, QScriptEngine *engine);
    static QScriptValue oscillator(QScriptContext *context, QScriptEngine *engine);
    static QScriptValue phaselock(QScriptContext *context, QScriptEngine *engine);
    void initialize();
    void resetBiases();
    void resetCoilCurrents();
    void cryoControl(bool flag);

 private:
    Cartridge *m_cart;
};

class ScriptRunner : public QObject
{
    Q_OBJECT
 public:
    explicit ScriptRunner(const QString &scriptname, Cartridge *cartridge, QObject *parent = 0);
    ~ScriptRunner();

 signals:
    void done();

 public slots:
    void run();
    void report(const QString &txt);

 signals:
    void console(const QString &txt);

 private:
    QScriptEngine engine;
    QString m_script;
};

#endif  // SCRIPTRUNNER_H