oscilloscope example,how to add a square wave on the canvas

[jetsu]

hi,everyone
oscilloscope program give me methods to sample the voltage from ADC of s3c2440 platform.Now I have got it.
Then I want to add a square wave on the canvas which could be a comparison with the sampling curve.
I don't know how to implement it.
I know how to add a curve in plot.cpp:

p_curve = new QwtPlotCurve();
    p_curve->setStyle(QwtPlotCurve::Steps);
    p_curve->setPen(QPen(Qt::green));
    p_curve->setRenderHint(QwtPlotItem::RenderAntialiased, true);
    p_curve->setPaintAttribute(QwtPlotCurve::ClipPolygons, false);
    p_curve->setData(SquareWaveData());
    p_curve->attach(this);

p_curve = new QwtPlotCurve();
    p_curve->setStyle(QwtPlotCurve::Steps);
    p_curve->setPen(QPen(Qt::green));
    p_curve->setRenderHint(QwtPlotItem::RenderAntialiased, true);
    p_curve->setPaintAttribute(QwtPlotCurve::ClipPolygons, false);
    p_curve->setData(SquareWaveData());
    p_curve->attach(this);

To copy to clipboard, switch view to plain text mode 

The problem is how to produce the data for the square wave which is synchronous with the sampling curve?

[d_stranz]

The problem is how to produce the data for the square wave which is synchronous with the sampling curve?

This isn't a Qwt question, it's a data processing question.

If you are sampling the ADC voltage, then you need to find each zero crossing of the sample data and set up your square wave data so it has steps at each sample zero crossing, and amplitude equal to the maximum (or minimum, depending on which direction the zero crossing goes) between zeroes.

If the sample data are supposed to be periodic with a fixed frequency, then simply find the first zero crossing (so you know where to start your model curve) and create a regular square wave at the expected frequency. If the sample matches the model, then the zero crossings for both of them will be in alignment, and the amplitudes should be the same as well. If the sample frequency varies, then the zero crossing won't all match up; if the sample amplitude varies, then the maxima of the sample and model curves won't match, either.

If your sample data are noisy, you may need to do some signal averaging (like a 3- or 5-point moving window average) to avoid detecting zero crossings that occur simply due to noise.

[jetsu]

thanks for your reply,the sample data is periodic with a fixed frequency when the program is running.while next time I may need to change the frequency.
I just want to produce a square wave with alterable frequency and duty,which should be synchronous with the sampling curve.In other words,the square wave is the ideal curve,the sampling curve is the actual one.
the following shows how I implement the sampling thread:

#include "samplingthread.h"
#include "signaldata.h"
#include <qwt_math.h>
#include <math.h>
 
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <linux/fs.h>
#include <errno.h>
#include <string.h>
 
SamplingThread::SamplingThread(QObject *parent):
    QwtSamplingThread(parent)
{
    fd = open("/dev/adc", 0);
     if (fd < 0) {
           perror("open ADC device:");
    }
}
 
SamplingThread::~SamplingThread()
{
    close(fd);
}
 
void SamplingThread::sample(double elapsed)
{
    const QPointF s(elapsed, value(elapsed));
    SignalData::instance().append(s);
}
 
double SamplingThread::value(double) const
{
    int value = -1;
    char buffer[30];
 
    int len = read(fd, buffer, sizeof buffer -1);
    if (len > 0) {
        buffer[len] = '\0';
        sscanf(buffer, "%d", &value);
    } else {
         perror("read ADC device:");
    }
    const double v = (double)value;
    return v;
}

#include "samplingthread.h"
#include "signaldata.h"
#include <qwt_math.h>
#include <math.h>

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <linux/fs.h>
#include <errno.h>
#include <string.h>

SamplingThread::SamplingThread(QObject *parent):
    QwtSamplingThread(parent)
{
    fd = open("/dev/adc", 0);
     if (fd < 0) {
           perror("open ADC device:");
    }
}

SamplingThread::~SamplingThread()
{
    close(fd);
}

void SamplingThread::sample(double elapsed)
{
    const QPointF s(elapsed, value(elapsed));
    SignalData::instance().append(s);
}

double SamplingThread::value(double) const
{
    int value = -1;
    char buffer[30];

    int len = read(fd, buffer, sizeof buffer -1);
    if (len > 0) {
        buffer[len] = '\0';
        sscanf(buffer, "%d", &value);
    } else {
         perror("read ADC device:");
    }
    const double v = (double)value;
    return v;
}

To copy to clipboard, switch view to plain text mode 

[d_stranz]

Well, how hard is that? The code below assumes you use the same calling convention for the model data as you do for the sample data.

SquareWave::SquareWave( double periodInSec, double amplitude )
{
    // Member variables of SquareWave class
    d_period = periodInSec;
    d_amplitude = amplitude;
    d_offset = 0.0;  // offset in sec of first signal zero from square wave
}
 
void SquareWave::sample(double elapsed)
{
    const QPointF s(elapsed, value(elapsed));
    ModelData::instance().append(s);
}
 
double SquareWave::value( double elapsed ) const
{
    // This assumes that the sample starts out by going in the positive direction.
    // So, it returns an amplitude based on which half of the period the sample is on
    // by computing how many periods have elapsed so far.  If the number of periods
    // is even (%2 == 0), then it returns the positive amplitude, otherwise if it is
    // odd (%2 == 1), then it returns the negative amplitude.
 
    bool bEven = ( int( (elapsed - d_offset) / d_period ) % 2 == 0 ? true : false );
    if ( bEven )
       return d_amplitude;
    else
       return -d_amplitude;
}

SquareWave::SquareWave( double periodInSec, double amplitude )
{
    // Member variables of SquareWave class
    d_period = periodInSec;
    d_amplitude = amplitude;
    d_offset = 0.0;  // offset in sec of first signal zero from square wave
}

void SquareWave::sample(double elapsed)
{
    const QPointF s(elapsed, value(elapsed));
    ModelData::instance().append(s);
}

double SquareWave::value( double elapsed ) const
{
    // This assumes that the sample starts out by going in the positive direction.
    // So, it returns an amplitude based on which half of the period the sample is on
    // by computing how many periods have elapsed so far.  If the number of periods
    // is even (%2 == 0), then it returns the positive amplitude, otherwise if it is
    // odd (%2 == 1), then it returns the negative amplitude.

    bool bEven = ( int( (elapsed - d_offset) / d_period ) % 2 == 0 ? true : false );
    if ( bEven )
       return d_amplitude;
    else
       return -d_amplitude;
}

To copy to clipboard, switch view to plain text mode 

Obviously, I haven't compiled or tested this, but you should get the idea. Might need to multiply (d_period * 2.0) in the line that computes bEven.

[jetsu]

Well, how hard is that? The code below assumes you use the same calling convention for the model data as you do for the sample data.

SquareWave::SquareWave( double periodInSec, double amplitude )
{
    // Member variables of SquareWave class
    d_period = periodInSec;
    d_amplitude = amplitude;
    d_offset = 0.0;  // offset in sec of first signal zero from square wave
}
 
void SquareWave::sample(double elapsed)
{
    const QPointF s(elapsed, value(elapsed));
    ModelData::instance().append(s);
}
 
double SquareWave::value( double elapsed ) const
{
    // This assumes that the sample starts out by going in the positive direction.
    // So, it returns an amplitude based on which half of the period the sample is on
    // by computing how many periods have elapsed so far.  If the number of periods
    // is even (%2 == 0), then it returns the positive amplitude, otherwise if it is
    // odd (%2 == 1), then it returns the negative amplitude.
 
    bool bEven = ( int( (elapsed - d_offset) / d_period ) % 2 == 0 ? true : false );
    if ( bEven )
       return d_amplitude;
    else
       return -d_amplitude;
}

SquareWave::SquareWave( double periodInSec, double amplitude )
{
    // Member variables of SquareWave class
    d_period = periodInSec;
    d_amplitude = amplitude;
    d_offset = 0.0;  // offset in sec of first signal zero from square wave
}

void SquareWave::sample(double elapsed)
{
    const QPointF s(elapsed, value(elapsed));
    ModelData::instance().append(s);
}

double SquareWave::value( double elapsed ) const
{
    // This assumes that the sample starts out by going in the positive direction.
    // So, it returns an amplitude based on which half of the period the sample is on
    // by computing how many periods have elapsed so far.  If the number of periods
    // is even (%2 == 0), then it returns the positive amplitude, otherwise if it is
    // odd (%2 == 1), then it returns the negative amplitude.

    bool bEven = ( int( (elapsed - d_offset) / d_period ) % 2 == 0 ? true : false );
    if ( bEven )
       return d_amplitude;
    else
       return -d_amplitude;
}

To copy to clipboard, switch view to plain text mode 

Obviously, I haven't compiled or tested this, but you should get the idea. Might need to multiply (d_period * 2.0) in the line that computes bEven.

thanks for your help.

[d_stranz]

Sure. Take a screen shot and post it so we can see if it worked.

[jetsu]

hello，d_stranz.here questions come.
in samplingThread.cpp,I add these code:

void SamplingThread::sample(double elapsed)
{
    const QPointF s(elapsed, value(elapsed));
    const QPointF s2(elapsed, value2(elapsed));
    SignalData::instance().append(s,s2);
}
double SamplingThread::value2(double timeStamp) const
{
    const double period = 1.0 / 5.0;//here 5.0 is the frequency
 
    const double x = ::fmod(timeStamp, period);
    bool bEven = ( int(x) % 2 == 0 ? true : false );
    if ( bEven )
      v = 400.0;//400.0 is the amplitude
    else
       v = 0;
    return v;
}

void SamplingThread::sample(double elapsed)
{
    const QPointF s(elapsed, value(elapsed));
    const QPointF s2(elapsed, value2(elapsed));
    SignalData::instance().append(s,s2);
}
double SamplingThread::value2(double timeStamp) const
{
    const double period = 1.0 / 5.0;//here 5.0 is the frequency

    const double x = ::fmod(timeStamp, period);
    bool bEven = ( int(x) % 2 == 0 ? true : false );
    if ( bEven )
      v = 400.0;//400.0 is the amplitude
    else
       v = 0;
    return v;
}

To copy to clipboard, switch view to plain text mode 

then I make changes in signaldata.h,signadata.cpp,curvedata.h and curvedata.cpp.
signaldata.h:

#ifndef _SIGNAL_DATA_H_
#define _SIGNAL_DATA_H_ 1
 
#include <qrect.h>
 
class SignalData
{
public:
    static SignalData &instance();
 
    void append(const QPointF &pos,const QpointF &pos2);
    void clearStaleValues(double min);
 
    int size() const;
    QPointF value(int index) const;
    QPointF value2(int index) const;
    QRectF boundingRect() const;
 
    void lock();
    void unlock();
 
private:
    SignalData();
    SignalData(const SignalData &);
    SignalData &operator=( const SignalData & );
 
    virtual ~SignalData();
 
    class PrivateData;
    PrivateData *d_data;
};
 
#endif

#ifndef _SIGNAL_DATA_H_
#define _SIGNAL_DATA_H_ 1

#include <qrect.h>

class SignalData
{
public:
    static SignalData &instance();

    void append(const QPointF &pos,const QpointF &pos2);
    void clearStaleValues(double min);

    int size() const;
    QPointF value(int index) const;
    QPointF value2(int index) const;
    QRectF boundingRect() const;

    void lock();
    void unlock();
    
private:
    SignalData();
    SignalData(const SignalData &);
    SignalData &operator=( const SignalData & );

    virtual ~SignalData();

    class PrivateData;
    PrivateData *d_data;
};

#endif

To copy to clipboard, switch view to plain text mode 

signaldata.cpp:

#include "signaldata.h"
#include <qvector.h>
#include <qmutex.h>
#include <qreadwritelock.h>
 
class SignalData::PrivateData
{
public:
    PrivateData():
        boundingRect(1.0, 1.0, -2.0, -2.0) // invalid
    {
        values.reserve(1000);
    }
 
    inline void append(const QPointF &sample,const QPointF &squarewave)
    {
        values.append(sample);
        values2.append(squarewave);
        // adjust the bounding rectangle
 
        if ( boundingRect.width() < 0 || boundingRect.height() < 0 )
        {
            boundingRect.setRect(sample.x(), sample.y(), 0.0, 0.0);
        }
        else
        {
            boundingRect.setRight(sample.x());
 
            if ( sample.y() > boundingRect.bottom() )
                boundingRect.setBottom(sample.y());
 
            if ( sample.y() < boundingRect.top() )
                boundingRect.setTop(sample.y());
        }
    }
    QReadWriteLock lock;
 
    QVector<QPointF> values;
    QVector<QPointF> values2;
    QRectF boundingRect;
 
    QMutex mutex; // protecting pendingValues
    QVector<QPointF> pendingValues;
    QVector<QPointF> pendingValues2;
};
 
SignalData::SignalData()
{
    d_data = new PrivateData();
}
 
SignalData::~SignalData()
{
    delete d_data;
}
 
int SignalData::size() const
{
    return d_data->values.size();
}   
 
QPointF SignalData::value(int index) const
{
    return d_data->values[index];
}   
QPointF SignalData::value2(int index) const
{
    return d_data->values2[index]
}
QRectF SignalData::boundingRect() const
{
    return d_data->boundingRect;
}
 
void SignalData::lock()
{
    d_data->lock.lockForRead();
}
 
void SignalData::unlock()
{
    d_data->lock.unlock();
}
 
void SignalData::append(const QPointF &sample,const QPointF &squarewave)
{
    d_data->mutex.lock();
    d_data->pendingValues += sample;
    d_data->pendingValues += squarewave;
 
    const bool isLocked = d_data->lock.tryLockForWrite();
    if ( isLocked )
    {
        const int numValues = d_data->pendingValues.size();
        const QPointF *pendingValues = d_data->pendingValues.data();
        const QPointF *pendingValues = d_data->pendingValues2.data();
        for ( int i = 0; i < numValues; i++ )
            d_data->append(pendingValues[i],pendingValues2[i]);
 
        d_data->pendingValues.clear();
        d_data->pendingValues2.clear();
        d_data->lock.unlock();
    }
 
    d_data->mutex.unlock();
}
 
void SignalData::clearStaleValues(double limit)
{
    d_data->lock.lockForWrite();
 
    d_data->boundingRect = QRectF(1.0, 1.0, -2.0, -2.0); // invalid
 
    const QVector<QPointF> values = d_data->values;
    const QVector<QPointF> values2= d_data->values2;
    d_data->values.clear();
    d_data->values2.clear();
    d_data->values.reserve(values.size());
    d_data->values2.reserve(values2.size());
    #if 0
    int index;
    for ( index = values.size() - 1; index >= 0; index-- )
    {
        if ( values[index].x() < limit )
            break;
    }
 
    if ( index > 0 )
        d_data->append(values[index++]);
        d_data->append2(values2[index++]);
 
    while ( index < values.size() - 1 )
        d_data->append(values[index++]);
        d_data->append2(values2[index++]);
    #endif
    d_data->lock.unlock();
}
 
SignalData &SignalData::instance()
{
    static SignalData valueVector;
    return valueVector;
}

#include "signaldata.h"
#include <qvector.h>
#include <qmutex.h>
#include <qreadwritelock.h>

class SignalData::PrivateData
{
public:
    PrivateData():
        boundingRect(1.0, 1.0, -2.0, -2.0) // invalid
    {
        values.reserve(1000);
    }

    inline void append(const QPointF &sample,const QPointF &squarewave)
    {
        values.append(sample);
        values2.append(squarewave);
        // adjust the bounding rectangle

        if ( boundingRect.width() < 0 || boundingRect.height() < 0 )
        {
            boundingRect.setRect(sample.x(), sample.y(), 0.0, 0.0);
        }
        else
        {
            boundingRect.setRight(sample.x());

            if ( sample.y() > boundingRect.bottom() )
                boundingRect.setBottom(sample.y());

            if ( sample.y() < boundingRect.top() )
                boundingRect.setTop(sample.y());
        }
    }
    QReadWriteLock lock;

    QVector<QPointF> values;
    QVector<QPointF> values2;
    QRectF boundingRect;

    QMutex mutex; // protecting pendingValues
    QVector<QPointF> pendingValues;
    QVector<QPointF> pendingValues2;
};

SignalData::SignalData()
{
    d_data = new PrivateData();
}

SignalData::~SignalData()
{
    delete d_data;
}

int SignalData::size() const
{
    return d_data->values.size();
}   

QPointF SignalData::value(int index) const
{
    return d_data->values[index];
}   
QPointF SignalData::value2(int index) const
{
    return d_data->values2[index]
}
QRectF SignalData::boundingRect() const
{
    return d_data->boundingRect;
}

void SignalData::lock()
{
    d_data->lock.lockForRead();
}

void SignalData::unlock()
{
    d_data->lock.unlock();
}

void SignalData::append(const QPointF &sample,const QPointF &squarewave)
{
    d_data->mutex.lock();
    d_data->pendingValues += sample;
    d_data->pendingValues += squarewave;

    const bool isLocked = d_data->lock.tryLockForWrite();
    if ( isLocked )
    {
        const int numValues = d_data->pendingValues.size();
        const QPointF *pendingValues = d_data->pendingValues.data();
        const QPointF *pendingValues = d_data->pendingValues2.data();
        for ( int i = 0; i < numValues; i++ )
            d_data->append(pendingValues[i],pendingValues2[i]);

        d_data->pendingValues.clear();
        d_data->pendingValues2.clear();
        d_data->lock.unlock();
    }

    d_data->mutex.unlock();
}

void SignalData::clearStaleValues(double limit)
{
    d_data->lock.lockForWrite();

    d_data->boundingRect = QRectF(1.0, 1.0, -2.0, -2.0); // invalid

    const QVector<QPointF> values = d_data->values;
    const QVector<QPointF> values2= d_data->values2;
    d_data->values.clear();
    d_data->values2.clear();
    d_data->values.reserve(values.size());
    d_data->values2.reserve(values2.size());
    #if 0
    int index;
    for ( index = values.size() - 1; index >= 0; index-- )
    {
        if ( values[index].x() < limit )
            break;
    }

    if ( index > 0 )
        d_data->append(values[index++]);
        d_data->append2(values2[index++]);

    while ( index < values.size() - 1 )
        d_data->append(values[index++]);
        d_data->append2(values2[index++]);
    #endif
    d_data->lock.unlock();
}

SignalData &SignalData::instance()
{
    static SignalData valueVector;
    return valueVector;
}

To copy to clipboard, switch view to plain text mode 

curvedata.h:

#include <qwt_series_data.h>
#include <qpointer.h>
 
class SignalData;
 
class CurveData: public QwtSeriesData<QPointF>
{
public:
    const SignalData &values() const;
    SignalData &values();
 
    virtual QPointF sample(size_t i) const;
    virtual size_t size() const;
 
    virtual QRectF boundingRect() const;
};
class CurveData2: public QwtSeriesData<QPointF>
{
public:
    const SignalData &values2() const;
    SignalData &values2();
 
    virtual QPointF sample(size_t i) const;
    virtual size_t size() const;
 
    virtual QRectF boundingRect() const;
};

#include <qwt_series_data.h>
#include <qpointer.h>

class SignalData;

class CurveData: public QwtSeriesData<QPointF>
{
public:
    const SignalData &values() const;
    SignalData &values();

    virtual QPointF sample(size_t i) const;
    virtual size_t size() const;

    virtual QRectF boundingRect() const;
};
class CurveData2: public QwtSeriesData<QPointF>
{
public:
    const SignalData &values2() const;
    SignalData &values2();

    virtual QPointF sample(size_t i) const;
    virtual size_t size() const;

    virtual QRectF boundingRect() const;
};

To copy to clipboard, switch view to plain text mode 

curvedata.cpp:

#include "curvedata.h"
#include "signaldata.h"
 
const SignalData &CurveData::values() const
{
    return SignalData::instance();
}
const SignalData &CurveData2::values2() const
{
    return SignalData::instance();
}
SignalData &CurveData::values() 
{
    return SignalData::instance();
}
SignalData &CurveData2::values2() 
{
    return SignalData::instance();
}
QPointF CurveData::sample(size_t i) const
{
    return SignalData::instance().value(i);
}
QPointF CurveData2::sample(size_t i) const
{
    return SignalData::instance().value2(i);
}
size_t CurveData::size() const
{
    return SignalData::instance().size();
}
QRectF CurveData::boundingRect() const
{
    return SignalData::instance().boundingRect();
}

#include "curvedata.h"
#include "signaldata.h"

const SignalData &CurveData::values() const
{
    return SignalData::instance();
}
const SignalData &CurveData2::values2() const
{
    return SignalData::instance();
}
SignalData &CurveData::values() 
{
    return SignalData::instance();
}
SignalData &CurveData2::values2() 
{
    return SignalData::instance();
}
QPointF CurveData::sample(size_t i) const
{
    return SignalData::instance().value(i);
}
QPointF CurveData2::sample(size_t i) const
{
    return SignalData::instance().value2(i);
}
size_t CurveData::size() const
{
    return SignalData::instance().size();
}
QRectF CurveData::boundingRect() const
{
    return SignalData::instance().boundingRect();
}

To copy to clipboard, switch view to plain text mode 

I compile it then the error come in signaldata.h:QQ截图20120416120826.jpg
I don't know how to do,the program drive me insane.

[jetsu]

Now I can draw a square wave with fixed number of points on the canvas.
But I want to turn it into a dynamic one,like the sampling curve.
The frequency of the square wave is much slower than the sampling curve.
for example,the sampling frequency of the ADC is 200Hz,while the frequency of the dynamic square wave maybe 5Hz.
What should I do?

[d_stranz]

Now I can draw a square wave with fixed number of points on the canvas.
But I want to turn it into a dynamic one,like the sampling curve.
The frequency of the square wave is much slower than the sampling curve.
for example,the sampling frequency of the ADC is 200Hz,while the frequency of the dynamic square wave maybe 5Hz.
What should I do?

Then simply ask for the ModelData point 1/40 as often as you sample the signal data. The problem with your SampleData implementation is that it requires both a signal and a model point in each call to append(). So the way you have designed it, there is no way to sample the signal at a different rate than the model.

Instead of an append() method that requires two values, make two append methods: appendSignal() and appendModel(), each one taking one value as the argument. Then in your sample method, you can append a signal point with every call, but you only have to append a model point whenever the square wave goes from high->low or low->high. Put a member variable in your SamplingThread class that keeps track of the current value of the model. Initialize it to -1 or some other impossible value. When you enter the sample() method, compute the new value of the model point. If it is different from the value you have in the member variable, append the new model point and set the member variable equal to that. If it is not different, then do nothing. This will give you a square wave that follows the sample as closely as possible using this method - at the worst, it will be off by one sample period. (That is, if the model should go from high to low just after sample() is called, you won't find out until the next sample() call (1 / 200 second later). So you square wave will lag by at most 1 sample period, but it has 40x fewer points.

void SamplingThread::sample(double elapsed)
{
    const QPointF s(elapsed, value(elapsed));
    SignalData::instance().appendSignal( s );
 
    double newValue = value2( elapsed );
    if ( newValue != savedValue )
    {
        const QPointF s2(elapsed, newValue);
        savedValue = newValue;
 
        SignalData::instance().appendModel(s2);
    }
}

void SamplingThread::sample(double elapsed)
{
    const QPointF s(elapsed, value(elapsed));
    SignalData::instance().appendSignal( s );

    double newValue = value2( elapsed );
    if ( newValue != savedValue )
    {
        const QPointF s2(elapsed, newValue);
        savedValue = newValue;

        SignalData::instance().appendModel(s2);
    }
}

To copy to clipboard, switch view to plain text mode 

All of this assumes that your sample has a fixed frequency (or fixed period). If your signal does not have a fixed frequency (that is, transitions high->low or low->high can occur at any time), then you need to add more member variables that keep track of when the sample crosses zero. Your square wave has to track these transitions, and make the same transitions (high->low or low->high) when the sample does. You can't use the modulus arithmetic, because that assumes a fixed frequency.

[jetsu]

if we use two append() methods,there is only only one signaldata class and curvedata class,how should I set the data for p_curve?

p_curve->setData(new curvedata());

p_curve->setData(new curvedata());

To copy to clipboard, switch view to plain text mode 

[Uwe]

You can't share a CurveData instance as each curve takes ownership of the data bridge, when it has been assigned.

Uwe

[d_stranz]

if we use two append() methods,there is only only one signaldata class and curvedata class,how should I set the data for p_curve?

Your SignalData::PrivateData class has *two* QPointF arrays: values and values2. You are using one of these for the sample and one of them for the model, right? appendSignal() should put a new point onto the end of values, and appendModel() should put a new point onto the end of values2. What is the problem?

Have you made your design so complicated that you don't understand it any more?

When I originally offered you a solution to this, I gave you another class: ModelData. You decided to combine the sample and the model into one class, SignalData, and now you are getting confused because you are using one class to hold two different things, and your design makes that class a Singleton. It is getting you into trouble, because now you can have values and values2 with different lengths, but there is only one size() member function, and that is returning the length of values. Likewise for the other member functions - they are using values, and same property for values2 might be different. If you are depending on size() to set the points into the curves, then one curve will be wrong.

[jetsu]

thanks a lot. I have got the idea.
I change the program with the method you told me. And I add a Plot::update2() in plot.h and plot.cpp.there are indeed two dynamic lines on the canvas now.
I will add a screen shot function in the program later.Then I will post the photo here to share my joy with you.
Thanks again.

[yuanxingood]

Hello，I also want to add another wave,but i can't do it.I think we have the same problem.So can you give me your succeed code?Thank you!

[onelore]

Hello, I have the same problem. Can you post your code? thank you very much