122 lines
3.1 KiB
C++
122 lines
3.1 KiB
C++
#include <QThread>
|
|
#include <QDebug>
|
|
|
|
#include <bctransmitter.h>
|
|
|
|
|
|
BCTransmitter::BCTransmitter(QObject *parent)
|
|
: QObject(parent), _isBusy(false)
|
|
{
|
|
}
|
|
|
|
|
|
void BCTransmitter::onToggleConnectionState( bool connect )
|
|
{
|
|
if( connect )
|
|
{
|
|
if( BCCanDriver::sIdle == _canDriver.getState() )
|
|
_canDriver.onStartDriver();
|
|
|
|
std::optional<bcdata_t> hwVersion = _canDriver.readRawValue( BCDevice::ID::Console, BC::ID::Cons_Rev_Hw);
|
|
|
|
if(!hwVersion.has_value())
|
|
{
|
|
qDebug() << "Console not responding";
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
swVersion = getValue(CONSOLE, CONSOLE_REF_SW);
|
|
printf( "Console information:" _NL
|
|
" hardware version ........: %02d" _NL
|
|
" software version ........: %02d" _NL
|
|
" assistance level ........: %d" _NL,
|
|
hwVersion, swVersion,
|
|
getValue(CONSOLE, CONSOLE_ASSIST_INITLEVEL)
|
|
);
|
|
|
|
if (!gNoSerialNumbers)
|
|
printf( " part number .............: %05d" _NL
|
|
" item number .............: %05d" _NL _NL,
|
|
((getValue(CONSOLE, CONSOLE_SN_PN_HI) << 8) + getValue(CONSOLE, CONSOLE_SN_PN_LO)),
|
|
((getValue(CONSOLE, CONSOLE_SN_ITEM_HI) << 8) + getValue(CONSOLE, CONSOLE_SN_ITEM_LO))
|
|
);
|
|
*/
|
|
|
|
}
|
|
|
|
qDebug() << " ---HAIL to the kings: " << hwVersion;
|
|
}
|
|
}
|
|
|
|
|
|
void BCTransmitter::enqueueValueOp(BC::OpID opID, const BCValue* value)
|
|
{
|
|
QMutexLocker locker(&_mutex);
|
|
_valueQueue.enqueue( value );
|
|
|
|
// Logging (Thread-safe via Signal)
|
|
//emit messageLogged(QString("Command %1 queued.").arg(cmd.label));
|
|
|
|
// wir wollen nicht den ganzen Value verschicken, erstrecht
|
|
// wollen wir den Value in verschiedenen Threads gleichzeitig
|
|
// in die Hand nehmen, also hantieren wir nur mit den Inidizes.
|
|
|
|
// Trigger processing im Event-Loop des Worker Threads
|
|
// invokeMethod mit QueuedConnection entkoppelt den Aufruf,
|
|
// damit enqueueValueOp sofort zurückkehrt (non-blocking für den Aufrufer).
|
|
|
|
//QMetaObject::invokeMethod(this, "processValueOp", Qt::QueuedConnection);
|
|
QMetaObject::invokeMethod(this, [this, opID]()
|
|
{
|
|
this->processValueOp(opID);
|
|
}, Qt::QueuedConnection );
|
|
}
|
|
|
|
void BCTransmitter::processValueOp( BC::OpID opID )
|
|
{
|
|
|
|
if (_isBusy)
|
|
return;
|
|
|
|
_isBusy = true;
|
|
|
|
while (true)
|
|
{
|
|
const BCValue* currentValue{};
|
|
{
|
|
QMutexLocker locker(&_mutex);
|
|
if (_valueQueue.isEmpty())
|
|
{
|
|
_isBusy = false;
|
|
break; // Schleife verlassen, warten auf neue Events
|
|
}
|
|
currentValue =_valueQueue.dequeue();
|
|
} // Mutex wird hier freigegeben! WICHTIG: Execute ohne Lock!
|
|
|
|
|
|
if( opID == BC::OpID::ReadValue )
|
|
currentValue->readRawValue( *this );
|
|
else if( opID == BC::OpID::WriteValue )
|
|
currentValue->writeRawValue( *this );
|
|
|
|
|
|
//emit commandFinished(cmd.id, true);
|
|
//emit commandFinished(0, true);
|
|
}
|
|
}
|
|
|
|
std::optional<bcdata_t> BCTransmitter::readRawValue( BCDevice::ID deviceID, BC::ID registerID ) const
|
|
{
|
|
return _canDriver.readRawValue( deviceID, registerID );
|
|
}
|
|
|
|
void BCTransmitter::writeRawValue( BCDevice::ID deviceID, BC::ID registerID, bcdata_t value ) const
|
|
{
|
|
_canDriver.writeRawValue( deviceID, registerID, value );
|
|
}
|
|
|
|
|
|
|
|
|