Fixed thread sync

bcmainwindow.cpp

@@ -134,7 +134,8 @@ void BCMainWindow::initMainWindow()
   connect( this, &BCMainWindow::requestValueUpdate, &_transmitter, &BCTransmitter::onUpdateValue);
   connect( &_worker, &QThread::finished, &_transmitter, &QObject::deleteLater);
   connect( &_transmitter, &BCTransmitter::driverStateChanged, this, &BCMainWindow::onDriverStateChanged );
-  connect( &_transmitter, &BCTransmitter::valueQueueEmpty,    this, &BCMainWindow::onValueQueueEmpty );
+  connect( &_transmitter, &BCTransmitter::endOfProcessing,    this, &BCMainWindow::onEndOfProcessing );
+  connect( this,          &BCMainWindow::endOfTransmission, &_transmitter, &BCTransmitter::onEndOfTransmission );
 
   // transmitter starten
   _transmitter.moveToThread(&_worker);
@@ -307,7 +308,7 @@ void BCMainWindow::onValueUpdated(BCDevice::ID deviceID, int index, BCValue::Fla
   }
 }
 
-void BCMainWindow::onValueQueueEmpty()
+void BCMainWindow::onEndOfProcessing()
 {
   qDebug() << " --- END sync";
   _syncButton->setEnabled( true );
@@ -342,6 +343,8 @@ void BCMainWindow::onSyncDeviceView()
     emit requestValueUpdate( value);
 
   }
+  qDebug() << " --- sending FORWARD EOT";
+  emit endOfTransmission();
 
 
 

bcmainwindow.h

@@ -62,7 +62,7 @@ public slots:
 
   // Slots für Rückmeldungen vom Transmitter
   void onValueUpdated( BCDevice::ID deviceID, int index, BCValue::Flag state, uint32_t rawValue );
-  void onValueQueueEmpty();
+  void onEndOfProcessing();
   void onSyncDeviceView();
 
   void onShowMessage( const QString& message, int timeOut=3000);
@@ -71,6 +71,7 @@ signals:
 
   // Internes Signal, um Daten an den Worker Thread zu senden
   void requestValueUpdate( BCValuePtrConst value);
+  void endOfTransmission();
 
 protected:
 

bctransmitter.cpp

@@ -143,30 +143,13 @@ void BCTransmitter::onUpdateValue( BCValuePtrConst valuePtr)
   // Wir benutzen doch eine zusätzliche Queue, um erkennen zu können, ob der
   // der aktuelle Auftragsblock  abgearbeit wurde.
 
-  _valueQueue.enqueue( valuePtr );
+  //_valueQueue.enqueue( valuePtr );
   //qDebug() << " # #### ENQ: " <<_valueQueue.size();
 
   // Wir schicken den event gleich wieder weiter ...
-  QMetaObject::invokeMethod(this, "onProcessValue", Qt::QueuedConnection);
+  //QMetaObject::invokeMethod(this, "onProcessValue", Qt::QueuedConnection);
-}
+
 
-void BCTransmitter::onProcessValue()
-{
-  while (true)
-  {
-    BCValuePtrConst valuePtr{};
-    {
-      //QMutexLocker locker(&_mutex);
-      if (_valueQueue.isEmpty())
-      {
-        //_isBusy = false;
-        //qDebug() << " --- XXXXXXXXXX Warum so oft?";
-        emit valueQueueEmpty();
-        break; // Schleife verlassen, warten auf neue Events
-      }
-      valuePtr =_valueQueue.dequeue();
-      //qDebug() << " # #### DEQ: " <<_valueQueue.size();
-    } // Mutex wird hier freigegeben! WICHTIG: Execute ohne Lock!
 
   // Kosmetik
   const BCValue& value = *(valuePtr.get());
@@ -189,7 +172,6 @@ void BCTransmitter::onProcessValue()
   if(value.valueFlags.testFlag( BCValue::Flag::WriteMe ) )
   {
 
-
   }
   // oder sollen wir hier beides erlauben ? readFlag & writeFlag ?
   // Was kommt dann zuerst? Schreiben und lesen als verify ?
@@ -209,11 +191,21 @@ void BCTransmitter::onProcessValue()
 
   // __fix
   //bc::processEventsFor(150);
-  bc::delay_millis(150);
+  bc::delay_millis(250);
-  } // while
 
 }
 
+/**
+ * @brief Wenn dieser SLOT in der Event-Queue erreicht wird, dedeutet dies, das die
+ * Übertrgung vom Mainwindow abgeschlossen wurde. Wir schicken zur Bestätigung das
+ * Signal 'endOfProcessing' (Welches dann den 'Sync' - Button wieder einschaltet.
+ */
+
+void BCTransmitter::onEndOfTransmission()
+{
+  qDebug() << " --- sending BACK EOT";
+  emit endOfProcessing();
+}
 
 
 TransmitResult BCTransmitter::readByteValue( uint32_t deviceID, uint8_t registerID )

bctransmitter.h

@@ -36,7 +36,6 @@
 #include <QObject>
 #include <QQueue>
 #include <QMutex>
-#include <atomic>
 
 #include <bcvalue.h>
 #include <bcdrivertinycan.h>
@@ -66,10 +65,11 @@ public slots:
   void onUpdateValue(BCValuePtrConst valuePtr );
   void onProcessValue();
   void onStartNativeDriver();
+  void onEndOfTransmission();
 
 signals:
 
-  void valueQueueEmpty();
+  void endOfProcessing();
   void valueUpdated(BCDevice::ID deviceID, int index, BCValue::Flag state, uint32_t rawValue );
   void driverStateChanged( BCDriver::DriverState state, const QString& message="" );
 
@@ -81,8 +81,8 @@ private:
   TransmitResult readByteValue( uint32_t deviceID, uint8_t registerID );
   TransmitResult readWordValue( uint32_t deviceID, uint8_t registerID );
 
-  using BCDataQueue = QQueue<BCValuePtrConst>;
+  //using BCDataQueue = QQueue<BCValuePtrConst>;
-  BCDataQueue       _valueQueue;
+  //BCDataQueue       _valueQueue;
   //QMutex            _mutex;
   //std::atomic<bool> _isBusy{ false };