|
| 1 | +#include "xcxbike.h" |
| 2 | + |
| 3 | +#ifdef Q_OS_ANDROID |
| 4 | +#include "keepawakehelper.h" |
| 5 | +#endif |
| 6 | +#include "qzsettings.h" |
| 7 | +#include "virtualdevices/virtualbike.h" |
| 8 | + |
| 9 | +#include <QDebug> |
| 10 | +#include <QSettings> |
| 11 | + |
| 12 | +#include <chrono> |
| 13 | +#include <cmath> |
| 14 | + |
| 15 | +using namespace std::chrono_literals; |
| 16 | + |
| 17 | +#ifdef Q_OS_IOS |
| 18 | +extern quint8 QZ_EnableDiscoveryCharsAndDescripttors; |
| 19 | +#endif |
| 20 | + |
| 21 | +namespace { |
| 22 | +const QBluetoothUuid fff0Uuid(QStringLiteral("0000fff0-0000-1000-8000-00805f9b34fb")); |
| 23 | +const QBluetoothUuid fff5Uuid(QStringLiteral("0000fff5-0000-1000-8000-00805f9b34fb")); |
| 24 | +const QBluetoothUuid fff6Uuid(QStringLiteral("0000fff6-0000-1000-8000-00805f9b34fb")); |
| 25 | + |
| 26 | +quint8 byteAt(const QByteArray &packet, int offset) { return static_cast<quint8>(packet.at(offset)); } |
| 27 | + |
| 28 | +quint16 le16(const QByteArray &packet, int offset) { |
| 29 | + return static_cast<quint16>(byteAt(packet, offset)) | (static_cast<quint16>(byteAt(packet, offset + 1)) << 8); |
| 30 | +} |
| 31 | + |
| 32 | +quint32 le24(const QByteArray &packet, int offset) { |
| 33 | + return static_cast<quint32>(byteAt(packet, offset)) | (static_cast<quint32>(byteAt(packet, offset + 1)) << 8) | |
| 34 | + (static_cast<quint32>(byteAt(packet, offset + 2)) << 16); |
| 35 | +} |
| 36 | +} // namespace |
| 37 | + |
| 38 | +xcxbike::xcxbike(bool noWriteResistance, bool noHeartService, int8_t bikeResistanceOffset, double bikeResistanceGain) |
| 39 | + : noWriteResistance(noWriteResistance), noHeartService(noHeartService), bikeResistanceOffset(bikeResistanceOffset), |
| 40 | + bikeResistanceGain(bikeResistanceGain) { |
| 41 | +#ifdef Q_OS_IOS |
| 42 | + QZ_EnableDiscoveryCharsAndDescripttors = true; |
| 43 | +#endif |
| 44 | + m_watt.setType(metric::METRIC_WATT, deviceType()); |
| 45 | + Speed.setType(metric::METRIC_SPEED); |
| 46 | + connect(&refresh, &QTimer::timeout, this, &xcxbike::update); |
| 47 | + refresh.start(300ms); |
| 48 | +} |
| 49 | + |
| 50 | +bool xcxbike::parseTelemetry(const QByteArray &packet, XcxTelemetry *telemetry) { |
| 51 | + // Captures contain the original 20-byte telemetry frame, while the physical bike has also |
| 52 | + // been observed appending a three-byte trailer. The trailer's semantics are not known, so only |
| 53 | + // the proven first 20 bytes are decoded for both variants. |
| 54 | + if (!telemetry || (packet.size() != 20 && packet.size() != 23) || byteAt(packet, 0) != 0xfa || |
| 55 | + byteAt(packet, 1) != 0x05) |
| 56 | + return false; |
| 57 | + |
| 58 | + telemetry->state1 = byteAt(packet, 2); |
| 59 | + telemetry->state2 = byteAt(packet, 3); |
| 60 | + telemetry->timer = le16(packet, 4); |
| 61 | + telemetry->speedKph = le16(packet, 6) / 10.0; |
| 62 | + telemetry->distanceRaw = le24(packet, 8); |
| 63 | + telemetry->energy = le16(packet, 11); |
| 64 | + telemetry->cadence = le16(packet, 13); |
| 65 | + telemetry->unknown15 = le16(packet, 15); |
| 66 | + // The capture only proves that byte 17 contains power up to 255 W. A new capture is required |
| 67 | + // before treating any other byte as a high byte for larger power values. |
| 68 | + telemetry->power = byteAt(packet, 17); |
| 69 | + telemetry->resistance = le16(packet, 18); |
| 70 | + return true; |
| 71 | +} |
| 72 | + |
| 73 | +void xcxbike::update() { |
| 74 | + if (m_control && m_control->state() == QLowEnergyController::UnconnectedState) |
| 75 | + emit disconnected(); |
| 76 | + if (notificationEnabled) |
| 77 | + update_metrics(false, watts()); |
| 78 | + |
| 79 | + // This protocol is telemetry-only: no FFF5 command format was present in the capture. |
| 80 | + requestResistance = -1; |
| 81 | + if (requestStart != -1) { |
| 82 | + requestStart = -1; |
| 83 | + emit bikeStarted(); |
| 84 | + } |
| 85 | + requestStop = -1; |
| 86 | +} |
| 87 | + |
| 88 | +void xcxbike::characteristicChanged(const QLowEnergyCharacteristic &characteristic, const QByteArray &value) { |
| 89 | + if (characteristic.uuid() != fff6Uuid) |
| 90 | + return; |
| 91 | + |
| 92 | + XcxTelemetry telemetry; |
| 93 | + if (!parseTelemetry(value, &telemetry)) { |
| 94 | + qDebug() << QStringLiteral("XCX unexpected FFF6 packet") << value.size() << value.toHex(' '); |
| 95 | + return; |
| 96 | + } |
| 97 | + |
| 98 | + qDebug() << QStringLiteral("XCX << raw:") << value.toHex(' ') << QStringLiteral("state1:") << telemetry.state1 |
| 99 | + << QStringLiteral("state2:") << telemetry.state2 << QStringLiteral("timer:") << telemetry.timer |
| 100 | + << QStringLiteral("speed:") << telemetry.speedKph << QStringLiteral("distanceRaw:") |
| 101 | + << telemetry.distanceRaw << QStringLiteral("energy:") << telemetry.energy << QStringLiteral("cadence:") |
| 102 | + << telemetry.cadence << QStringLiteral("unknown15:") << telemetry.unknown15 << QStringLiteral("power:") |
| 103 | + << telemetry.power << QStringLiteral("resistance:") << telemetry.resistance; |
| 104 | + |
| 105 | + if (!receivedState || telemetry.state1 != lastState1 || telemetry.state2 != lastState2) { |
| 106 | + qDebug() << QStringLiteral("XCX state changed") << lastState1 << lastState2 << QStringLiteral("->") |
| 107 | + << telemetry.state1 << telemetry.state2; |
| 108 | + lastState1 = telemetry.state1; |
| 109 | + lastState2 = telemetry.state2; |
| 110 | + receivedState = true; |
| 111 | + } |
| 112 | + |
| 113 | + const QDateTime now = QDateTime::currentDateTime(); |
| 114 | + const qint64 elapsedMs = lastTelemetryTime.isValid() ? lastTelemetryTime.msecsTo(now) : 0; |
| 115 | + Speed = telemetry.speedKph; |
| 116 | + Cadence = telemetry.cadence; |
| 117 | + m_watt = telemetry.power; |
| 118 | + Resistance = telemetry.resistance; |
| 119 | + KCal = telemetry.energy; |
| 120 | + // The proprietary counter advances plausibly in 0.1 km units. It must not be interpreted as |
| 121 | + // metres like the device's broken FTMS mirror does. |
| 122 | + Distance = telemetry.distanceRaw / 10.0; |
| 123 | + |
| 124 | + if (elapsedMs > 0 && elapsedMs < 10000 && telemetry.cadence > 0) { |
| 125 | + partialCrankRevolution += telemetry.cadence * (elapsedMs / 60000.0); |
| 126 | + const quint32 completedRevolutions = static_cast<quint32>(std::floor(partialCrankRevolution)); |
| 127 | + if (completedRevolutions) { |
| 128 | + CrankRevs += completedRevolutions; |
| 129 | + LastCrankEventTime += static_cast<quint16>(completedRevolutions * 1024.0 * 60.0 / telemetry.cadence); |
| 130 | + partialCrankRevolution -= completedRevolutions; |
| 131 | + } |
| 132 | + } |
| 133 | + lastTelemetryTime = now; |
| 134 | + |
| 135 | +#ifdef Q_OS_ANDROID |
| 136 | + QSettings settings; |
| 137 | + if (settings.value(QZSettings::ant_heart, QZSettings::default_ant_heart).toBool()) |
| 138 | + Heart = static_cast<uint8_t>(KeepAwakeHelper::heart()); |
| 139 | + else |
| 140 | +#endif |
| 141 | + update_hr_from_external(); |
| 142 | +} |
| 143 | + |
| 144 | +void xcxbike::serviceStateChanged(QLowEnergyService::ServiceState state) { |
| 145 | + qDebug() << QStringLiteral("XCX FFF0 service state") << state; |
| 146 | + if (state != QLowEnergyService::ServiceDiscovered) |
| 147 | + return; |
| 148 | + |
| 149 | + fff5WriteCharacteristic = fff0Service->characteristic(fff5Uuid); |
| 150 | + fff6NotifyCharacteristic = fff0Service->characteristic(fff6Uuid); |
| 151 | + if (!fff6NotifyCharacteristic.isValid()) { |
| 152 | + qDebug() << QStringLiteral("XCX FFF6 notification characteristic not found"); |
| 153 | + return; |
| 154 | + } |
| 155 | + qDebug() << QStringLiteral("XCX FFF5 present for future protocol research:") << fff5WriteCharacteristic.isValid(); |
| 156 | + connect(fff0Service, &QLowEnergyService::characteristicChanged, this, &xcxbike::characteristicChanged); |
| 157 | + connect(fff0Service, &QLowEnergyService::descriptorWritten, this, &xcxbike::descriptorWritten); |
| 158 | + createVirtualBike(); |
| 159 | + |
| 160 | + const QLowEnergyDescriptor cccd = |
| 161 | + fff6NotifyCharacteristic.descriptor(QBluetoothUuid::ClientCharacteristicConfiguration); |
| 162 | + if (!cccd.isValid()) { |
| 163 | + qDebug() << QStringLiteral("XCX FFF6 CCCD not found"); |
| 164 | + return; |
| 165 | + } |
| 166 | + fff0Service->writeDescriptor(cccd, QByteArray::fromHex("0100")); |
| 167 | +} |
| 168 | + |
| 169 | +void xcxbike::descriptorWritten(const QLowEnergyDescriptor &descriptor, const QByteArray &value) { |
| 170 | + qDebug() << QStringLiteral("XCX descriptor written") << descriptor.uuid() << value.toHex(' '); |
| 171 | + notificationEnabled = true; |
| 172 | + emit connectedAndDiscovered(); |
| 173 | +} |
| 174 | + |
| 175 | +void xcxbike::createVirtualBike() { |
| 176 | + if (hasVirtualDevice()) |
| 177 | + return; |
| 178 | + QSettings settings; |
| 179 | + if (settings.value(QZSettings::virtual_device_enabled, QZSettings::default_virtual_device_enabled).toBool()) { |
| 180 | + auto *virtualBike = |
| 181 | + new virtualbike(this, noWriteResistance, noHeartService, bikeResistanceOffset, bikeResistanceGain); |
| 182 | + connect(virtualBike, &virtualbike::changeInclination, this, &xcxbike::changeInclination); |
| 183 | + setVirtualDevice(virtualBike, VIRTUAL_DEVICE_MODE::PRIMARY); |
| 184 | + } |
| 185 | +} |
| 186 | + |
| 187 | +void xcxbike::serviceScanDone() { |
| 188 | + fff0Service = m_control->createServiceObject(fff0Uuid, this); |
| 189 | + if (!fff0Service) { |
| 190 | + qDebug() << QStringLiteral("XCX proprietary FFF0 service not found"); |
| 191 | + return; |
| 192 | + } |
| 193 | + connect(fff0Service, &QLowEnergyService::stateChanged, this, &xcxbike::serviceStateChanged); |
| 194 | + fff0Service->discoverDetails(); |
| 195 | +} |
| 196 | + |
| 197 | +void xcxbike::deviceDiscovered(const QBluetoothDeviceInfo &device) { |
| 198 | + bluetoothDevice = device; |
| 199 | + m_control = QLowEnergyController::createCentral(bluetoothDevice, this); |
| 200 | + connect(m_control, &QLowEnergyController::discoveryFinished, this, &xcxbike::serviceScanDone); |
| 201 | + connect(m_control, &QLowEnergyController::stateChanged, this, &xcxbike::controllerStateChanged); |
| 202 | + connect(m_control, &QLowEnergyController::connected, this, [this]() { m_control->discoverServices(); }); |
| 203 | + connect(m_control, &QLowEnergyController::disconnected, this, &xcxbike::disconnected); |
| 204 | + m_control->connectToDevice(); |
| 205 | +} |
| 206 | + |
| 207 | +void xcxbike::controllerStateChanged(QLowEnergyController::ControllerState state) { |
| 208 | + qDebug() << QStringLiteral("XCX controller state") << state; |
| 209 | + if (state == QLowEnergyController::UnconnectedState && m_control) { |
| 210 | + notificationEnabled = false; |
| 211 | + lastTelemetryTime = QDateTime(); |
| 212 | + m_control->connectToDevice(); |
| 213 | + } |
| 214 | +} |
| 215 | + |
| 216 | +bool xcxbike::connected() { |
| 217 | + return m_control && m_control->state() == QLowEnergyController::DiscoveredState && notificationEnabled; |
| 218 | +} |
| 219 | + |
| 220 | +uint16_t xcxbike::watts() { return Cadence.value() == 0 ? 0 : static_cast<uint16_t>(m_watt.value()); } |
0 commit comments