RFSignalGenerator.h

/***********************************************************************************************************************
*                                                                                                                      *
* libscopehal v0.1                                                                                                     *
*                                                                                                                      *
* Copyright (c) 2012-2023 Andrew D. Zonenberg and contributors                                                         *
* All rights reserved.                                                                                                 *
*                                                                                                                      *
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the     *
* following conditions are met:                                                                                        *
*                                                                                                                      *
*    * Redistributions of source code must retain the above copyright notice, this list of conditions, and the         *
*      following disclaimer.                                                                                           *
*                                                                                                                      *
*    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the       *
*      following disclaimer in the documentation and/or other materials provided with the distribution.                *
*                                                                                                                      *
*    * Neither the name of the author nor the names of any contributors may be used to endorse or promote products     *
*      derived from this software without specific prior written permission.                                           *
*                                                                                                                      *
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED   *
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL *
* THE AUTHORS BE HELD LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES        *
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR       *
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE       *
* POSSIBILITY OF SUCH DAMAGE.                                                                                          *
*                                                                                                                      *
***********************************************************************************************************************/
 
#ifndef RFSignalGenerator_h
#define RFSignalGenerator_h
 
class RFSignalGenerator : public virtual Instrument
{
public:
    RFSignalGenerator();
    virtual ~RFSignalGenerator();
 
    // General
 
    virtual bool GetChannelOutputEnable(int chan) =0;
 
    virtual void SetChannelOutputEnable(int chan, bool on) =0;
 
    virtual float GetChannelOutputPower(int chan) =0;
 
    virtual void SetChannelOutputPower(int chan, float power) =0;
 
    virtual double GetChannelCenterFrequency(int chan) =0;
 
    virtual void SetChannelCenterFrequency(int chan, double freq) =0;
 
    // Analog modulation
 
    virtual bool IsAnalogModulationAvailable(int chan) =0;
 
    virtual void SetAnalogModulationEnable(int chan, bool on) =0;
 
    virtual bool GetAnalogModulationEnable(int chan) =0;
 
    virtual void SetAnalogFMEnable(int chan, bool on) =0;
 
    virtual bool GetAnalogFMEnable(int chan) =0;
 
    virtual std::vector<FunctionGenerator::WaveShape> GetAnalogFMWaveShapes() =0;
 
    virtual FunctionGenerator::WaveShape GetAnalogFMWaveShape(int chan) =0;
 
    virtual void SetAnalogFMWaveShape(int chan, FunctionGenerator::WaveShape shape) =0;
 
    virtual void SetAnalogFMDeviation(int chan, int64_t deviation) =0;
 
    virtual int64_t GetAnalogFMDeviation(int chan) =0;
 
    virtual void SetAnalogFMFrequency(int chan, int64_t frequency) =0;
 
    virtual int64_t GetAnalogFMFrequency(int chan) =0;
 
    // Vector modulation
 
    virtual bool IsVectorModulationAvailable(int chan) =0;
 
    // Sweeps
 
    virtual bool IsSweepAvailable(int chan) =0;
 
    enum SweepType
    {
        SWEEP_TYPE_NONE,
        SWEEP_TYPE_FREQ,
        SWEEP_TYPE_LEVEL,
        SWEEP_TYPE_FREQ_LEVEL
    };
 
    static std::string GetNameOfSweepType(SweepType type);
 
    static SweepType GetSweepTypeOfName(const std::string& name);
 
    virtual SweepType GetSweepType(int chan);
 
    virtual void SetSweepType(int chan, SweepType type);
 
    virtual float GetSweepStartFrequency(int chan);
 
    virtual float GetSweepStopFrequency(int chan);
 
    virtual void SetSweepStartFrequency(int chan, float freq);
 
    virtual void SetSweepStopFrequency(int chan, float freq);
 
    virtual float GetSweepStartLevel(int chan);
 
    virtual float GetSweepStopLevel(int chan);
 
    virtual void SetSweepStartLevel(int chan, float level);
 
    virtual void SetSweepStopLevel(int chan, float level);
 
    virtual void SetSweepDwellTime(int chan, float fs);
 
    virtual float GetSweepDwellTime(int chan);
 
    virtual void SetSweepPoints(int chan, int npoints);
 
    virtual int GetSweepPoints(int chan);
 
    enum SweepShape
    {
        //Ramp up and down
        SWEEP_SHAPE_TRIANGLE,
 
        //Ramp up, then jump down
        SWEEP_SHAPE_SAWTOOTH
    };
 
    static std::string GetNameOfSweepShape(SweepShape shape);
 
    static SweepShape GetSweepShapeOfName(const std::string& name);
 
    virtual SweepShape GetSweepShape(int chan);
 
    virtual void SetSweepShape(int chan, SweepShape shape);
 
    enum SweepSpacing
    {
        SWEEP_SPACING_LINEAR,
        SWEEP_SPACING_LOG
    };
 
    static std::string GetNameOfSweepSpacing(SweepSpacing spacing);
 
    static SweepSpacing GetSweepSpacingOfName(const std::string& name);
 
    virtual SweepSpacing GetSweepSpacing(int chan);
 
    virtual void SetSweepSpacing(int chan, SweepSpacing shape);
 
    enum SweepDirection
    {
        SWEEP_DIR_FWD,
        SWEEP_DIR_REV
    };
 
    static std::string GetNameOfSweepDirection(SweepDirection dir);
 
    static SweepDirection GetSweepDirectionOfName(const std::string& name);
 
    virtual SweepDirection GetSweepDirection(int chan);
 
    virtual void SetSweepDirection(int chan, SweepDirection dir);
 
    virtual bool AcquireData() override;
 
    // Serialization
 
protected:
    void DoSerializeConfiguration(YAML::Node& node, IDTable& table);
 
    void DoLoadConfiguration(int version, const YAML::Node& node, IDTable& idmap);
 
    void DoPreLoadConfiguration(int version, const YAML::Node& node, IDTable& idmap, ConfigWarningList& list);
};
 
#endif