135 lines
3.3 KiB
C++
135 lines
3.3 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();
|
|
|
|
int hwVersion = _canDriver.getValue( BCDevice::ID::Console, BC::ID::Cons_Rev_Hw);
|
|
|
|
if (hwVersion == 0)
|
|
{
|
|
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!
|
|
|
|
std::optional<bcdata_t> result;
|
|
|
|
/*
|
|
if( opID == BC::OpID::ReadValue )
|
|
result = executeRead(currentValue);
|
|
else if( opID == BC::OpID::WriteValue )
|
|
result = executeRead(currentValue);
|
|
*/
|
|
//emit commandFinished(cmd.id, true);
|
|
//emit commandFinished(0, true);
|
|
}
|
|
}
|
|
|
|
std::optional<bcdata_t> BCTransmitter::executeRead(const BCValue& value)
|
|
{
|
|
|
|
return 0;
|
|
|
|
std::optional<uint32_t> result;
|
|
switch( value.deviceID )
|
|
{
|
|
// hier lacht der blaue riesenhase!
|
|
case BCDevice::ID::Invalid:
|
|
case BCDevice::ID::Console:
|
|
case BCDevice::ID::Console_Master:
|
|
case BCDevice::ID::Battery:
|
|
case BCDevice::ID::Motor:
|
|
case BCDevice::ID::BIB:
|
|
case BCDevice::ID::Sensor:
|
|
break;
|
|
};
|
|
}
|
|
|
|
|
|
std::optional<bcdata_t> BCTransmitter::executeWrite(const BCValue& value)
|
|
{
|
|
|
|
}
|