MAINT: convert rest of sensor plugins

Author: gabrielbmotta

src/applications/mne_scan/plugins/brainamp/brainamp.cpp

@@ -100,7 +100,7 @@ BrainAMP::~BrainAMP()
     //std::cout << "BrainAMP::~BrainAMP() " << std::endl;
 
     //If the program is closed while the sampling is in process
-    if(this->isRunning()) {
+    if(m_bProcessOutput) {
         this->stop();    
     }
 }
@@ -279,7 +279,8 @@ bool BrainAMP::start()
                                m_iSamplingFreq);
 
     if(m_pBrainAMPProducer->isRunning()) {
-        QThread::start();
+        m_bProcessOutput = true;
+        m_OutputProcessingThread = std::thread(&BrainAMP::run, this);
         return true;
     } else {
         qWarning() << "BrainAMP::start() - BrainAMPProducer thread could not be started." << endl;
@@ -291,8 +292,11 @@ bool BrainAMP::start()
 
 bool BrainAMP::stop()
 {
-    requestInterruption();
-    wait(500);
+    m_bProcessOutput = false;
+
+    if(m_OutputProcessingThread.joinable()){
+        m_OutputProcessingThread.join();
+    }
 
     //Stop the producer thread first
     m_pBrainAMPProducer->stop();
@@ -373,7 +377,7 @@ void BrainAMP::run()
 {
     MatrixXd matData;
 
-    while(!isInterruptionRequested()) {
+    while(m_bProcessOutput) {
         if(m_pBrainAMPProducer->isRunning()) {
             //pop matrix
             if(m_pCircularBuffer->pop(matData)) {

src/applications/mne_scan/plugins/brainflowboard/brainflowboard.cpp

@@ -69,6 +69,7 @@ BrainFlowBoard::BrainFlowBoard()
 , m_sStreamerParams("")
 , m_uiSamplesPerBlock(100)
 , m_pFiffInfo(QSharedPointer<FiffInfo>::create())
+, m_bProcessOutput(false)
 {
     m_pShowSettingsAction = new QAction(QIcon(":/images/options.png"), tr("Streaming Settings"),this);
     m_pShowSettingsAction->setStatusTip(tr("Streaming Settings"));
@@ -244,7 +245,8 @@ bool BrainFlowBoard::start()
         msgBox.exec();
         return false;
     }
-    QThread::start();
+    m_bProcessOutput = true;
+    m_OutputProcessingThread = std::thread(&BrainFlowBoard::run, this);
     return true;
 }
 
@@ -256,8 +258,11 @@ bool BrainFlowBoard::stop()
         if(m_pBoardShim) {
             m_pBoardShim->stop_stream();
         }
-        requestInterruption();
-        wait(500);
+        m_bProcessOutput = false;
+
+        if(m_OutputProcessingThread.joinable()){
+            m_OutputProcessingThread.join();
+        }
         m_pOutput->measurementData()->clear();
     } catch (const BrainFlowException &err) {
         BoardShim::log_message((int)LogLevels::LEVEL_ERROR, err.what());
@@ -388,12 +393,12 @@ void BrainFlowBoard::run()
     BrainFlowArray<double, 2> data;
     QList<Eigen::VectorXd> lSampleBlockBuffer;
 
-    while(!isInterruptionRequested()) {
-        usleep(lSamplingPeriod);
+    while(m_bProcessOutput) {
+        std::this_thread::sleep_for(std::chrono::microseconds(lSamplingPeriod));
         iSampleIterator = 0;
 
         //get samples from device until the complete matrix is filled, i.e. the samples per block size is met
-        while(iSampleIterator < m_uiSamplesPerBlock && !isInterruptionRequested()) {
+        while(iSampleIterator < m_uiSamplesPerBlock && m_bProcessOutput) {
             //Get sample block from device
             data = m_pBoardShim->get_board_data ();
             if (data.get_size(1) == 0) {

src/applications/mne_scan/plugins/brainflowboard/brainflowboard.h

@@ -47,6 +47,10 @@
 
 #include <scShared/Plugins/abstractsensor.h>
 
+#include <thread>
+#include <atomic>
+
+
 //=============================================================================================================
 // QT INCLUDES
 //=============================================================================================================
@@ -128,6 +132,9 @@ class BRAINFLOWBOARD_EXPORT BrainFlowBoard : public SCSHAREDLIB::AbstractSensor
 
     QSharedPointer<SCSHAREDLIB::PluginOutputData<SCMEASLIB::RealTimeMultiSampleArray> > m_pOutput;
     QSharedPointer<FIFFLIB::FiffInfo>   m_pFiffInfo;        /**< Fiff measurement info.*/
+
+    std::thread             m_OutputProcessingThread;
+    std::atomic_bool        m_bProcessOutput;
 };
 }
 

src/applications/mne_scan/plugins/eegosports/eegosports.cpp

@@ -98,6 +98,7 @@ EEGoSports::EEGoSports()
 , m_sRPA("2RD")
 , m_sNasion("0Z")
 , m_pCircularBuffer(QSharedPointer<CircularBuffer_Matrix_double>(new CircularBuffer_Matrix_double(10)))
+, m_bProcessOutput(false)
 {
 }
 
@@ -106,7 +107,7 @@ EEGoSports::EEGoSports()
 EEGoSports::~EEGoSports()
 {
     //If the program is closed while the sampling is in process
-    if(this->isRunning()) {
+    if(m_bProcessOutput) {
         this->stop();    
     }
 }
@@ -564,7 +565,8 @@ bool EEGoSports::start()
                                  m_bCheckImpedances);
 
     if(m_pEEGoSportsProducer->isRunning()) {
-        QThread::start();
+        m_bProcessOutput = true;
+        m_OutputProcessingThread = std::thread(&EEGoSports::run, this);;
         return true;
     } else {
         qWarning() << "[EEGoSports::start] EEGoSports thread could not be started - Either the device is turned off (check your OS device manager) or the driver DLL (EEGO-SDK.dll) is not installed in one of the monitored dll path." << endl;
@@ -577,8 +579,11 @@ bool EEGoSports::start()
 bool EEGoSports::stop()
 {
     // Stop this (consumer) thread first
-    requestInterruption();
-    wait(500);
+    m_bProcessOutput = false;
+
+    if(m_OutputProcessingThread.joinable()){
+        m_OutputProcessingThread.join();
+    }
 
     //Stop the producer thread
     m_pEEGoSportsProducer->stop();
@@ -660,7 +665,7 @@ void EEGoSports::onUpdateCardinalPoints(const QString& sLPA, double dLPA, const
 void EEGoSports::showImpedanceDialog()
 {
     // Open Impedance dialog only if no sampling process is active
-    if(!this->isRunning()) {
+    if(!m_bProcessOutput) {
         if(m_pEEGoSportsImpedanceWidget == NULL) {
             m_pEEGoSportsImpedanceWidget = QSharedPointer<EEGoSportsImpedanceWidget>(new EEGoSportsImpedanceWidget(this));
         }
@@ -700,7 +705,7 @@ void EEGoSports::run()
 {
     MatrixXd matData;
 
-    while(!isInterruptionRequested()) {
+    while(m_bProcessOutput) {
         if(m_pEEGoSportsProducer->isRunning()) {
             // Check impedances - send new impedance values to graphic scene
             if(m_bCheckImpedances) {

src/applications/mne_scan/plugins/eegosports/eegosports.h

@@ -53,6 +53,9 @@
 #include <utils/generics/circularbuffer.h>
 #include <fstream>
 
+#include <thread>
+#include <atomic>
+
 //=============================================================================================================
 // EIGEN INCLUDES
 //=============================================================================================================
@@ -260,6 +263,9 @@ protected slots:
     QSharedPointer<EEGoSportsProducer>  m_pEEGoSportsProducer;              /**< The EEGoSportsProducer.*/
 
     QMutex                              m_mutex;                            /**< Holds the threads mutex.*/
+
+    std::thread             m_OutputProcessingThread;
+    std::atomic_bool        m_bProcessOutput;
 };
 } // NAMESPACE
 

src/applications/mne_scan/plugins/ftbuffer/ftbuffer.cpp

@@ -70,6 +70,7 @@ FtBuffer::FtBuffer()
 , m_pCircularBuffer(QSharedPointer<CircularBuffer_Matrix_double>(new CircularBuffer_Matrix_double(10)))
 , m_sBufferAddress("127.0.0.1")
 , m_iBufferPort(1972)
+, m_bProcessOutput(false)
 {
 }
 
@@ -133,7 +134,8 @@ bool FtBuffer::start()
     qInfo() << "[FtBuffer::start] Producer thread created, sending work command...";
     emit workCommand();
 
-    QThread::start();
+    m_bProcessOutput = true;
+    m_OutputProcessingThread = std::thread(&FtBuffer::run, this);
 
     return true;
 }
@@ -146,14 +148,17 @@ bool FtBuffer::stop()
 
     m_bIsConfigured = false;
 
-    requestInterruption();
-    wait(500);
+    m_bProcessOutput = false;
+
+    if(m_OutputProcessingThread.joinable()){
+        m_OutputProcessingThread.join();
+    }
 
     //stops separate producer/client thread first
     m_pProducerThread.requestInterruption();
     int itries = 0;
     while(m_pProducerThread.isRunning()) {
-        msleep(10);
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
         if(itries > 10){
             break;
         }
@@ -200,12 +205,12 @@ void FtBuffer::run()
 {
     MatrixXd matData;
 
-    while(!isInterruptionRequested()) {
+    while(m_bProcessOutput) {
         //qDebug() << "[FtBuffer::run] m_pFiffInfo->dig.size()" << m_pFiffInfo->dig.size();
         //pop matrix
         if(m_pCircularBuffer->pop(matData)) {
             //emit values
-            if(!isInterruptionRequested()) {
+            if(m_bProcessOutput) {
                 m_pRTMSA_BufferOutput->measurementData()->setValue(matData);
             }
         }

src/applications/mne_scan/plugins/ftbuffer/ftbuffer.h

@@ -55,6 +55,9 @@
 
 #include <utils/generics/circularbuffer.h>
 
+#include <thread>
+#include <atomic>
+
 //=============================================================================================================
 // QT INCLUDES
 //=============================================================================================================
@@ -253,6 +256,9 @@ class FTBUFFER_EXPORT FtBuffer : public SCSHAREDLIB::AbstractSensor
 
     QString                                                                             m_sBufferAddress;               /**< The address used to connect to the buffer if starting without being connected */
     int                                                                                 m_iBufferPort;                  /**< The port used to connect to the buffer if starting without being connected */
+
+    std::thread             m_OutputProcessingThread;
+    std::atomic_bool        m_bProcessOutput;
 };
 }//namespace end brace
 

src/applications/mne_scan/plugins/gusbamp/gusbamp.cpp

@@ -72,6 +72,7 @@ GUSBAmp::GUSBAmp()
 , m_iSamplesPerBlock(0)
 , m_iSampleRate(128)
 , m_pCircularBuffer(QSharedPointer<CircularBuffer_Matrix_float>(new CircularBuffer_Matrix_float(8)))
+, m_bProcessOutput(false)
 {
     m_viChannelsToAcquire = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
 
@@ -86,7 +87,7 @@ GUSBAmp::GUSBAmp()
 GUSBAmp::~GUSBAmp()
 {
     //If the program is closed while the sampling is in process
-    if(this->isRunning()){
+    if(m_bProcessOutput){
         this->stop();
     }
 }
@@ -212,7 +213,8 @@ bool GUSBAmp::start()
 
     //start the thread for ring buffer
     if(m_pGUSBAmpProducer->isRunning())  {
-        QThread::start();
+        m_bProcessOutput = true;
+        m_OutputProcessingThread = std::thread(&GUSBAmp::run, this);
         return true;
     } else  {
         qWarning() << "Plugin GUSBAmp - ERROR - GUSBAmpProducer thread could not be started - Either the device is turned off (check your OS device manager) or the driver DLL (GUSBAmpSDK.dll / GUSBAmpSDK32bit.dll) is not installed in the system32 / SysWOW64 directory" << endl;
@@ -225,8 +227,11 @@ bool GUSBAmp::start()
 bool GUSBAmp::stop()
 {
     // Stop this (consumer) thread first
-    requestInterruption();
-    wait(500);
+    m_bProcessOutput = false;
+
+    if(m_OutputProcessingThread.joinable()){
+        m_OutputProcessingThread.join();
+    }
 
     //Stop the producer thread first
     m_pGUSBAmpProducer->stop();
@@ -271,7 +276,7 @@ void GUSBAmp::run()
     qint32 size = 0;
     MatrixXf matValue;
 
-    while(!isInterruptionRequested()) {
+    while(m_bProcessOutput) {
         //pop matrix only if the producer thread is running
         if(m_pGUSBAmpProducer->isRunning()) {
             //pop matrix

src/applications/mne_scan/plugins/gusbamp/gusbamp.h

@@ -50,6 +50,9 @@
 #include "FormFiles/gusbampsetupwidget.h"
 #include "FormFiles/gusbampsetupprojectwidget.h"
 
+#include <thread>
+#include <atomic>
+
 //=============================================================================================================
 // QT INCLUDES
 //=============================================================================================================
@@ -211,6 +214,9 @@ class GUSBAMPSHARED_EXPORT GUSBAmp : public SCSHAREDLIB::AbstractSensor
     std::vector<int>            m_viSizeOfSampleMatrix;     /**< vector including the size of the two dimensional sample Matrix. */
     std::vector<int>            m_viChannelsToAcquire;      /**< vector of the calling numbers of the channels to be acquired. */
     Eigen::RowVectorXd          m_cals;
+
+    std::thread             m_OutputProcessingThread;
+    std::atomic_bool        m_bProcessOutput;
 };
 } // NAMESPACE
 

src/applications/mne_scan/plugins/natus/natus.cpp

@@ -75,6 +75,7 @@ Natus::Natus()
 , m_qStringResourcePath(qApp->applicationDirPath()+"/../resources/mne_scan/plugins/natus/")
 , m_pRMTSA_Natus(PluginOutputData<RealTimeMultiSampleArray>::create(this, "Natus", "EEG output data"))
 , m_pFiffInfo(QSharedPointer<FiffInfo>::create())
+, m_bProcessOutput(false)
 {
     m_pRMTSA_Natus->measurementData()->setName(this->getName());//Provide name to auto store widget settings
 }
@@ -84,7 +85,7 @@ Natus::Natus()
 Natus::~Natus()
 {
     //If the program is closed while the sampling is in process
-    if(this->isRunning()) {
+    if(m_bProcessOutput) {
         this->stop();
     }
 }
@@ -229,7 +230,8 @@ bool Natus::start()
     m_pRMTSA_Natus->measurementData()->initFromFiffInfo(m_pFiffInfo);
     m_pRMTSA_Natus->measurementData()->setMultiArraySize(1);
 
-    QThread::start();
+    m_bProcessOutput = true;
+    m_OutputProcessingThread = std::thread(&Natus::run, this);
 
     // Start the producer
     m_pNatusProducer = QSharedPointer<NatusProducer>::create(m_iSamplesPerBlock, m_iNumberChannels);
@@ -245,8 +247,11 @@ bool Natus::start()
 
 bool Natus::stop()
 {
-    requestInterruption();
-    wait(500);
+    m_bProcessOutput = false;
+
+    if(m_OutputProcessingThread.joinable()){
+        m_OutputProcessingThread.join();
+    }
 
     // Clear all data in the buffer connected to displays and other plugins
     m_pRMTSA_Natus->measurementData()->clear();
@@ -299,10 +304,10 @@ void Natus::run()
 {
     MatrixXd matData;
 
-    while(!isInterruptionRequested()) {
+    while(m_bProcessOutput) {
         if(m_pCircularBuffer->pop(matData)) {
             //emit values
-            if(!isInterruptionRequested()) {
+            if(m_bProcessOutput) {
                 m_pRMTSA_Natus->measurementData()->setValue(matData);
             }
         }