chris/BionxControl
Public Access
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanups.

Browse Source
This commit is contained in:
PANIK\chris
2026-01-02 16:25:21 +01:00
parent acbd80c446
commit 26d7f726d4
109 changed files with 565 additions and 6171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
bctransmitter.cpp
View File

@@ -30,6 +30,7 @@
***************************************************************************/
#include "bcvaluetype.h"
#include <QThread>
#include <QDebug>
@@ -51,7 +52,7 @@ void BCTransmitter::onToggleConnectionState( bool connect )
_canDriver->onStartDriver();
// __fix!
BCDriver::TransmitResult hwVersion = _canDriver->readRawByte( (uint32_t)BCDevice::ID::Console, (uint8_t)BC::ID::Cons_Rev_Hw);
TransmitResult hwVersion = _canDriver->readRawByte( (uint32_t)BCDevice::ID::Console, (uint8_t)BC::ID::Cons_Rev_Hw);
if(!hwVersion)
{
qDebug() << "Console not responding";
@@ -67,7 +68,7 @@ void BCTransmitter::onToggleConnectionState( bool connect )
}
void BCTransmitter::enqueueValueOp( const BCValuePtr value)
void BCTransmitter::enqueueValue( BCValuePtrConst value)
{
// Hier sind wir noch in GUI Thread
QMutexLocker locker(&_mutex);
@@ -79,16 +80,16 @@ void BCTransmitter::enqueueValueOp( const BCValuePtr value)
// 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).
// damit enqueueValue sofort zurückkehrt (non-blocking für den Aufrufer).
//QMetaObject::invokeMethod(this, "processValueOp", Qt::QueuedConnection);
//QMetaObject::invokeMethod(this, "processValue", Qt::QueuedConnection);
QMetaObject::invokeMethod(this, [this]()
{
processValueOp();
processValue();
}, Qt::QueuedConnection );
}
void BCTransmitter::processValueOp()
void BCTransmitter::processValue()
{
if (_isBusy)
@@ -98,7 +99,7 @@ void BCTransmitter::processValueOp()
while (true)
{
BCValuePtr value{};
BCValuePtrConst valuePtr{};
{
QMutexLocker locker(&_mutex);
if (_valueQueue.isEmpty())
@@ -106,27 +107,39 @@ void BCTransmitter::processValueOp()
_isBusy = false;
break; // Schleife verlassen, warten auf neue Events
}
value =_valueQueue.dequeue();
valuePtr =_valueQueue.dequeue();
} // Mutex wird hier freigegeben! WICHTIG: Execute ohne Lock!
// Kosmetik
const BCValue& value = *(valuePtr.get());
// Abkürzung
//const BCValue& value = *currentValue;
// Value ist 'under construction'
//emit valueUpdated( val.deviceID, val.indexRow, BCValue::State::Locked );
/*
if( opID == BCValue::OpID::ReadValue )
const BCValueType& valueType = *value.valueType;
uint32_t devID = static_cast<uint32_t>(value.deviceID);
uint8_t regID = static_cast<uint8_t> (value.registerID);
QString newVisibleValue;
if(value.state.testFlag( BCValue::State::WriteMe ) )
{
QString result = currentValue->readRawValueX( *this );
emit valueUpdated( valuel.deviceID, value.indexRow, BCValue::State::InSync, result );
}
else if( opID == BCValue::OpID::WriteValue )
// oder sollen wir hier beides erlauben ? readFlag & writeFlag ?
// Was kommt dann zuerst? Schreiben und lesen als verify ?
else if( value.state.testFlag( BCValue::State::ReadMe ) )
{
currentValue->writeRawValueX( *this );
// wir sind hier im anderen thread! nicht einfach so reinschreiben, nur lesen
TransmitResult result = valueType.readValueFunc( *this, devID, regID );
if( result.has_value() )
newVisibleValue = valueType.formatValue( result.value() );
//emit valueUpdated( value.deviceID, value.indexRow, BCValue::State::InSync, result );
}
*/
emit valueUpdated( value->deviceID, value->indexRow, BCValue::State::InSync, "fitze!");
// emit valueUpdated( value->deviceID, value->indexRow, BCValue::State::InSync, "fitze!");
// __fix
bc::processEventsFor(50);
@@ -136,17 +149,29 @@ void BCTransmitter::processValueOp()
}
}
uint8_t BCTransmitter::readByte( uint32_t deviceID, uint8_t registerID ) const
/**
* @brief BCTransmitter::readByte
* NEIN NEIN NEIN!
* Reicht den read request an den aktuellen Treiber weiter. Wird von aussen, von der readValueFunc des ValueTypes
* aufgerufen, deshalb public.
*/
TransmitResult BCTransmitter::readByte( uint32_t deviceID, uint8_t registerID ) const
{
BCDriver::TransmitResult result = _canDriver->readRawByte( deviceID, registerID );
return result.value();
return _canDriver->readRawByte( deviceID, registerID );
}
void BCTransmitter::writeByte( uint32_t deviceID, uint8_t registerID , uint8_t value ) const
/**
* @brief BCTransmitter::writeByte
* Reicht den write request an den aktuellen Treiber weiter. Wird von aussen, von der writeValueFunc des ValueTypes
* aufgerufen, deshalb public.
*/
TransmitResult BCTransmitter::writeByte( uint32_t deviceID, uint8_t registerID , uint8_t value ) const
{
_canDriver->writeRawByte( deviceID, registerID, value );
return _canDriver->writeRawByte( deviceID, registerID, value );
}