modgensetup.cpp

#include "modgensetup.h"

#if defined(TKPA_V1)
    #include "cdeviceni5450.h"
    #include "ni5450setup.h"
#elif defined(TKPA_V2)
    #include "cdevicemgqs.h"
    #include "mgqssetup.h"
#endif

#include "devicemanager.h"
#include "globals.h"
#include "test.h"

#include <QDebug>
#include <QElapsedTimer>

/* -------------------------------------------------------------------------- */
TestStepBasic* createModGenSetup (const std::vector<ModGenChannelSettings> &ch)
{
#if defined(TKPA_V1)

    std::vector<NI5450ChannelSettings> niChannelSettings;
    foreach (const LowFreqGenChannelSettings &s, ch)
    {
        NI5450ChannelSettings niChannel(std::to_string(s.ch), s.amp, s.freq);
        niChannelSettings.push_back(niChannel);
    }
    return new NI5450Setup(niChannelSettings);

#elif defined(TKPA_V2)

    std::vector<MGQSChannelSettings> mgqsChannelSettings;
    foreach (const ModGenChannelSettings &s, ch)
    {
        MGQSChannelSettings channel(s.ch, s.amp, s.freq);
        mgqsChannelSettings.push_back(channel);
    }
    return new MGQSSetup(mgqsChannelSettings);

#endif
}

TestStepBasic* createModGenSetup2ch (double freq)
{
    std::vector<ModGenChannelSettings> ch{
        {0, Globals::c_defaultModGenAmp, freq},
        {1, Globals::c_defaultModGenAmp, freq}};
    return createModGenSetup(ch);
}

TestStepBasic* createModGenEnableOutput (const std::vector<unsigned short> &ch,
                                         bool bEnable)
{
#if defined(TKPA_V1)

    std::vector<std::string> niChannels;
    foreach (unsigned short c, ch)
    {
        niChannels.push_back(std::to_string(c));
    }
    return new NI5450SetOutputEnabled(niChannels, bEnable);

#elif defined(TKPA_V2)

    return new MGQSEnableOutput(ch, bEnable);

#endif
}

TestStepBasic* createModGenAbortGeneration ()
{
#if defined(TKPA_V1)
    return new NI5450AbortGeneration;
#elif defined(TKPA_V2)
    return new MGQSAbortGeneration;
#endif
}

TestStepBasic*
    createModGenSetFrequency (const std::vector<ModGenChannelSettings> &ch)
{
#if defined(TKPA_V1)

    std::vector<std::string> niChannels;
    foreach (const LowFreqGenChannelSettings &c, ch)
    {
        niChannels.push_back(std::to_string(c.ch));
    }
    return new NI5450SetFrequency(niChannels, freq);

#elif defined(TKPA_V2)

    std::vector<MGQSChannelSettings> channels;
    foreach (const ModGenChannelSettings &c, ch)
    {
        MGQSChannelSettings mgqsChannel(c.ch, c.amp, c.freq);
        channels.push_back(mgqsChannel);
    }
    return new MGQSSetFrequency(channels);

#endif
}

/* -------------------------------------------------------------------------- */
ModGenFrequencySweep::ModGenFrequencySweep(
    const std::vector<FreqListItem> &freqList,
    const std::vector<unsigned short> &ch,
    double amp,
    Test* parent)
    : TestStep(parent)
    , m_freqList(freqList)
    , m_ch(ch)
    , m_amp(amp)
{
#if defined(TKPA_V1)
    m_devNum = c_NI5450DevNum;
#elif defined(TKPA_V2)
    m_devNum = c_mgqsDevNum;
#endif

    Q_ASSERT(freqList.size() > 0);

    setName("Frequency sweep " + m_devNum);
    double t(0.0);
    foreach (const FreqListItem &f, m_freqList)
    {
        t += f.time;
    }
    m_time = t;
}

bool ModGenFrequencySweep::setFreq(double freq)
{
#if defined(TKPA_V1)
    CDeviceNI5450* dev = dynamic_cast<CDeviceNI5450*>(
        DeviceManager::instance().deviceBySchemeNum(m_devNum).get());

    for (unsigned int i = 0; i < m_ch.size(); i++)
    {
        if (dev->setFreqAttribute(std::to_string(m_ch[i]), freq) != 0)
        {
            setErrorString(QString::fromStdString(dev->getLastError()));
            return false;
        }
    }
#elif defined(TKPA_V2)

    CDeviceMGQS* dev = dynamic_cast<CDeviceMGQS*>(
        DeviceManager::instance().deviceBySchemeNum(m_devNum).get());

    for (unsigned int i = 0; i < m_ch.size(); i++)
    {
        CDeviceMGQS::GenParameters genParams(m_amp, freq, 0);
        if (dev->configAfg(m_ch[i], genParams) != 0)
        {
            setErrorString(QString::fromStdString(dev->getLastError()));
            return false;
        }
    }

#endif
    return true;
}

bool ModGenFrequencySweep::execute()
{
    // Текущая частота
    double freq{0.0};
    // Прошедшее время в секундах
    double sec{0.0};

    // Индекс начального частотного интервала
    unsigned int curIndex{0};
    // Частотный интервал
    FreqListItem fItem = m_freqList[curIndex];
    // Индекс конечного частотного интервала
    FreqListItem fLastItem = *std::prev(m_freqList.end());
    // Изменение частоты между частотными точками в единицу времени
    double df = (fItem.freqEnd - fItem.freqStart) / fItem.time;
    // Время на начале частотного интервала
    double startTime{0.0};
    // Признак - установлена ли частота
    bool bSet{false};

    qDebug() << "Total time = " << m_time;
    qDebug() << "df =" << df;

    // Запускаем таймер
    QElapsedTimer timer;
    timer.start();

    int counter{0};

    // Цикл по всем частотным интервалам
    do
    {
        // Расчёт текущей частоты
        freq = fItem.freqStart + (sec - startTime) * df;

        if (!bSet)
        {
            // Выдать частоту на генераторе
            if (!setFreq(freq))
            {
                return false;
            }

            qDebug().nospace().noquote()
                << ++counter << " freq = " << freq << ", msec  = " << sec;

            // Если изменеие частоты меньше опредленного значения
            // признак выполнения частоты становится выполнился
            if (df < 0.001)
            {
                bSet = true;
            }
        }

        // Прошедшее время в секундах
        sec = timer.nsecsElapsed() * 1e-6;

        // Проверка перехода на следующую частотный интервал по времени
        if (sec > startTime + fItem.time)
        {
            if (curIndex == m_freqList.size() - 1)
            {
                break;
            }

            // Прибавить к начальному времени время перестройки на текущей
            // частотной точке
            startTime += fItem.time;
            // Увеличить индекс частотного интервала
            curIndex++;

            // Взять новый частотный интервал
            fItem = m_freqList[curIndex];

            // Изменение частоты между частотными точками в единицу времени
            df = (fItem.freqEnd - fItem.freqStart) / fItem.time;

            bSet = false;
        }

        // Остновить если поступил сигнал Стоп
        if (parent() && parent()->stopCondition())
        {
            break;
        }

    } while (sec < m_time);

    qDebug().nospace().noquote()
        << ++counter << " freq = " << freq << ", msec  = " << sec;
    // Установить конечную частоту
    setFreq(fLastItem.freqEnd);

    return true;
}