153 lines
3.8 KiB
C++
153 lines
3.8 KiB
C++
/***************************************************************************
|
|
|
|
BionxControl
|
|
Copyright © 2025 christoph holzheuer
|
|
christoph.holzheuer@gmail.com
|
|
|
|
Using:
|
|
|
|
mhs_can_drv.c
|
|
© 2011 - 2023 by MHS-Elektronik GmbH & Co. KG, Germany
|
|
Klaus Demlehner, klaus@mhs-elektronik.de
|
|
@see www.mhs-elektronik.de
|
|
|
|
Based on Bionx data type descriptions from:
|
|
|
|
BigXionFlasher USB V 0.2.4 rev. 97
|
|
© 2011-2013 by Thomas Koenig <info@bigxionflasher.org>
|
|
@see www.bigxionflasher.org
|
|
|
|
Bionx Bike Info
|
|
© 2018 Thorsten Schmidt (tschmidt@ts-soft.de)
|
|
@see www.ts-soft.de
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
@see https://github.com/bikemike/bionx-bikeinfo
|
|
|
|
***************************************************************************/
|
|
|
|
|
|
#include <QThread>
|
|
#include <QDebug>
|
|
|
|
#include <bctransmitter.h>
|
|
|
|
BCTransmitter::BCTransmitter(QObject *parent)
|
|
: QObject(parent), _isBusy(false)
|
|
{
|
|
_canDriver = new BCDriverTinyCan{this};
|
|
//_canDriver = new BCDriverDummy{this};
|
|
}
|
|
|
|
|
|
void BCTransmitter::onToggleConnectionState( bool connect )
|
|
{
|
|
if( connect )
|
|
{
|
|
if( _canDriver->getDriverState() != BCDriver::DriverState::DeviceReady )
|
|
_canDriver->onStartDriver();
|
|
|
|
// __fix!
|
|
BCDriver::TransmitResult hwVersion = _canDriver->readRawByte( (uint32_t)BCDevice::ID::Console, (uint8_t)BC::ID::Cons_Rev_Hw);
|
|
if(!hwVersion)
|
|
{
|
|
qDebug() << "Console not responding";
|
|
}
|
|
else
|
|
{
|
|
|
|
|
|
}
|
|
|
|
qDebug() << " ---HAIL to the kings: " << hwVersion.value();
|
|
}
|
|
}
|
|
|
|
|
|
void BCTransmitter::enqueueValueOp( const BCValue& value)
|
|
{
|
|
// Hier sind wir noch in GUI Thread
|
|
QMutexLocker locker(&_mutex);
|
|
_valueQueue.enqueue( value );
|
|
|
|
// wir wollen nicht den ganzen Value verschicken, erstrecht
|
|
// wollen wir nicht 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]()
|
|
{
|
|
processValueOp();
|
|
}, Qt::QueuedConnection );
|
|
}
|
|
|
|
void BCTransmitter::processValueOp()
|
|
{
|
|
|
|
if (_isBusy)
|
|
return;
|
|
|
|
_isBusy = true;
|
|
|
|
while (true)
|
|
{
|
|
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!
|
|
|
|
/*
|
|
// Abkürzung
|
|
const BCValue& value = *currentValue;
|
|
// Value ist 'under construction'
|
|
//emit valueUpdated( val.deviceID, val.indexRow, BCValue::State::Locked );
|
|
|
|
if( opID == BCValue::OpID::ReadValue )
|
|
{
|
|
QString result = currentValue->readRawValueX( *this );
|
|
emit valueUpdated( valuel.deviceID, value.indexRow, BCValue::State::InSync, result );
|
|
}
|
|
else if( opID == BCValue::OpID::WriteValue )
|
|
{
|
|
currentValue->writeRawValueX( *this );
|
|
}
|
|
*/
|
|
|
|
// __fix
|
|
bc::processEventsFor(50);
|
|
|
|
//emit valueStateChanged(cmd.id, true);
|
|
//emit valueStateChanged(0, true);
|
|
}
|
|
}
|
|
|
|
uint8_t BCTransmitter::readByte( uint32_t deviceID, uint8_t registerID ) const
|
|
{
|
|
BCDriver::TransmitResult result = _canDriver->readRawByte( deviceID, registerID );
|
|
|
|
return result.value();
|
|
|
|
}
|
|
|
|
void BCTransmitter::writeByte( uint32_t deviceID, uint8_t registerID , uint8_t value ) const
|
|
{
|
|
_canDriver->writeRawByte( deviceID, registerID, value );
|
|
}
|
|
|
|
|
|
|
|
|