138 lines
3.4 KiB
C++
138 lines
3.4 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( _canDriver.getState() != BCCanDriver::DriverState::Ready )
|
|
_canDriver.onStartDriver();
|
|
|
|
uint32_t hwVersion = _canDriver.readRawValue( BCDevice::ID::Console, BC::ID::Cons_Rev_Hw);
|
|
|
|
if(!hwVersion)
|
|
{
|
|
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 BCDataItem* 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 BCDataItem* 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->readRawValueX( *this );
|
|
else if( opID == BC::OpID::WriteValue )
|
|
currentValue->writeRawValueX( *this );
|
|
|
|
|
|
//emit commandFinished(cmd.id, true);
|
|
//emit commandFinished(0, true);
|
|
}
|
|
}
|
|
|
|
uint32_t BCTransmitter::readRawValue( BCDevice::ID deviceID, BC::ID registerID ) const
|
|
{
|
|
try
|
|
{
|
|
return _canDriver.readRawValue( deviceID, registerID );
|
|
}
|
|
catch ( BCException& exception )
|
|
{
|
|
qDebug() << " -- OUCH: read exception: " << exception.what();
|
|
}
|
|
|
|
}
|
|
|
|
void BCTransmitter::writeRawValue( BCDevice::ID deviceID, BC::ID registerID, uint8_t value ) const
|
|
{
|
|
try
|
|
{
|
|
_canDriver.writeRawValue( deviceID, registerID, value );
|
|
}
|
|
catch ( BCException& exception )
|
|
{
|
|
qDebug() << " -- OUCH: write exception: " << exception.what();
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|