dspdevicemimoengine.h

Go to the documentation of this file.

// Copyright (C) 2019 F4EXB                                                      //
// written by Edouard Griffiths                                                  //
//                                                                               //
// This program is free software; you can redistribute it and/or modify          //
// it under the terms of the GNU General Public License as published by          //
// the Free Software Foundation as version 3 of the License, or                  //
// (at your option) any later version.                                           //
//                                                                               //
// This program is distributed in the hope that it will be useful,               //
// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
// GNU General Public License V3 for more details.                               //
//                                                                               //
// You should have received a copy of the GNU General Public License             //
// along with this program. If not, see <http://www.gnu.org/licenses/>.          //

#ifndef SDRBASE_DSP_DSPDEVICEMIMOENGINE_H_
#define SDRBASE_DSP_DSPDEVICEMIMOENGINE_H_

#include <QThread>

#include "dsp/dsptypes.h"
#include "util/message.h"
#include "util/messagequeue.h"
#include "util/syncmessenger.h"
#include "util/movingaverage.h"
#include "export.h"

class DeviceSampleMIMO;
class ThreadedBasebandSampleSource;
class ThreadedBasebandSampleSink;
class BasebandSampleSink;

class SDRBASE_API DSPDeviceMIMOEngine : public QThread {
    Q_OBJECT

public:
    class SetSampleMIMO : public Message {
        MESSAGE_CLASS_DECLARATION
    public:
        SetSampleMIMO(DeviceSampleMIMO* sampleMIMO) : Message(), m_sampleMIMO(sampleMIMO) { }
        DeviceSampleMIMO* getSampleMIMO() const { return m_sampleMIMO; }
    private:
        DeviceSampleMIMO* m_sampleMIMO;
    };

    class AddThreadedBasebandSampleSource : public Message {
        MESSAGE_CLASS_DECLARATION
    public:
        AddThreadedBasebandSampleSource(ThreadedBasebandSampleSource* threadedSampleSource, unsigned int index) :
            Message(),
            m_threadedSampleSource(threadedSampleSource),
            m_index(index)
        { }
        ThreadedBasebandSampleSource* getThreadedSampleSource() const { return m_threadedSampleSource; }
        unsigned int getIndex() const { return m_index; }
    private:
        ThreadedBasebandSampleSource* m_threadedSampleSource;
        unsigned int m_index;
    };

    class AddSourceStream : public Message {
        MESSAGE_CLASS_DECLARATION
    public:
        AddSourceStream(bool connect) : Message(), m_connect(connect) { }
        bool getConnect() const { return m_connect; }
    private:
        bool m_connect;
    };

    class RemoveLastSourceStream : public Message {
        MESSAGE_CLASS_DECLARATION
    };

    class AddSinkStream : public Message {
        MESSAGE_CLASS_DECLARATION
    public:
        AddSinkStream(bool connect) : Message(), m_connect(connect) { }
        bool getConnect() const { return m_connect; }
    private:
        bool m_connect;
    };

    class RemoveLastSinkStream : public Message {
        MESSAGE_CLASS_DECLARATION
    };

    class RemoveThreadedBasebandSampleSource : public Message {
        MESSAGE_CLASS_DECLARATION

    public:
        RemoveThreadedBasebandSampleSource(ThreadedBasebandSampleSource* threadedSampleSource, unsigned int index) :
            Message(),
            m_threadedSampleSource(threadedSampleSource),
            m_index(index)
        { }
        ThreadedBasebandSampleSource* getThreadedSampleSource() const { return m_threadedSampleSource; }
        unsigned int getIndex() const { return m_index; }
    private:
        ThreadedBasebandSampleSource* m_threadedSampleSource;
        unsigned int m_index;
    };

    class AddThreadedBasebandSampleSink : public Message {
        MESSAGE_CLASS_DECLARATION
    public:
        AddThreadedBasebandSampleSink(ThreadedBasebandSampleSink* threadedSampleSink, unsigned int index) :
            Message(),
            m_threadedSampleSink(threadedSampleSink),
            m_index(index)
        { }
        ThreadedBasebandSampleSink* getThreadedSampleSink() const { return m_threadedSampleSink; }
        unsigned int getIndex() const { return m_index; }
    private:
        ThreadedBasebandSampleSink* m_threadedSampleSink;
        unsigned int m_index;
    };

    class RemoveThreadedBasebandSampleSink : public Message {
        MESSAGE_CLASS_DECLARATION
    public:
        RemoveThreadedBasebandSampleSink(ThreadedBasebandSampleSink* threadedSampleSink, unsigned int index) :
            Message(),
            m_threadedSampleSink(threadedSampleSink),
            m_index(index)
        { }
        ThreadedBasebandSampleSink* getThreadedSampleSink() const { return m_threadedSampleSink; }
        unsigned int getIndex() const { return m_index; }
    private:
        ThreadedBasebandSampleSink* m_threadedSampleSink;
        unsigned int m_index;
    };

    class AddBasebandSampleSink : public Message {
        MESSAGE_CLASS_DECLARATION
    public:
        AddBasebandSampleSink(BasebandSampleSink* sampleSink, unsigned int index) :
            Message(),
            m_sampleSink(sampleSink),
            m_index(index)
        { }
        BasebandSampleSink* getSampleSink() const { return m_sampleSink; }
        unsigned int getIndex() const { return m_index; }
    private:
        BasebandSampleSink* m_sampleSink;
        unsigned int m_index;
    };

    class RemoveBasebandSampleSink : public Message {
        MESSAGE_CLASS_DECLARATION
    public:
        RemoveBasebandSampleSink(BasebandSampleSink* sampleSink, unsigned int index) :
            Message(),
            m_sampleSink(sampleSink),
            m_index(index)
        { }
        BasebandSampleSink* getSampleSink() const { return m_sampleSink; }
        unsigned int getIndex() const { return m_index; }
    private:
        BasebandSampleSink* m_sampleSink;
        unsigned int m_index;
    };

    class AddSpectrumSink : public Message {
        MESSAGE_CLASS_DECLARATION
    public:
        AddSpectrumSink(BasebandSampleSink* sampleSink) : Message(), m_sampleSink(sampleSink) { }
        BasebandSampleSink* getSampleSink() const { return m_sampleSink; }
    private:
        BasebandSampleSink* m_sampleSink;
    };

    class RemoveSpectrumSink : public Message {
        MESSAGE_CLASS_DECLARATION
    public:
        RemoveSpectrumSink(BasebandSampleSink* sampleSink) : Message(), m_sampleSink(sampleSink) { }
        BasebandSampleSink* getSampleSink() const { return m_sampleSink; }
    private:
        BasebandSampleSink* m_sampleSink;
    };

    class GetErrorMessage : public Message {
        MESSAGE_CLASS_DECLARATION
    public:
        void setErrorMessage(const QString& text) { m_errorMessage = text; }
        const QString& getErrorMessage() const { return m_errorMessage; }
    private:
        QString m_errorMessage;
    };

    class GetMIMODeviceDescription : public Message {
        MESSAGE_CLASS_DECLARATION
    public:
        void setDeviceDescription(const QString& text) { m_deviceDescription = text; }
        const QString& getDeviceDescription() const { return m_deviceDescription; }
    private:
        QString m_deviceDescription;
    };

    class ConfigureCorrection : public Message {
        MESSAGE_CLASS_DECLARATION
    public:
        ConfigureCorrection(bool dcOffsetCorrection, bool iqImbalanceCorrection, unsigned int index) :
            Message(),
            m_dcOffsetCorrection(dcOffsetCorrection),
            m_iqImbalanceCorrection(iqImbalanceCorrection),
            m_index(index)
        { }
        bool getDCOffsetCorrection() const { return m_dcOffsetCorrection; }
        bool getIQImbalanceCorrection() const { return m_iqImbalanceCorrection; }
        unsigned int getIndex() const { return m_index; }
    private:
        bool m_dcOffsetCorrection;
        bool m_iqImbalanceCorrection;
        unsigned int m_index;
    };

    class SetSpectrumSinkInput : public Message {
        MESSAGE_CLASS_DECLARATION
    public:
        SetSpectrumSinkInput(bool sourceElseSink, int index) :
            m_sourceElseSink(sourceElseSink),
            m_index(index)
        { }
        bool getSourceElseSink() const { return m_sourceElseSink; }
        int getIndex() const { return m_index; }
    private:
        bool m_sourceElseSink;
        int m_index;
    };

    enum State {
        StNotStarted,  
        StIdle,        
        StReady,       
        StRunning,     
        StError        
    };

    DSPDeviceMIMOEngine(uint32_t uid, QObject* parent = nullptr);
    ~DSPDeviceMIMOEngine();

    MessageQueue* getInputMessageQueue() { return &m_inputMessageQueue; }

    void start(); 
    void stop();  

    bool initProcess();  
    bool startProcess(); 
    void stopProcess();  

    void setMIMO(DeviceSampleMIMO* mimo); 
    DeviceSampleMIMO *getMIMO() { return m_deviceSampleMIMO; }
    void setMIMOSequence(int sequence); 
    uint getUID() const { return m_uid; }

    void addSourceStream(bool connect);
    void removeLastSourceStream();
    void addSinkStream(bool connect);
    void removeLastSinkStream();

    void addChannelSource(ThreadedBasebandSampleSource* source, int index = 0);    
    void removeChannelSource(ThreadedBasebandSampleSource* source, int index = 0); 
    void addChannelSink(ThreadedBasebandSampleSink* sink, int index = 0);          
    void removeChannelSink(ThreadedBasebandSampleSink* sink, int index = 0);       

    void addAncillarySink(BasebandSampleSink* sink, int index = 0);    
    void removeAncillarySink(BasebandSampleSink* sink, int index = 0); 

    void addSpectrumSink(BasebandSampleSink* spectrumSink);    
    void removeSpectrumSink(BasebandSampleSink* spectrumSink); 
    void setSpectrumSinkInput(bool sourceElseSink, int index);

    State state() const { return m_state; } 

    QString errorMessage(); 
    QString deviceDescription(); 

    void configureCorrections(bool dcOffsetCorrection, bool iqImbalanceCorrection, int isource); 

private:
    struct SourceCorrection
    {
        bool m_dcOffsetCorrection;
        bool m_iqImbalanceCorrection;
        double m_iOffset;
        double m_qOffset;
        int m_iRange;
        int m_qRange;
        int m_imbalance;
        MovingAverageUtil<int32_t, int64_t, 1024> m_iBeta;
        MovingAverageUtil<int32_t, int64_t, 1024> m_qBeta;
#if IMBALANCE_INT
        // Fixed point DC + IQ corrections
        MovingAverageUtil<int64_t, int64_t, 128> m_avgII;
        MovingAverageUtil<int64_t, int64_t, 128> m_avgIQ;
        MovingAverageUtil<int64_t, int64_t, 128> m_avgPhi;
        MovingAverageUtil<int64_t, int64_t, 128> m_avgII2;
        MovingAverageUtil<int64_t, int64_t, 128> m_avgQQ2;
        MovingAverageUtil<int64_t, int64_t, 128> m_avgAmp;
#else
        // Floating point DC + IQ corrections
        MovingAverageUtil<float, double, 128> m_avgII;
        MovingAverageUtil<float, double, 128> m_avgIQ;
        MovingAverageUtil<float, double, 128> m_avgII2;
        MovingAverageUtil<float, double, 128> m_avgQQ2;
        MovingAverageUtil<double, double, 128> m_avgPhi;
        MovingAverageUtil<double, double, 128> m_avgAmp;
#endif
        SourceCorrection()
        {
            m_dcOffsetCorrection = false;
            m_iqImbalanceCorrection = false;
            m_iOffset = 0;
            m_qOffset = 0;
            m_iRange = 1 << 16;
            m_qRange = 1 << 16;
            m_imbalance = 65536;
            m_iBeta.reset();
            m_qBeta.reset();
            m_avgAmp.reset();
            m_avgII.reset();
            m_avgII2.reset();
            m_avgIQ.reset();
            m_avgPhi.reset();
            m_avgQQ2.reset();
            m_iBeta.reset();
            m_qBeta.reset();
        }
    };

    uint32_t m_uid; 
    State m_state;

    QString m_errorMessage;
    QString m_deviceDescription;

    DeviceSampleMIMO* m_deviceSampleMIMO;
    int m_sampleMIMOSequence;

    MessageQueue m_inputMessageQueue;  //<! Input message queue. Post here.
    SyncMessenger m_syncMessenger;     

    typedef std::list<BasebandSampleSink*> BasebandSampleSinks;
    std::vector<BasebandSampleSinks> m_basebandSampleSinks; 

    typedef std::list<ThreadedBasebandSampleSink*> ThreadedBasebandSampleSinks;
    std::vector<ThreadedBasebandSampleSinks> m_threadedBasebandSampleSinks; 
    std::vector<int> m_sampleSinkConnectionIndexes;

    typedef std::list<ThreadedBasebandSampleSource*> ThreadedBasebandSampleSources;
    std::vector<ThreadedBasebandSampleSources> m_threadedBasebandSampleSources; 
    std::vector<int> m_sampleSourceConnectionIndexes;

    std::vector<SourceCorrection> m_sourcesCorrections;

    BasebandSampleSink *m_spectrumSink; 
    bool m_spectrumInputSourceElseSink; 
    unsigned int m_spectrumInputIndex;  

    void run();
    void work(int nbWriteSamples); 

    State gotoIdle();     
    State gotoInit();     
    State gotoRunning();  
    State gotoError(const QString& errorMsg); 

    void handleSetMIMO(DeviceSampleMIMO* mimo); 
    void iqCorrections(SampleVector::iterator begin, SampleVector::iterator end, int isource, bool imbalanceCorrection);

private slots:
    void handleData();                 
    void workSampleSink(unsigned int sinkIndex);
    void handleSynchronousMessages();  
    void handleInputMessages();        
    void handleForwardToSpectrumSink(int nbSamples);
};

#endif // SDRBASE_DSP_DSPDEVICEMIMOENGINE_H_