try1

//#include MAINWINDOW_H


#include <qwidget.h>
#include <QComboBox>
#include <QPushButton>
#include <QLabel>
#include <QScrollArea>
#include <QSpinBox>
#include <QSignalMapper>
#include <QModelIndex>
#include <QtGlobal>
#include <QMainWindow>
#include <QLCDNumber>

#include <QStatusBar>

#include "qfirmata.h"

class Plot;
class Knob;
class WheelBox;
class SamplingThread;


class MainWindow : public QWidget
{
    Q_OBJECT

public:
    MainWindow( QWidget * = NULL );

    void start();

    double amplitude() const;
    double frequency() const;
    double signalInterval() const;
    int analoginp;

//private Q_SLOTS:
public Q_SLOTS:
    void onFirmwareVersionReceived(const int majorVersion, const int minorVersion);
    void onFirmwareNameReceived(QString firmwareName);
    void onInitialized(const int majorVersion, const int minorVersion, QString firmwareName);
    void onAnalogPinChanged(int pin);
    void onAnalogPinReportinChange(unsigned int pin, bool value);
    void onDigitalPinChanged(int pin);
    void on_pushButtonConnect_clicked();
    void on_pushButtonDisconnect_clicked();
    void on_pushButtonConnect_2_clicked();
    void on_pushButtonDisconnect_2_clicked();
    void samplesValueThis();
   // void setStatusBar(QStatusBar *statusbar);
Q_SIGNALS:
    void amplitudeChanged( double );
    void frequencyChanged( double );
    void signalIntervalChanged( double );
    void transferAnalog(int);


private:
    QFirmata *_firmata;
    Knob *d_frequencyKnob;
    Knob *d_amplitudeKnob;
    WheelBox *d_timerWheel;
    WheelBox *d_intervalWheel;
    QComboBox *_portComboBox;
    QPushButton *_connectButton;
    QPushButton *_disconnectButton;
    QLabel *_firmwareLabel;
    QLCDNumber *_lcddisplay;
    SamplingThread *d_samplingThread;


    Plot *d_plot;

};






#include "mainwindow.h"
#include "plot.h"
#include "knob.h"
#include "wheelbox.h"
#include "samplingthread.h"
#include <qwt_scale_engine.h>
#include <qlabel.h>
#include <qlayout.h>
#include <QComboBox>
#include <QDebug>
#include <QDesktopWidget>
#include <QScreen>
#include <QMessageBox>
#include <QMetaEnum>
#include <QSerialPort>
#include <QSerialPortInfo>
#include <QtGlobal>
#include <QMainWindow>

MainWindow::MainWindow( QWidget *parent ):
    QWidget( parent ),
    _firmata(new QFirmata(this))


{

    const double intervalLength = 10.0; // seconds

    d_plot = new Plot( this );
    d_plot->setIntervalLength( intervalLength );

    d_amplitudeKnob = new Knob( "Amplitude", 0.0, 5000.0, this );
    d_amplitudeKnob->setValue( 160.0 );

    d_frequencyKnob = new Knob( "Frequency [Hz]", 0.1, 20.0, this );
    d_frequencyKnob->setValue( 17.8 );

    d_intervalWheel = new WheelBox( "Displayed [s]", 1.0, 100.0, 1.0, this );
    d_intervalWheel->setValue( intervalLength );

    d_timerWheel = new WheelBox( "Sample Interval [ms]", 0.0, 20.0, 0.1, this );
    d_timerWheel->setValue( 10.0 );

    d_samplingThread = new SamplingThread (this);





    _portComboBox = new QComboBox(this);
   Q_FOREACH (const QSerialPortInfo &info, QSerialPortInfo::availablePorts())
    {
        _portComboBox->addItem(info.portName());
   }

    _connectButton = new QPushButton(tr("connect"),this);
    _disconnectButton = new QPushButton(tr("disconnect"),this);
    _firmwareLabel = new QLabel();
      QLabel *serialLabel = new QLabel("Serial settings");
      QFont font = serialLabel->font();
      font.setBold(true);
      font.setPointSize(10);
      serialLabel->setFont(font);
      QLabel *serialLabel2 = new QLabel("LCD Display");
      QFont font2 = serialLabel2->font();
      font2.setBold(true);
      font2.setPointSize(10);
      serialLabel2->setFont(font2);

    _lcddisplay = new QLCDNumber(this);
    _lcddisplay ->setGeometry(QRect(30,70,10,41));


 QVBoxLayout* vLayout1 = new QVBoxLayout();
    vLayout1->addWidget( d_intervalWheel );
    vLayout1->addWidget( d_timerWheel );
    vLayout1->addStretch( 10 );
    vLayout1->addWidget( d_amplitudeKnob );
    vLayout1->addWidget( d_frequencyKnob );


   //  vLayout1->addWidget(serialLabel);

//    QHBoxLayout *layout2 = new QHBoxLayout( this );
//    layout2->addWidget(_connectButton);
//    layout2->addWidget(_disconnectButton);

     QVBoxLayout* vLayout2 = new QVBoxLayout();
     vLayout2 ->addWidget(serialLabel);
     vLayout2->addWidget(_portComboBox);
     //vLayout2->addLayout(layout2);
     vLayout2->addWidget(_connectButton);
     vLayout2->addWidget(_disconnectButton);
     vLayout2->addWidget(_firmwareLabel);
     vLayout2->addSpacerItem(new QSpacerItem(3,3,QSizePolicy::Expanding));
     vLayout2 ->addWidget(serialLabel2);
     vLayout2->addWidget(_lcddisplay);



    QHBoxLayout *layout = new QHBoxLayout( this );
    layout->addWidget( d_plot, 10 );
    layout->addLayout( vLayout1 );
    layout->addSpacing(30);
    layout->addLayout( vLayout2 );



//    _connectButton = new QPushButton(tr("connect"),this);
//    _disconnectButton = new QPushButton(tr("disconnect"),this);
//    _firmwareLabel = new QLabel();


//   QWidget *widget = new QWidget(this);

//   QWidget *serialWidget = new QWidget(this);
//   QVBoxLayout *serialWidgetLayout = new QVBoxLayout(serialWidget);
//   serialWidget->setLayout(serialWidgetLayout);
//   serialWidgetLayout->addWidget(_portComboBox);
//  serialWidgetLayout->addWidget(_connectButton);
//   serialWidgetLayout->addWidget(_disconnectButton);
//   serialWidgetLayout->addWidget(_firmwareLabel);
//





  //layout->addWidget(serialLabel);
   //layout->addLayout(serialWidgetLayout);

//    d_samplingThread.setFrequency( frequency() );
//    d_samplingThread.setAmplitude( amplitude() );
//    d_samplingThread.setInterval( signalInterval() );

//    connect( d_amplitudeKnob, SIGNAL( valueChanged( double ) ),
//        SLOT( amplitudeChanged( double ) ) );
//    connect( d_frequencyKnob, SIGNAL( valueChanged( double ) ),
//        SLOT( frequencyChanged( double ) ) );
//    connect( d_timerWheel, SIGNAL( valueChanged( double ) ),
//        SLOT( signalIntervalChanged( double ) ) );

//    connect( d_intervalWheel, SIGNAL( valueChanged( double ) ),
//        d_plot, SLOT( setIntervalLength( double ) ) );

    connect(_firmata, SIGNAL(firmwareVersionReceived(int, int)), this, SLOT(onFirmwareVersionReceived(int,int)));
    connect(_firmata, SIGNAL(firmwareNameReceived(QString)), this, SLOT(onFirmwareNameReceived(QString)));
    connect(_firmata, SIGNAL(initialized(int,int,QString)), this, SLOT(onInitialized(int,int,QString)));
    connect(_firmata, SIGNAL(digitalPinChanged(int)), this, SLOT(onDigitalPinChanged(int)));
    connect(_firmata, SIGNAL(analogPinChanged(int)), this, SLOT(onAnalogPinChanged(int)));




    connect(_connectButton, SIGNAL(clicked()), this, SLOT(on_pushButtonConnect_clicked()));
     connect(_disconnectButton, SIGNAL(clicked()), this, SLOT(on_pushButtonDisconnect_clicked()));
    connect(d_samplingThread, SIGNAL(transfeAnalog(int)), this, SLOT(samplesValueThis()));
    // connect(_firmata, SIGNAL(tranferAnalog(int) ),this, SLOT( samplesValueThis() )  );
}


void MainWindow::start()
{
    d_plot->start();

}

double MainWindow::frequency() const
{
    return d_frequencyKnob->value();
    qDebug()<<"frequency";
}

double MainWindow::amplitude() const
{
    return d_amplitudeKnob->value();
    qDebug()<<"amplitude";
}

double MainWindow::signalInterval() const
{
    return d_timerWheel->value();
}


void MainWindow::onFirmwareVersionReceived(const int majorVersion, const int minorVersion)
{
    qDebug()<<"major"<<majorVersion<<"minor"<<minorVersion;
}

void MainWindow::onFirmwareNameReceived(QString firmwareName)
{
    qDebug()<<"firmware name"<<firmwareName;
}

void MainWindow::onInitialized(const int majorVersion, const int minorVersion, QString firmwareName)
{
    qDebug()<<"firmate initialized"<<majorVersion<<minorVersion<<firmwareName;
   //statusBar()->showMessage(tr("initialized"), 5000);

  // QString statusText = QString::number(majorVersion)+"."+QString::number(minorVersion);
 // _firmata->send;

}

void MainWindow::onAnalogPinChanged(int pin)
{


analoginp = _firmata->getAnalog(pin);
qDebug()<<"analog pin change"<<pin<<"changed. new value"<<analoginp;
_lcddisplay->display(analoginp);

 Q_EMIT transferAnalog(analoginp);




}


void MainWindow::onAnalogPinReportinChange(unsigned int pin, bool value)
{
    qDebug()<<"analog pin reporting"<<pin<<"changed. new value"<<value;

    if(value)
    {
        _firmata->sendAnalogPinReporting(pin, ARD_ANALOG);
    }
    else
    {
        _firmata->sendAnalogPinReporting(pin, ARD_OFF);
    }
}

void MainWindow::onDigitalPinChanged(int pin)
{
    qDebug()<<"digital pin"<<pin<<"changed. new value"<<_firmata->getDigital(pin);

}

void MainWindow::on_pushButtonConnect_clicked()
{
    _firmata->open(_portComboBox->currentText());
  //statusBar()->showMessage(tr("[Notice] Successfully open connection"), 5000);

    _firmata->sendAnalogPinReporting(3, ARD_ANALOG);

   _firmata->sendDigitalPinMode(13,ARD_OUTPUT);
}


void MainWindow::on_pushButtonDisconnect_clicked()
{
    _firmata->close();
  //   _connectButton->show();
  //  _disconnectButton->hide();
  // _firmwareLabel->setText("");
  //  statusBar()->showMessage(tr("[Notice] Successfully closed connection"), 5000);

}


void MainWindow::on_pushButtonConnect_2_clicked()
{
   _firmata->sendDigital(13,ARD_ON);

}

void MainWindow::on_pushButtonDisconnect_2_clicked()
{
    _firmata->sendDigital(13,ARD_OFF);
}


void MainWindow::samplesValueThis()
{
    d_samplingThread -> setSampleValue(analoginp);
}






----------------------------------------------------------------------------------------------------



#include <qwt_sampling_thread.h>
#include <qfirmata.h>

class SamplingThread: public QwtSamplingThread
{
    Q_OBJECT

public:
    SamplingThread( QObject *parent = NULL );

    double frequency() const;
    double amplitude() const;
    int analoginput;
    int pin;
    static int analoginp;


public Q_SLOTS:
    void setAmplitude( double );
    void setFrequency( double );
    void setSampleValue(int);
//    void onFirmwareVersionReceived(const int majorVersion, const int minorVersion);
//    void onFirmwareNameReceived(QString firmwareName);
//    void onInitialized(const int majorVersion, const int minorVersion, QString firmwareName);
//    void onAnalogPinChanged(int pin);
//    void onAnalogPinReportinChange(unsigned int pin, bool value);
//    void onDigitalPinChanged(int pin);

protected:
    virtual void sample( double elapsed );

private:
    virtual double value( double timeStamp ) const;

    double d_frequency;
    double d_amplitude;
    QFirmata *_firmata2;
    double sampleValue;
};







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

#if QT_VERSION < 0x040600
#define qFastSin(x) ::sin(x)
#endif

SamplingThread::SamplingThread( QObject *parent ):
    QwtSamplingThread( parent ),
    d_frequency( 5.0 ),
    d_amplitude( 20.0 ),
  sampleValue (0)



{

}

void SamplingThread::setFrequency( double frequency )
{
    d_frequency = frequency;
    qDebug()<<"display frequency"<<d_frequency;
}

double SamplingThread::frequency() const
{
    return d_frequency;
}

void SamplingThread::setAmplitude( double amplitude )
{
    d_amplitude = amplitude;
}

double SamplingThread::amplitude() const
{
    return d_amplitude;
}

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

double SamplingThread::value( double timeStamp ) const
{
   //analoginput = MainWindow::analoginp;
    const double period = 1.0 / d_frequency;

    const double x = ::fmod( timeStamp, period );
    //const double v = d_amplitude * analoginput;
   //const double v = d_amplitude * qFastSin( x / period * 2 * M_PI );
    //const double v = d_amplitude;
   const double v = d_amplitude * sampleValue * 0.001;
   qDebug()<<"value V"<< v;
   qDebug()<<"amplitude"<< d_amplitude;
   qDebug()<<"SV"<< sampleValue;
    return v;

}

void SamplingThread::setSampleValue(int samples)
{
  analoginp = (double)samples;
  qDebug()<<"sample value"<< analoginp << "nilai sample" << samples;


}