mirror of
https://github.com/GoldenCheetah/GoldenCheetah.git
synced 2026-02-14 08:38:45 +00:00
0d3a8c911a
Added calibration trainer command, delayed check for user stopped pedaling with visual feedback on progress and saved calibration for next use on success.
3174 lines
110 KiB
C++
3174 lines
110 KiB
C++
/*
|
|
* Copyright (c) 2009 Mark Liversedge (liversedge@gmail.com)
|
|
*
|
|
* 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 2 of the License, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc., 51
|
|
* Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#include "TrainSidebar.h"
|
|
#include "MainWindow.h"
|
|
#include "Context.h"
|
|
#include "Athlete.h"
|
|
#include "Settings.h"
|
|
#include "Colors.h"
|
|
#include "Units.h"
|
|
#include "DeviceTypes.h"
|
|
#include "DeviceConfiguration.h"
|
|
#include "RideImportWizard.h"
|
|
#include <QApplication>
|
|
#include <QtGui>
|
|
#include <QRegExp>
|
|
#include <QStyle>
|
|
#include <QStyleFactory>
|
|
#include <QScrollBar>
|
|
|
|
#include <QEvent>
|
|
#include <QInputEvent>
|
|
#include <QKeyEvent>
|
|
|
|
#include <QSound>
|
|
|
|
// Three current realtime device types supported are:
|
|
#include "RealtimeController.h"
|
|
#include "ComputrainerController.h"
|
|
#include "MonarkController.h"
|
|
#include "KettlerController.h"
|
|
#include "KettlerRacerController.h"
|
|
#include "ErgofitController.h"
|
|
#include "DaumController.h"
|
|
#include "ANTlocalController.h"
|
|
#include "NullController.h"
|
|
#ifdef QT_BLUETOOTH_LIB
|
|
#include "BT40Controller.h"
|
|
#endif
|
|
#ifdef GC_HAVE_LIBUSB
|
|
#include "FortiusController.h"
|
|
#include "ImagicController.h"
|
|
#endif
|
|
|
|
// Media selection helper
|
|
#if defined(GC_VIDEO_AV) || defined(GC_VIDEO_QUICKTIME)
|
|
#include "QtMacVideoWindow.h"
|
|
#else
|
|
#include "VideoWindow.h"
|
|
#endif
|
|
#ifdef Q_OS_MAC
|
|
#include <CoreServices/CoreServices.h>
|
|
#include <QStyle>
|
|
#include <QStyleFactory>
|
|
#import <IOKit/pwr_mgt/IOPMLib.h>
|
|
#endif
|
|
|
|
#ifdef WIN32
|
|
#include "windows.h"
|
|
#endif
|
|
|
|
#include "TrainDB.h"
|
|
#include "Library.h"
|
|
|
|
TrainSidebar::TrainSidebar(Context *context) : GcWindow(context), context(context),
|
|
bicycle(context)
|
|
{
|
|
QWidget *c = new QWidget;
|
|
//c->setContentsMargins(0,0,0,0); // bit of space is useful
|
|
QVBoxLayout *cl = new QVBoxLayout(c);
|
|
setControls(c);
|
|
autoConnect = false;
|
|
useSimulatedSpeed = false;
|
|
|
|
cl->setSpacing(0);
|
|
cl->setContentsMargins(0,0,0,0);
|
|
|
|
// don't set the source for telemetry
|
|
lastAppliedIntensity = 100;
|
|
bpmTelemetry = wattsTelemetry = kphTelemetry = rpmTelemetry = -1;
|
|
|
|
#if !defined GC_VIDEO_NONE
|
|
videoModel = new QSqlTableModel(this, trainDB->connection());
|
|
videoModel->setTable("videos");
|
|
videoModel->setEditStrategy(QSqlTableModel::OnManualSubmit);
|
|
videoModel->select();
|
|
while (videoModel->canFetchMore(QModelIndex())) videoModel->fetchMore(QModelIndex());
|
|
|
|
vsortModel = new QSortFilterProxyModel(this);
|
|
vsortModel->setSourceModel(videoModel);
|
|
vsortModel->setDynamicSortFilter(true);
|
|
vsortModel->sort(1, Qt::AscendingOrder); //filename order
|
|
|
|
mediaTree = new QTreeView;
|
|
mediaTree->setModel(vsortModel);
|
|
|
|
// hide unwanted columns and header
|
|
for(int i=0; i<mediaTree->header()->count(); i++)
|
|
mediaTree->setColumnHidden(i, true);
|
|
mediaTree->setColumnHidden(1, false); // show filename
|
|
mediaTree->header()->hide();
|
|
|
|
mediaTree->setSortingEnabled(false);
|
|
mediaTree->setAlternatingRowColors(false);
|
|
mediaTree->setEditTriggers(QAbstractItemView::NoEditTriggers); // read-only
|
|
mediaTree->expandAll();
|
|
mediaTree->header()->setCascadingSectionResizes(true); // easier to resize this way
|
|
mediaTree->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
mediaTree->header()->setStretchLastSection(true);
|
|
mediaTree->header()->setMinimumSectionSize(0);
|
|
mediaTree->header()->setFocusPolicy(Qt::NoFocus);
|
|
mediaTree->setFrameStyle(QFrame::NoFrame);
|
|
#ifdef Q_OS_MAC
|
|
mediaTree->header()->setSortIndicatorShown(false); // blue looks nasty
|
|
mediaTree->setAttribute(Qt::WA_MacShowFocusRect, 0);
|
|
#endif
|
|
#ifdef Q_OS_WIN
|
|
QStyle *cde = QStyleFactory::create(OS_STYLE);
|
|
mediaTree->verticalScrollBar()->setStyle(cde);
|
|
#endif
|
|
|
|
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
videosyncModel = new QSqlTableModel(this, trainDB->connection());
|
|
videosyncModel->setTable("videosyncs");
|
|
videosyncModel->setEditStrategy(QSqlTableModel::OnManualSubmit);
|
|
videosyncModel->select();
|
|
while (videosyncModel->canFetchMore(QModelIndex())) videosyncModel->fetchMore(QModelIndex());
|
|
|
|
vssortModel = new QSortFilterProxyModel(this);
|
|
vssortModel->setSourceModel(videosyncModel);
|
|
vssortModel->setDynamicSortFilter(true);
|
|
vssortModel->sort(1, Qt::AscendingOrder); //filename order
|
|
|
|
videosyncTree = new QTreeView;
|
|
videosyncTree->setModel(vssortModel);
|
|
|
|
// hide unwanted columns and header
|
|
for(int i=0; i<videosyncTree->header()->count(); i++)
|
|
videosyncTree->setColumnHidden(i, true);
|
|
videosyncTree->setColumnHidden(1, false); // show filename
|
|
videosyncTree->header()->hide();
|
|
|
|
videosyncTree->setSortingEnabled(false);
|
|
videosyncTree->setAlternatingRowColors(false);
|
|
videosyncTree->setEditTriggers(QAbstractItemView::NoEditTriggers); // read-only
|
|
videosyncTree->expandAll();
|
|
videosyncTree->header()->setCascadingSectionResizes(true); // easier to resize this way
|
|
videosyncTree->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
videosyncTree->header()->setStretchLastSection(true);
|
|
videosyncTree->header()->setMinimumSectionSize(0);
|
|
videosyncTree->header()->setFocusPolicy(Qt::NoFocus);
|
|
videosyncTree->setFrameStyle(QFrame::NoFrame);
|
|
#ifdef Q_OS_MAC
|
|
videosyncTree->header()->setSortIndicatorShown(false); // blue looks nasty
|
|
videosyncTree->setAttribute(Qt::WA_MacShowFocusRect, 0);
|
|
#endif
|
|
#ifdef Q_OS_WIN
|
|
QStyle *cdevideosync = QStyleFactory::create(OS_STYLE);
|
|
videosyncTree->verticalScrollBar()->setStyle(cdevideosync);
|
|
#endif
|
|
|
|
#endif //GC_HAVE_VLC
|
|
|
|
#endif //GC_VIDEO_NONE
|
|
|
|
deviceTree = new DeviceTreeView;
|
|
deviceTree->setFrameStyle(QFrame::NoFrame);
|
|
if (appsettings->value(this, TRAIN_MULTI, false).toBool() == true)
|
|
deviceTree->setSelectionMode(QAbstractItemView::MultiSelection);
|
|
else
|
|
deviceTree->setSelectionMode(QAbstractItemView::SingleSelection);
|
|
deviceTree->setColumnCount(1);
|
|
deviceTree->header()->hide();
|
|
deviceTree->setAlternatingRowColors (false);
|
|
deviceTree->setIndentation(5);
|
|
deviceTree->expandItem(deviceTree->invisibleRootItem());
|
|
deviceTree->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
#ifdef Q_OS_WIN
|
|
QStyle *xde = QStyleFactory::create(OS_STYLE);
|
|
deviceTree->verticalScrollBar()->setStyle(xde);
|
|
#endif
|
|
|
|
workoutModel = new QSqlTableModel(this, trainDB->connection());
|
|
workoutModel->setTable("workouts");
|
|
workoutModel->setEditStrategy(QSqlTableModel::OnManualSubmit);
|
|
workoutModel->select();
|
|
while (workoutModel->canFetchMore(QModelIndex())) workoutModel->fetchMore(QModelIndex());
|
|
|
|
sortModel = new QSortFilterProxyModel(this);
|
|
sortModel->setSourceModel(workoutModel);
|
|
sortModel->setDynamicSortFilter(true);
|
|
sortModel->sort(1, Qt::AscendingOrder); //filename order
|
|
|
|
workoutTree = new QTreeView;
|
|
workoutTree->setModel(sortModel);
|
|
|
|
// hide unwanted columns and header
|
|
for(int i=0; i<workoutTree->header()->count(); i++)
|
|
workoutTree->setColumnHidden(i, true);
|
|
workoutTree->setColumnHidden(1, false); // show filename
|
|
workoutTree->header()->hide();
|
|
workoutTree->setFrameStyle(QFrame::NoFrame);
|
|
workoutTree->setAlternatingRowColors(false);
|
|
workoutTree->setEditTriggers(QAbstractItemView::NoEditTriggers); // read-only
|
|
workoutTree->setSelectionMode(QAbstractItemView::ExtendedSelection);
|
|
workoutTree->expandAll();
|
|
workoutTree->header()->setCascadingSectionResizes(true); // easier to resize this way
|
|
workoutTree->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
workoutTree->header()->setStretchLastSection(true);
|
|
workoutTree->header()->setMinimumSectionSize(0);
|
|
workoutTree->header()->setFocusPolicy(Qt::NoFocus);
|
|
workoutTree->setFrameStyle(QFrame::NoFrame);
|
|
#ifdef Q_OS_MAC
|
|
workoutTree->header()->setSortIndicatorShown(false); // blue looks nasty
|
|
workoutTree->setAttribute(Qt::WA_MacShowFocusRect, 0);
|
|
#endif
|
|
#ifdef Q_OS_WIN
|
|
xde = QStyleFactory::create(OS_STYLE);
|
|
workoutTree->verticalScrollBar()->setStyle(xde);
|
|
#endif
|
|
|
|
connect(context, SIGNAL(newLap()), this, SLOT(resetLapTimer()));
|
|
connect(context, SIGNAL(viewChanged(int)), this, SLOT(viewChanged(int)));
|
|
|
|
// not used but kept in case re-instated in the future
|
|
recordSelector = new QCheckBox(this);
|
|
recordSelector->setText(tr("Save workout data"));
|
|
recordSelector->setChecked(true);
|
|
recordSelector->hide(); // we don't let users change this for now
|
|
|
|
trainSplitter = new GcSplitter(Qt::Vertical);
|
|
trainSplitter->setContentsMargins(0,0,0,0);
|
|
deviceItem = new GcSplitterItem(tr("Devices"), iconFromPNG(":images/sidebar/power.png"), this);
|
|
|
|
// devices splitter actions
|
|
QAction *moreDeviceAct = new QAction(iconFromPNG(":images/sidebar/extra.png"), tr("Menu"), this);
|
|
deviceItem->addAction(moreDeviceAct);
|
|
connect(moreDeviceAct, SIGNAL(triggered(void)), this, SLOT(devicePopup(void)));
|
|
|
|
workoutItem = new GcSplitterItem(tr("Workouts"), iconFromPNG(":images/sidebar/folder.png"), this);
|
|
QAction *moreWorkoutAct = new QAction(iconFromPNG(":images/sidebar/extra.png"), tr("Menu"), this);
|
|
workoutItem->addAction(moreWorkoutAct);
|
|
connect(moreWorkoutAct, SIGNAL(triggered(void)), this, SLOT(workoutPopup(void)));
|
|
|
|
deviceItem->addWidget(deviceTree);
|
|
trainSplitter->addWidget(deviceItem);
|
|
workoutItem->addWidget(workoutTree);
|
|
trainSplitter->addWidget(workoutItem);
|
|
cl->addWidget(trainSplitter);
|
|
|
|
|
|
#if !defined GC_VIDEO_NONE
|
|
mediaItem = new GcSplitterItem(tr("Media"), iconFromPNG(":images/sidebar/movie.png"), this);
|
|
QAction *moreMediaAct = new QAction(iconFromPNG(":images/sidebar/extra.png"), tr("Menu"), this);
|
|
mediaItem->addAction(moreMediaAct);
|
|
connect(moreMediaAct, SIGNAL(triggered(void)), this, SLOT(mediaPopup(void)));
|
|
mediaItem->addWidget(mediaTree);
|
|
trainSplitter->addWidget(mediaItem);
|
|
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
videosyncItem = new GcSplitterItem(tr("VideoSync"), iconFromPNG(":images/sidebar/sync.png"), this);
|
|
QAction *moreVideoSyncAct = new QAction(iconFromPNG(":images/sidebar/extra.png"), tr("Menu"), this);
|
|
videosyncItem->addAction(moreVideoSyncAct);
|
|
connect(moreVideoSyncAct, SIGNAL(triggered(void)), this, SLOT(videosyncPopup(void)));
|
|
videosyncItem->addWidget(videosyncTree);
|
|
trainSplitter->addWidget(videosyncItem);
|
|
#endif //GC_HAVE_VLC
|
|
#endif //GC_VIDEO_NONE
|
|
trainSplitter->prepare(context->athlete->cyclist, "train");
|
|
|
|
#ifdef Q_OS_MAC
|
|
// get rid of annoying focus rectangle for sidebar components
|
|
#if !defined GC_VIDEO_NONE
|
|
mediaTree->setAttribute(Qt::WA_MacShowFocusRect, 0);
|
|
#if defined GC_HAVE_VLC // not on OSX at present
|
|
videosyncTree->setAttribute(Qt::WA_MacShowFocusRect, 0);
|
|
#endif
|
|
#endif
|
|
workoutTree->setAttribute(Qt::WA_MacShowFocusRect, 0);
|
|
deviceTree->setAttribute(Qt::WA_MacShowFocusRect, 0);
|
|
#endif
|
|
|
|
// handle config changes
|
|
connect(deviceTree,SIGNAL(itemSelectionChanged()), this, SLOT(deviceTreeWidgetSelectionChanged()));
|
|
connect(deviceTree,SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(deviceTreeMenuPopup(const QPoint &)));
|
|
connect(deviceTree,SIGNAL(itemMoved(int, int)), this, SLOT(moveDevices(int, int)));
|
|
|
|
#if !defined GC_VIDEO_NONE
|
|
connect(mediaTree->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)),
|
|
this, SLOT(mediaTreeWidgetSelectionChanged()));
|
|
connect(context, SIGNAL(selectMedia(QString)), this, SLOT(selectVideo(QString)));
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
connect(videosyncTree->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)),
|
|
this, SLOT(videosyncTreeWidgetSelectionChanged()));
|
|
connect(context, SIGNAL(selectVideoSync(QString)), this, SLOT(selectVideoSync(QString)));
|
|
#endif //GC_HAVE_VLC
|
|
#endif //GC_VIDEO_NONE
|
|
connect(context, SIGNAL(configChanged(qint32)), this, SLOT(configChanged(qint32)));
|
|
connect(context, SIGNAL(selectWorkout(QString)), this, SLOT(selectWorkout(QString)));
|
|
connect(trainDB, SIGNAL(dataChanged()), this, SLOT(refresh()));
|
|
|
|
connect(workoutTree->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)), this, SLOT(workoutTreeWidgetSelectionChanged()));
|
|
|
|
videosyncFile = NULL;
|
|
calibrating = false;
|
|
|
|
// Remote control support
|
|
remote = new RemoteControl;
|
|
|
|
// now the GUI is setup lets sort our control variables
|
|
gui_timer = new QTimer(this);
|
|
disk_timer = new QTimer(this);
|
|
load_timer = new QTimer(this);
|
|
|
|
session_time = QTime();
|
|
session_elapsed_msec = 0;
|
|
lap_time = QTime();
|
|
lap_elapsed_msec = 0;
|
|
|
|
rrFile = recordFile = vo2File = NULL;
|
|
lastRecordSecs = 0;
|
|
status = 0;
|
|
setStatusFlags(RT_MODE_ERGO); // ergo mode by default
|
|
mode = ERG;
|
|
pendingConfigChange = false;
|
|
|
|
displayWorkoutLap = 0;
|
|
pwrcount = 0;
|
|
cadcount = 0;
|
|
hrcount = 0;
|
|
spdcount = 0;
|
|
lodcount = 0;
|
|
wbalr = wbal = 0;
|
|
load_msecs = total_msecs = lap_msecs = 0;
|
|
displayWorkoutDistance = displayDistance = displayPower = displayHeartRate =
|
|
displaySpeed = displayCadence = slope = load = 0;
|
|
displaySMO2 = displayTHB = displayO2HB = displayHHB = 0;
|
|
displayLRBalance = displayLTE = displayRTE = displayLPS = displayRPS = 0;
|
|
displayLatitude = displayLongitude = displayAltitude = 0.0;
|
|
|
|
connect(gui_timer, SIGNAL(timeout()), this, SLOT(guiUpdate()));
|
|
connect(disk_timer, SIGNAL(timeout()), this, SLOT(diskUpdate()));
|
|
connect(load_timer, SIGNAL(timeout()), this, SLOT(loadUpdate()));
|
|
|
|
configChanged(CONFIG_APPEARANCE | CONFIG_DEVICES | CONFIG_ZONES); // will reset the workout tree
|
|
setLabels();
|
|
|
|
// capture keyboard events so we can control during
|
|
// a workout using basic keyboard controls
|
|
context->mainWindow->installEventFilter(this);
|
|
|
|
#ifndef Q_OS_MAC
|
|
//toolbarButtons->hide();
|
|
#endif
|
|
|
|
}
|
|
|
|
void
|
|
TrainSidebar::refresh()
|
|
{
|
|
int row;
|
|
|
|
#if !defined GC_VIDEO_NONE
|
|
// remember selection
|
|
row = mediaTree->currentIndex().row();
|
|
QString videoPath = mediaTree->model()->data(mediaTree->model()->index(row,0)).toString();
|
|
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
// refresh data
|
|
videoModel->select();
|
|
while (videoModel->canFetchMore(QModelIndex())) videoModel->fetchMore(QModelIndex());
|
|
#endif
|
|
|
|
// restore selection
|
|
selectVideo(videoPath);
|
|
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
// remember selection
|
|
row = videosyncTree->currentIndex().row();
|
|
QString videosyncPath = videosyncTree->model()->data(videosyncTree->model()->index(row,0)).toString();
|
|
|
|
// refresh data
|
|
videosyncModel->select();
|
|
while (videosyncModel->canFetchMore(QModelIndex())) videosyncModel->fetchMore(QModelIndex());
|
|
|
|
// restore selection
|
|
selectVideoSync(videosyncPath);
|
|
#endif // GC_HAVE_VLC
|
|
|
|
#endif // GC_VIDEO_NONE
|
|
|
|
row = workoutTree->currentIndex().row();
|
|
QString workoutPath = workoutTree->model()->data(workoutTree->model()->index(row,0)).toString();
|
|
|
|
workoutModel->select();
|
|
while (workoutModel->canFetchMore(QModelIndex())) workoutModel->fetchMore(QModelIndex());
|
|
|
|
// restore selection
|
|
selectWorkout(workoutPath);
|
|
}
|
|
|
|
void
|
|
TrainSidebar::workoutPopup()
|
|
{
|
|
// OK - we are working with a specific event..
|
|
QMenu menu(workoutTree);
|
|
QAction *import = new QAction(tr("Import Workout from File"), workoutTree);
|
|
QAction *download = new QAction(tr("Get Workouts from ErgDB"), workoutTree);
|
|
QAction *dlTodaysPlan = new QAction(tr("Get Workouts from Today's Plan"), workoutTree);
|
|
QAction *wizard = new QAction(tr("Create Workout via Wizard"), workoutTree);
|
|
QAction *scan = new QAction(tr("Scan for Workouts"), workoutTree);
|
|
|
|
menu.addAction(import);
|
|
menu.addAction(download);
|
|
menu.addAction(dlTodaysPlan);
|
|
menu.addAction(wizard);
|
|
menu.addAction(scan);
|
|
|
|
|
|
// we can delete too
|
|
int delNumber = 0;
|
|
|
|
QModelIndexList list = workoutTree->selectionModel()->selectedRows();
|
|
foreach (QModelIndex index, list)
|
|
{
|
|
QModelIndex target = sortModel->mapToSource(index);
|
|
|
|
QString filename = workoutModel->data(workoutModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
if (QFileInfo(filename).exists()) {
|
|
delNumber++;
|
|
}
|
|
}
|
|
|
|
if (delNumber > 0) {
|
|
QAction *del = new QAction(tr("Delete selected Workout"), workoutTree);
|
|
|
|
if (delNumber > 1) {
|
|
del->setText(QString(tr("Delete %1 selected Workouts")).arg(delNumber));
|
|
}
|
|
menu.addAction(del);
|
|
connect(del, SIGNAL(triggered(void)), this, SLOT(deleteWorkouts(void)));
|
|
}
|
|
|
|
// connect menu to functions
|
|
connect(import, SIGNAL(triggered(void)), context->mainWindow, SLOT(importWorkout(void)));
|
|
connect(wizard, SIGNAL(triggered(void)), context->mainWindow, SLOT(showWorkoutWizard(void)));
|
|
connect(download, SIGNAL(triggered(void)), context->mainWindow, SLOT(downloadErgDB(void)));
|
|
connect(dlTodaysPlan, SIGNAL(triggered(void)), context->mainWindow, SLOT(downloadTodaysPlanWorkouts(void)));
|
|
connect(scan, SIGNAL(triggered(void)), context->mainWindow, SLOT(manageLibrary(void)));
|
|
|
|
// execute the menu
|
|
menu.exec(trainSplitter->mapToGlobal(QPoint(workoutItem->pos().x()+workoutItem->width()-20,
|
|
workoutItem->pos().y())));
|
|
}
|
|
|
|
bool
|
|
TrainSidebar::eventFilter(QObject *, QEvent *event)
|
|
{
|
|
// do not allow to close the Window when active
|
|
if (event->type() == QEvent::Close) {
|
|
if (status & RT_RUNNING) {
|
|
QMessageBox::warning(this, tr("Train mode active"), tr("Please stop the train mode before closing the window or application."));
|
|
event->ignore();
|
|
return true;
|
|
} else if (gui_timer->isActive()) {
|
|
// we just disconnecting before allowing the window to close
|
|
Disconnect();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// only when we are recording !
|
|
if (status & RT_RECORDING) {
|
|
#if 0
|
|
if (event->type() == QEvent::KeyPress) {
|
|
|
|
// we care about cmd / ctrl
|
|
Qt::KeyboardModifiers kmod = static_cast<QInputEvent*>(event)->modifiers();
|
|
bool ctrl = (kmod & Qt::ControlModifier) != 0;
|
|
Q_UNUSED(ctrl);
|
|
|
|
// what was pressed
|
|
int key =static_cast<QKeyEvent*>(event)->key();
|
|
|
|
//
|
|
// We can process the keyboard event here
|
|
// and call any training method
|
|
//
|
|
// KEY FUNCTION
|
|
// Start() - will pause/unpause if running
|
|
// Stop() - will end workout
|
|
// Pause() - pause only
|
|
// UnPause() - unpause
|
|
// FFwd() - nip forward
|
|
// Rewind() - nip back
|
|
// newLap() - new lap marker
|
|
//
|
|
switch(key) {
|
|
|
|
//XXX TODO
|
|
|
|
default:
|
|
break;
|
|
|
|
}
|
|
return true; // we listen to 'em all
|
|
}
|
|
#endif
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void
|
|
TrainSidebar::mediaPopup()
|
|
{
|
|
// OK - we are working with a specific event..
|
|
QMenu menu(mediaTree);
|
|
QAction *import = new QAction(tr("Import Video from File"), mediaTree);
|
|
QAction *scan = new QAction(tr("Scan for Videos"), mediaTree);
|
|
|
|
menu.addAction(import);
|
|
menu.addAction(scan);
|
|
|
|
// connect menu to functions
|
|
connect(import, SIGNAL(triggered(void)), context->mainWindow, SLOT(importWorkout(void)));
|
|
connect(scan, SIGNAL(triggered(void)), context->mainWindow, SLOT(manageLibrary(void)));
|
|
|
|
QModelIndex current = mediaTree->currentIndex();
|
|
QModelIndex target = vsortModel->mapToSource(current);
|
|
QString filename = videoModel->data(videoModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
if (QFileInfo(filename).exists()) {
|
|
QAction *del = new QAction(tr("Remove reference to selected video"), workoutTree);
|
|
menu.addAction(del);
|
|
connect(del, SIGNAL(triggered(void)), this, SLOT(deleteVideos(void)));
|
|
}
|
|
|
|
// execute the menu
|
|
menu.exec(trainSplitter->mapToGlobal(QPoint(mediaItem->pos().x()+mediaItem->width()-20,
|
|
mediaItem->pos().y())));
|
|
}
|
|
|
|
void
|
|
TrainSidebar::videosyncPopup()
|
|
{
|
|
// OK - we are working with a specific event..
|
|
QMenu menu(videosyncTree);
|
|
QAction *import = new QAction(tr("Import VideoSync from File"), videosyncTree);
|
|
QAction *scan = new QAction(tr("Scan for VideoSyncs"), videosyncTree);
|
|
|
|
menu.addAction(import);
|
|
menu.addAction(scan);
|
|
|
|
// connect menu to functions
|
|
connect(import, SIGNAL(triggered(void)), context->mainWindow, SLOT(importWorkout(void)));
|
|
connect(scan, SIGNAL(triggered(void)), context->mainWindow, SLOT(manageLibrary(void)));
|
|
|
|
QModelIndex current = videosyncTree->currentIndex();
|
|
QModelIndex target = vssortModel->mapToSource(current);
|
|
QString filename = videosyncModel->data(videosyncModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
if (QFileInfo(filename).exists()) {
|
|
QAction *del = new QAction(tr("Delete selected VideoSync"), workoutTree);
|
|
menu.addAction(del);
|
|
connect(del, SIGNAL(triggered(void)), this, SLOT(deleteVideoSyncs(void)));
|
|
}
|
|
|
|
// execute the menu
|
|
menu.exec(trainSplitter->mapToGlobal(QPoint(videosyncItem->pos().x()+videosyncItem->width()-20,
|
|
videosyncItem->pos().y())));
|
|
}
|
|
|
|
void
|
|
TrainSidebar::configChanged(qint32)
|
|
{
|
|
// do not refresh if workout running, defer to end of workout
|
|
if (status&RT_RUNNING) {
|
|
pendingConfigChange = true;
|
|
return;
|
|
}
|
|
|
|
// auto connect is off by default
|
|
autoConnect = appsettings->value(this, TRAIN_AUTOCONNECT, false).toBool();
|
|
|
|
// lap sounds are off by default
|
|
lapAudioEnabled = appsettings->value(this, TRAIN_LAPALERT, false).toBool();
|
|
|
|
useSimulatedSpeed = appsettings->value(this, TRAIN_USESIMULATEDSPEED, false).toBool();
|
|
|
|
setProperty("color", GColor(CTRAINPLOTBACKGROUND));
|
|
#if !defined GC_VIDEO_NONE
|
|
mediaTree->setStyleSheet(GCColor::stylesheet());
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
videosyncTree->setStyleSheet(GCColor::stylesheet());
|
|
#endif
|
|
#endif
|
|
workoutTree->setStyleSheet(GCColor::stylesheet());
|
|
deviceTree->setStyleSheet(GCColor::stylesheet());
|
|
|
|
// DEVICES
|
|
|
|
// Disconnect any running telemetry before manipulating device list
|
|
Disconnect();
|
|
|
|
// zap whats there
|
|
QList<QTreeWidgetItem *> devices = deviceTree->invisibleRootItem()->takeChildren();
|
|
for (int i=0; i<devices.count(); i++) delete devices.at(i);
|
|
|
|
if (appsettings->value(this, TRAIN_MULTI, false).toBool() == true)
|
|
deviceTree->setSelectionMode(QAbstractItemView::MultiSelection);
|
|
else
|
|
deviceTree->setSelectionMode(QAbstractItemView::SingleSelection);
|
|
|
|
// wipe whatever is there
|
|
foreach(DeviceConfiguration x, Devices) delete x.controller;
|
|
Devices.clear();
|
|
|
|
DeviceConfigurations all;
|
|
Devices = all.getList();
|
|
for (int i=0; i<Devices.count(); i++) {
|
|
|
|
// add to the selection tree
|
|
QTreeWidgetItem *device = new QTreeWidgetItem(deviceTree->invisibleRootItem(), i);
|
|
device->setText(0, Devices.at(i).name);
|
|
|
|
// Create the controllers for each device
|
|
// we can call upon each of these when we need
|
|
// to interact with the device
|
|
if (Devices.at(i).type == DEV_CT) {
|
|
Devices[i].controller = new ComputrainerController(this, &Devices[i]);
|
|
} else if (Devices.at(i).type == DEV_MONARK) {
|
|
Devices[i].controller = new MonarkController(this, &Devices[i]);
|
|
} else if (Devices.at(i).type == DEV_KETTLER) {
|
|
Devices[i].controller = new KettlerController(this, &Devices[i]);
|
|
} else if (Devices.at(i).type == DEV_KETTLER_RACER) {
|
|
Devices[i].controller = new KettlerRacerController(this, &Devices[i]);
|
|
} else if (Devices.at(i).type == DEV_ERGOFIT) {
|
|
Devices[i].controller = new ErgofitController(this, &Devices[i]);
|
|
} else if (Devices.at(i).type == DEV_DAUM) {
|
|
Devices[i].controller = new DaumController(this, &Devices[i]);
|
|
#ifdef GC_HAVE_LIBUSB
|
|
} else if (Devices.at(i).type == DEV_FORTIUS) {
|
|
Devices[i].controller = new FortiusController(this, &Devices[i]);
|
|
} else if (Devices.at(i).type == DEV_IMAGIC) {
|
|
Devices[i].controller = new ImagicController(this, &Devices[i]);
|
|
#endif
|
|
} else if (Devices.at(i).type == DEV_NULL) {
|
|
Devices[i].controller = new NullController(this, &Devices[i]);
|
|
} else if (Devices.at(i).type == DEV_ANTLOCAL) {
|
|
Devices[i].controller = new ANTlocalController(this, &Devices[i]);
|
|
// connect slot for receiving remote control commands
|
|
connect(Devices[i].controller, SIGNAL(remoteControl(uint16_t)), this, SLOT(remoteControl(uint16_t)));
|
|
// connect slot for receiving rrData
|
|
connect(Devices[i].controller, SIGNAL(rrData(uint16_t,uint8_t,uint8_t)), this, SLOT(rrData(uint16_t,uint8_t,uint8_t)));
|
|
#ifdef QT_BLUETOOTH_LIB
|
|
} else if (Devices.at(i).type == DEV_BT40) {
|
|
Devices[i].controller = new BT40Controller(this, &Devices[i]);
|
|
connect(Devices[i].controller, SIGNAL(vo2Data(double,double,double,double,double,double)),
|
|
this, SLOT(vo2Data(double,double,double,double,double,double)));
|
|
#endif
|
|
}
|
|
}
|
|
|
|
// select the first device
|
|
if (Devices.count()) {
|
|
deviceTree->setCurrentItem(deviceTree->invisibleRootItem()->child(0));
|
|
}
|
|
// And select default workout to Ergo
|
|
QModelIndex firstWorkout = sortModel->index(0, 0, QModelIndex());
|
|
workoutTree->setCurrentIndex(firstWorkout);
|
|
|
|
// Re-read ANT remote control command mappings
|
|
remote->readConfig();
|
|
|
|
// Athlete
|
|
FTP=285; // default to 285 if zones are not set
|
|
WPRIME = 20000;
|
|
|
|
int range = context->athlete->zones(false)->whichRange(QDate::currentDate());
|
|
if (range != -1) {
|
|
FTP = context->athlete->zones(false)->getCP(range);
|
|
WPRIME = context->athlete->zones(false)->getWprime(range);
|
|
}
|
|
|
|
// Reinit Bicycle
|
|
bicycle.Reset(context);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
* Device Selected
|
|
*--------------------------------------------------------------------*/
|
|
void
|
|
TrainSidebar::deviceTreeWidgetSelectionChanged()
|
|
{
|
|
//qDebug() << "TrainSidebar::deviceTreeWidgetSelectionChanged()";
|
|
|
|
bpmTelemetry = wattsTelemetry = kphTelemetry = rpmTelemetry = -1;
|
|
deviceSelected();
|
|
|
|
if (status&RT_CONNECTED) Disconnect(); // disconnect first
|
|
if (autoConnect) Connect(); // re-connect
|
|
}
|
|
|
|
int
|
|
TrainSidebar::selectedDeviceNumber()
|
|
{
|
|
if (deviceTree->selectedItems().isEmpty()) return -1;
|
|
|
|
QTreeWidgetItem *selected = deviceTree->selectedItems().first();
|
|
|
|
if (selected->type() == HEAD_TYPE) return -1;
|
|
else return selected->type();
|
|
}
|
|
|
|
QList<int>
|
|
TrainSidebar::devices()
|
|
{
|
|
QList<int> returning;
|
|
foreach(QTreeWidgetItem *item, deviceTree->selectedItems())
|
|
if (item->type() != HEAD_TYPE)
|
|
returning << item->type();
|
|
|
|
return returning;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
* Workout Selected
|
|
*--------------------------------------------------------------------*/
|
|
void
|
|
TrainSidebar::workoutTreeWidgetSelectionChanged()
|
|
{
|
|
QModelIndex current = workoutTree->currentIndex();
|
|
QModelIndex target = sortModel->mapToSource(current);
|
|
QString filename = workoutModel->data(workoutModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
|
|
// wipe away the current selected workout once we've told everyone
|
|
// since they might be editing it and want to save changes first (!!)
|
|
ErgFile *prior = const_cast<ErgFile*>(ergFileQueryAdapter.getErgFile());
|
|
|
|
if (filename == "") {
|
|
|
|
// an empty workout
|
|
context->notifyErgFileSelected(NULL);
|
|
ergFileQueryAdapter.setErgFile(NULL);
|
|
|
|
// clean last
|
|
if (prior) delete prior;
|
|
|
|
return;
|
|
}
|
|
|
|
// is it the auto mode?
|
|
int index = target.row();
|
|
if (index == 0) {
|
|
// ergo mode
|
|
context->notifyErgFileSelected(NULL);
|
|
ergFileQueryAdapter.setErgFile(NULL);
|
|
mode = ERG;
|
|
setLabels();
|
|
clearStatusFlags(RT_WORKOUT);
|
|
//ergPlot->setVisible(false);
|
|
} else if (index == 1) {
|
|
// slope mode
|
|
context->notifyErgFileSelected(NULL);
|
|
ergFileQueryAdapter.setErgFile(NULL);
|
|
mode = CRS;
|
|
setLabels();
|
|
clearStatusFlags(RT_WORKOUT);
|
|
//ergPlot->setVisible(false);
|
|
} else {
|
|
// workout mode
|
|
ErgFile* ergFile = new ErgFile(filename, mode, context);
|
|
mode = ergFile->mode;
|
|
|
|
if (ergFile->isValid()) {
|
|
|
|
setStatusFlags(RT_WORKOUT);
|
|
|
|
// success! we have a load file
|
|
// setup the course profile in the
|
|
// display!
|
|
context->notifyErgFileSelected(ergFile);
|
|
ergFileQueryAdapter.setErgFile(ergFile);
|
|
adjustIntensity(100);
|
|
setLabels();
|
|
} else {
|
|
|
|
// couldn't parse fall back to ERG mode
|
|
delete ergFile;
|
|
ergFile = NULL;
|
|
context->notifyErgFileSelected(NULL);
|
|
ergFileQueryAdapter.setErgFile(NULL);
|
|
removeInvalidWorkout();
|
|
mode = ERG;
|
|
clearStatusFlags(RT_WORKOUT);
|
|
setLabels();
|
|
}
|
|
}
|
|
|
|
// set the device to the right mode
|
|
if (mode == ERG || mode == MRC) {
|
|
setStatusFlags(RT_MODE_ERGO);
|
|
clearStatusFlags(RT_MODE_SPIN);
|
|
|
|
// update every active device
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setMode(RT_MODE_ERGO);
|
|
|
|
} else { // SLOPE MODE
|
|
setStatusFlags(RT_MODE_SPIN);
|
|
clearStatusFlags(RT_MODE_ERGO);
|
|
|
|
// update every active device
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setMode(RT_MODE_SPIN);
|
|
}
|
|
|
|
maintainLapDistanceState();
|
|
|
|
ergFileQueryAdapter.resetQueryState();
|
|
|
|
// clean last
|
|
if (prior) delete prior;
|
|
}
|
|
|
|
/*
|
|
* Calculate Lap State with respect to distance.
|
|
* Doesn't apply to time-based workouts.
|
|
* Calculates the current lap distance.
|
|
* Calculates the lap distance remaining in the current lap.
|
|
* Route span is used if workout has no laps.
|
|
*/
|
|
void
|
|
TrainSidebar::maintainLapDistanceState()
|
|
{
|
|
// lapDistance, lapDistanceRemaining are only relevant when
|
|
// running in slope mode.
|
|
if (!ergFileQueryAdapter.getErgFile() || !(status&RT_MODE_SLOPE)) {
|
|
displayLapDistance = 0;
|
|
displayLapDistanceRemaining = -1;
|
|
return;
|
|
}
|
|
|
|
double currentpositionM = displayWorkoutDistance * 1000.;
|
|
double lapmarkerM = ergFileQueryAdapter.currentLap(currentpositionM);
|
|
|
|
// If no current lap then handle route as lap.
|
|
if (lapmarkerM < 0.) {
|
|
displayLapDistance = displayWorkoutDistance;
|
|
displayLapDistanceRemaining = (ergFileQueryAdapter.Duration() / 1000.) - displayWorkoutDistance;
|
|
return;
|
|
}
|
|
|
|
displayLapDistance = (currentpositionM - lapmarkerM) / 1000.;
|
|
double nextlapmarkerM = ergFileQueryAdapter.nextLap(currentpositionM);
|
|
|
|
// If no next lap then use distance to end of route.
|
|
if (nextlapmarkerM < 0.) {
|
|
displayLapDistanceRemaining = (ergFileQueryAdapter.Duration() / 1000.) - displayWorkoutDistance;
|
|
return;
|
|
}
|
|
|
|
displayLapDistanceRemaining = (nextlapmarkerM - currentpositionM) / 1000.;
|
|
}
|
|
|
|
QStringList
|
|
TrainSidebar::listWorkoutFiles(const QDir &dir) const
|
|
{
|
|
QStringList filters;
|
|
filters << "*.erg";
|
|
filters << "*.mrc";
|
|
filters << "*.crs";
|
|
filters << "*.pgmf";
|
|
|
|
return dir.entryList(filters, QDir::Files, QDir::Name);
|
|
}
|
|
|
|
void
|
|
TrainSidebar::deleteVideos()
|
|
{
|
|
QModelIndex current = mediaTree->currentIndex();
|
|
QModelIndex target = vsortModel->mapToSource(current);
|
|
QString filename = videoModel->data(videoModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
|
|
if (QFileInfo(filename).exists()) {
|
|
// are you sure?
|
|
QMessageBox msgBox;
|
|
msgBox.setText(tr("Are you sure you want to remove the reference to this video?"));
|
|
msgBox.setInformativeText(filename);
|
|
QPushButton *deleteButton = msgBox.addButton(tr("Remove"),QMessageBox::YesRole);
|
|
msgBox.setStandardButtons(QMessageBox::Cancel);
|
|
msgBox.setDefaultButton(QMessageBox::Cancel);
|
|
msgBox.setIcon(QMessageBox::Critical);
|
|
msgBox.exec();
|
|
|
|
if(msgBox.clickedButton() != deleteButton) return;
|
|
|
|
// delete from disk
|
|
//XXX QFile(filename).remove(); // lets not for now..
|
|
|
|
// remove any reference (from drag and drop)
|
|
Library *l = Library::findLibrary("Media Library");
|
|
if (l) l->removeRef(context, filename);
|
|
|
|
// delete from DB
|
|
trainDB->startLUW();
|
|
trainDB->deleteVideo(filename);
|
|
trainDB->endLUW();
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
TrainSidebar::deleteVideoSyncs()
|
|
{
|
|
QModelIndex current = videosyncTree->currentIndex();
|
|
QModelIndex target = vssortModel->mapToSource(current);
|
|
QString filename = videosyncModel->data(videosyncModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
|
|
if (QFileInfo(filename).exists()) {
|
|
// are you sure?
|
|
QMessageBox msgBox;
|
|
msgBox.setText(tr("Are you sure you want to delete this VideoSync?"));
|
|
msgBox.setInformativeText(filename);
|
|
QPushButton *deleteButton = msgBox.addButton(tr("Delete"),QMessageBox::YesRole);
|
|
msgBox.setStandardButtons(QMessageBox::Cancel);
|
|
msgBox.setDefaultButton(QMessageBox::Cancel);
|
|
msgBox.setIcon(QMessageBox::Critical);
|
|
msgBox.exec();
|
|
|
|
if(msgBox.clickedButton() != deleteButton) return;
|
|
|
|
// delete from disk
|
|
QFile(filename).remove();
|
|
|
|
// delete from DB
|
|
trainDB->startLUW();
|
|
trainDB->deleteVideoSync(filename);
|
|
trainDB->endLUW();
|
|
}
|
|
}
|
|
|
|
void
|
|
TrainSidebar::removeInvalidVideoSync()
|
|
{
|
|
QModelIndex current = videosyncTree->currentIndex();
|
|
QModelIndex target = vssortModel->mapToSource(current);
|
|
QString filename = videosyncModel->data(videosyncModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
QMessageBox msgBox;
|
|
msgBox.setText(tr("The VideoSync file is either not valid or not existing and will be removed from the library."));
|
|
msgBox.setInformativeText(filename);
|
|
QPushButton *removeButton = msgBox.addButton(tr("Remove"),QMessageBox::YesRole);
|
|
msgBox.setStandardButtons(QMessageBox::Cancel);
|
|
msgBox.setDefaultButton(removeButton);
|
|
msgBox.setIcon(QMessageBox::Critical);
|
|
msgBox.exec();
|
|
|
|
if(msgBox.clickedButton() != removeButton) return;
|
|
|
|
// delete from DB
|
|
trainDB->startLUW();
|
|
trainDB->deleteVideoSync(filename);
|
|
trainDB->endLUW();
|
|
|
|
}
|
|
|
|
void
|
|
TrainSidebar::deleteWorkouts()
|
|
{
|
|
QStringList nameList;
|
|
QModelIndexList list = workoutTree->selectionModel()->selectedRows();
|
|
foreach (QModelIndex index, list) {
|
|
QModelIndex target = sortModel->mapToSource(index);
|
|
QString filename = workoutModel->data(workoutModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
if (QFileInfo(filename).exists()) {
|
|
nameList.append(filename);
|
|
}
|
|
}
|
|
|
|
if (nameList.count()>0) {
|
|
// are you sure?
|
|
QMessageBox msgBox;
|
|
if (nameList.count()==1) {
|
|
msgBox.setText(tr("Are you sure you want to delete this Workout?"));
|
|
}
|
|
else {
|
|
msgBox.setText(QString(tr("Are you sure you want to delete this %1 workouts?")).arg(nameList.count()));
|
|
}
|
|
QString info;
|
|
for (int i=0;i<nameList.count() && i<21;i++) {
|
|
info += nameList.at(i)+"\n";
|
|
if (i == 20) {
|
|
info += "...\n";
|
|
}
|
|
}
|
|
msgBox.setInformativeText(info);
|
|
QPushButton *deleteButton = msgBox.addButton(tr("Delete"),QMessageBox::YesRole);
|
|
msgBox.setStandardButtons(QMessageBox::Cancel);
|
|
msgBox.setDefaultButton(QMessageBox::Cancel);
|
|
msgBox.setIcon(QMessageBox::Critical);
|
|
msgBox.exec();
|
|
|
|
if(msgBox.clickedButton() != deleteButton) return;
|
|
|
|
foreach (QString filename, nameList) {
|
|
if (QFileInfo(filename).exists()) {
|
|
// delete from disk
|
|
QFile(filename).remove();
|
|
// delete from DB
|
|
trainDB->startLUW();
|
|
trainDB->deleteWorkout(filename);
|
|
trainDB->endLUW();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
TrainSidebar::removeInvalidWorkout()
|
|
{
|
|
QModelIndex current = workoutTree->currentIndex();
|
|
QModelIndex target = sortModel->mapToSource(current);
|
|
QString filename = workoutModel->data(workoutModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
|
|
QMessageBox msgBox;
|
|
msgBox.setText(tr("The Workout file is either not valid or not existing and will be removed from the library."));
|
|
msgBox.setInformativeText(filename);
|
|
QPushButton *removeButton = msgBox.addButton(tr("Remove"),QMessageBox::YesRole);
|
|
msgBox.setStandardButtons(QMessageBox::Cancel);
|
|
msgBox.setDefaultButton(removeButton);
|
|
msgBox.setIcon(QMessageBox::Critical);
|
|
msgBox.exec();
|
|
|
|
if(msgBox.clickedButton() != removeButton) return;
|
|
|
|
// delete from DB
|
|
trainDB->startLUW();
|
|
trainDB->deleteWorkout(filename);
|
|
trainDB->endLUW();
|
|
|
|
}
|
|
|
|
void
|
|
TrainSidebar::mediaTreeWidgetSelectionChanged()
|
|
{
|
|
|
|
QModelIndex current = mediaTree->currentIndex();
|
|
QModelIndex target = vsortModel->mapToSource(current);
|
|
QString filename = videoModel->data(videoModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
if (filename == context->videoFilename)
|
|
context->notifyMediaSelected(""); // CTRL+Click to clear selection
|
|
else
|
|
context->notifyMediaSelected(filename);
|
|
}
|
|
|
|
void
|
|
TrainSidebar::videosyncTreeWidgetSelectionChanged()
|
|
{
|
|
|
|
QModelIndex current = videosyncTree->currentIndex();
|
|
QModelIndex target = vssortModel->mapToSource(current);
|
|
QString filename = videosyncModel->data(videosyncModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
|
|
// wip away the current selected videosync
|
|
if (videosyncFile) {
|
|
delete videosyncFile;
|
|
videosyncFile = NULL;
|
|
}
|
|
|
|
if (filename == "") {
|
|
context->notifyVideoSyncFileSelected(NULL);
|
|
return;
|
|
}
|
|
|
|
// is "None" selected?
|
|
int index = target.row();
|
|
if (index == 0) {
|
|
// None menu entry
|
|
context->notifyVideoSyncFileSelected(NULL);
|
|
} else {
|
|
videosyncFile = new VideoSyncFile(filename, mode, context);
|
|
if (videosyncFile->isValid()) {
|
|
context->notifyVideoSyncFileSelected(videosyncFile);
|
|
} else {
|
|
delete videosyncFile;
|
|
videosyncFile = NULL;
|
|
context->notifyVideoSyncFileSelected(NULL);
|
|
removeInvalidVideoSync();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------
|
|
* Was realtime window, now local and manages controller and chart updates etc
|
|
*------------------------------------------------------------------------------*/
|
|
|
|
void TrainSidebar::Start() // when start button is pressed
|
|
{
|
|
if (status&RT_PAUSED) {
|
|
|
|
qDebug() << "unpause...";
|
|
|
|
// UN PAUSE!
|
|
session_time.start();
|
|
lap_time.start();
|
|
clearStatusFlags(RT_PAUSED);
|
|
|
|
// Reset speed simulation timer.
|
|
bicycle.resettimer();
|
|
|
|
maintainLapDistanceState();
|
|
|
|
//foreach(int dev, activeDevices) Devices[dev].controller->restart();
|
|
//gui_timer->start(REFRESHRATE);
|
|
if (status & RT_RECORDING) disk_timer->start(SAMPLERATE);
|
|
load_period.restart();
|
|
load_timer->start(LOADRATE);
|
|
|
|
#if !defined GC_VIDEO_NONE
|
|
mediaTree->setEnabled(false);
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
videosyncTree->setEnabled(false);
|
|
#endif
|
|
#endif
|
|
|
|
// tell the world
|
|
context->notifyUnPause();
|
|
|
|
emit setNotification(tr("Resuming.."), 2);
|
|
|
|
} else if (status&RT_RUNNING) {
|
|
|
|
qDebug() << "pause...";
|
|
|
|
// Pause!
|
|
session_elapsed_msec += session_time.elapsed();
|
|
lap_elapsed_msec += lap_time.elapsed();
|
|
setStatusFlags(RT_PAUSED);
|
|
//foreach(int dev, activeDevices) Devices[dev].controller->pause();
|
|
//gui_timer->stop();
|
|
if (status & RT_RECORDING) disk_timer->stop();
|
|
load_timer->stop();
|
|
load_msecs += load_period.restart();
|
|
|
|
#if !defined GC_VIDEO_NONE
|
|
// enable media tree so we can change movie - mid workout
|
|
mediaTree->setEnabled(true);
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
videosyncTree->setEnabled(true);
|
|
#endif
|
|
#endif
|
|
|
|
// tell the world
|
|
context->notifyPause();
|
|
|
|
emit setNotification(tr("Paused.."), 2);
|
|
|
|
} else if (status&RT_CONNECTED) {
|
|
|
|
qDebug() << "start...";
|
|
|
|
#ifdef WIN32
|
|
// disable the screen saver on Windows
|
|
SetThreadExecutionState(ES_DISPLAY_REQUIRED | ES_CONTINUOUS);
|
|
#endif
|
|
|
|
// Stop users from selecting different devices
|
|
// media or workouts whilst a workout is in progress
|
|
#if !defined GC_VIDEO_NONE
|
|
mediaTree->setEnabled(false);
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
videosyncTree->setEnabled(false);
|
|
#endif
|
|
#endif
|
|
workoutTree->setEnabled(false);
|
|
deviceTree->setEnabled(false);
|
|
|
|
// START!
|
|
load = 100;
|
|
slope = 0.0;
|
|
|
|
// Reset Speed Simulation
|
|
bicycle.clear();
|
|
|
|
maintainLapDistanceState();
|
|
|
|
if (mode == ERG || mode == MRC) {
|
|
setStatusFlags(RT_MODE_ERGO);
|
|
clearStatusFlags(RT_MODE_SPIN);
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setMode(RT_MODE_ERGO);
|
|
} else { // SLOPE MODE
|
|
setStatusFlags(RT_MODE_SPIN);
|
|
clearStatusFlags(RT_MODE_ERGO);
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setMode(RT_MODE_SPIN);
|
|
}
|
|
|
|
// tell the world
|
|
context->notifyStart();
|
|
|
|
// we're away!
|
|
setStatusFlags(RT_RUNNING);
|
|
|
|
// tell the world
|
|
context->notifyStart();
|
|
|
|
load_period.restart();
|
|
session_time.start();
|
|
session_elapsed_msec = 0;
|
|
lap_time.start();
|
|
lap_elapsed_msec = 0;
|
|
wbalr = 0;
|
|
wbal = WPRIME;
|
|
|
|
resetTextAudioEmitTracking();
|
|
|
|
//reset all calibration data
|
|
calibrating = startCalibration = restartCalibration = finishCalibration = false;
|
|
calibrationSpindownTime = calibrationZeroOffset = calibrationSlope = calibrationTargetSpeed = 0;
|
|
calibrationCadence = calibrationCurrentSpeed = calibrationTorque = 0;
|
|
calibrationState = CALIBRATION_STATE_IDLE;
|
|
calibrationType = CALIBRATION_TYPE_NOT_SUPPORTED;
|
|
calibrationDeviceIndex = -1;
|
|
clearStatusFlags(RT_CALIBRATING);
|
|
//foreach(int dev, activeDevices) { // Do for selected device only
|
|
// Devices[dev].controller->resetCalibrationState();
|
|
//}
|
|
|
|
load_timer->start(LOADRATE); // start recording
|
|
|
|
if (recordSelector->isChecked()) {
|
|
setStatusFlags(RT_RECORDING);
|
|
}
|
|
|
|
if (status & RT_RECORDING) {
|
|
QDateTime now = QDateTime::currentDateTime();
|
|
|
|
// setup file
|
|
QString filename = now.toString(QString("yyyy_MM_dd_hh_mm_ss")) + QString(".csv");
|
|
|
|
if (!context->athlete->home->records().exists())
|
|
context->athlete->home->createAllSubdirs();
|
|
|
|
QString fulltarget = context->athlete->home->records().canonicalPath() + "/" + filename;
|
|
|
|
if (recordFile) delete recordFile;
|
|
recordFile = new QFile(fulltarget);
|
|
lastRecordSecs = 0;
|
|
if (!recordFile->open(QFile::WriteOnly | QFile::Truncate)) {
|
|
clearStatusFlags(RT_RECORDING);
|
|
} else {
|
|
|
|
// CSV File header
|
|
|
|
QTextStream recordFileStream(recordFile);
|
|
recordFileStream << "secs, cad, hr, km, kph, nm, watts, alt, lon, lat, headwind, slope, temp, interval, lrbalance, lte, rte, lps, rps, smo2, thb, o2hb, hhb, target\n";
|
|
|
|
disk_timer->start(SAMPLERATE); // start screen
|
|
}
|
|
}
|
|
gui_timer->start(REFRESHRATE); // start recording
|
|
|
|
emit setNotification(tr("Starting.."), 2);
|
|
}
|
|
}
|
|
|
|
void TrainSidebar::Pause() // pause capture to recalibrate
|
|
{
|
|
// Not convinced this function is ever reached, these are handled in Start()
|
|
|
|
// we're not running fool!
|
|
if ((status&RT_RUNNING) == 0) return;
|
|
|
|
if (status&RT_PAUSED) {
|
|
|
|
session_time.start();
|
|
lap_time.start();
|
|
clearStatusFlags(RT_PAUSED);
|
|
foreach(int dev, activeDevices) Devices[dev].controller->restart();
|
|
gui_timer->start(REFRESHRATE);
|
|
if (status & RT_RECORDING) disk_timer->start(SAMPLERATE);
|
|
load_period.restart();
|
|
load_timer->start(LOADRATE);
|
|
|
|
#if !defined GC_VIDEO_NONE
|
|
mediaTree->setEnabled(false);
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
videosyncTree->setEnabled(false);
|
|
#endif
|
|
#endif
|
|
|
|
// tell the world
|
|
context->notifyUnPause();
|
|
} else {
|
|
|
|
session_elapsed_msec += session_time.elapsed();
|
|
lap_elapsed_msec += lap_time.elapsed();
|
|
foreach(int dev, activeDevices) Devices[dev].controller->pause();
|
|
setStatusFlags(RT_PAUSED);
|
|
gui_timer->stop();
|
|
if (status & RT_RECORDING) disk_timer->stop();
|
|
load_timer->stop();
|
|
load_msecs += load_period.restart();
|
|
|
|
// enable media tree so we can change movie
|
|
#if !defined GC_VIDEO_NONE
|
|
mediaTree->setEnabled(true);
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
videosyncTree->setEnabled(true);
|
|
#endif
|
|
#endif
|
|
|
|
// tell the world
|
|
context->notifyPause();
|
|
}
|
|
}
|
|
|
|
void TrainSidebar::Stop(int deviceStatus) // when stop button is pressed
|
|
{
|
|
if ((status&RT_RUNNING) == 0) return;
|
|
|
|
// re-enable the screen saver on Windows
|
|
#ifdef WIN32
|
|
SetThreadExecutionState(ES_CONTINUOUS);
|
|
#endif
|
|
|
|
clearStatusFlags(RT_RUNNING|RT_PAUSED);
|
|
|
|
// Stop users from selecting different devices
|
|
// media or workouts whilst a workout is in progress
|
|
#if !defined GC_VIDEO_NONE
|
|
mediaTree->setEnabled(true);
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
videosyncTree->setEnabled(true);
|
|
#endif
|
|
#endif
|
|
workoutTree->setEnabled(true);
|
|
deviceTree->setEnabled(true);
|
|
|
|
//reset all calibration data
|
|
calibrating = startCalibration = restartCalibration = finishCalibration = false;
|
|
calibrationSpindownTime = calibrationZeroOffset = calibrationSlope = calibrationTargetSpeed = 0;
|
|
calibrationCadence = calibrationCurrentSpeed = calibrationTorque = 0;
|
|
calibrationState = CALIBRATION_STATE_IDLE;
|
|
calibrationType = CALIBRATION_TYPE_NOT_SUPPORTED;
|
|
calibrationDeviceIndex = -1;
|
|
clearStatusFlags(RT_CALIBRATING);
|
|
//foreach(int dev, activeDevices) { // Do for selected device only
|
|
// Devices[dev].controller->resetCalibrationState();
|
|
//}
|
|
|
|
load = 0;
|
|
slope = 0.0;
|
|
|
|
QDateTime now = QDateTime::currentDateTime();
|
|
|
|
if (status & RT_RECORDING) {
|
|
disk_timer->stop();
|
|
|
|
// close and reset File
|
|
recordFile->close();
|
|
|
|
// close rrFile
|
|
if (rrFile) {
|
|
//fprintf(stderr, "Closing r-r file\n"); fflush(stderr);
|
|
rrFile->close();
|
|
delete rrFile;
|
|
rrFile=NULL;
|
|
}
|
|
|
|
// close vo2File
|
|
if (vo2File) {
|
|
fprintf(stderr, "Closing vo2 file\n"); fflush(stderr);
|
|
vo2File->close();
|
|
delete vo2File;
|
|
vo2File=NULL;
|
|
}
|
|
|
|
if(deviceStatus == DEVICE_ERROR)
|
|
{
|
|
recordFile->remove();
|
|
}
|
|
else {
|
|
// add to the view - using basename ONLY
|
|
QString name;
|
|
name = recordFile->fileName();
|
|
|
|
QList<QString> list;
|
|
list.append(name);
|
|
|
|
RideImportWizard *dialog = new RideImportWizard (list, context);
|
|
dialog->process(); // do it!
|
|
}
|
|
|
|
// cancel recording
|
|
status &= ~RT_RECORDING;
|
|
}
|
|
|
|
load_timer->stop();
|
|
load_msecs = 0;
|
|
|
|
// get back to normal after it may have been adusted by the user
|
|
//lastAppliedIntensity=100;
|
|
adjustIntensity(100);
|
|
if (context->currentErgFile()) context->currentErgFile()->reload();
|
|
context->notifySetNow(load_msecs);
|
|
|
|
|
|
// tell the world
|
|
context->notifyStop();
|
|
|
|
// if a config change was requested while workout was running, action it now
|
|
if (pendingConfigChange) {
|
|
pendingConfigChange = false;
|
|
configChanged(CONFIG_APPEARANCE | CONFIG_DEVICES | CONFIG_ZONES);
|
|
}
|
|
|
|
// Re-enable gui elements
|
|
// reset counters etc
|
|
pwrcount = 0;
|
|
cadcount = 0;
|
|
hrcount = 0;
|
|
spdcount = 0;
|
|
lodcount = 0;
|
|
displayWorkoutLap = 0;
|
|
wbalr = 0;
|
|
wbal = WPRIME;
|
|
session_elapsed_msec = 0;
|
|
session_time.restart();
|
|
lap_elapsed_msec = 0;
|
|
lap_time.restart();
|
|
displayWorkoutDistance = displayDistance = 0;
|
|
displayLapDistance = 0;
|
|
displayLapDistanceRemaining = -1;
|
|
displayAltitude = 0;
|
|
|
|
ergFileQueryAdapter.resetQueryState();
|
|
guiUpdate();
|
|
|
|
emit setNotification(tr("Stopped.."), 2);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
// Called by push devices (e.g. ANT+)
|
|
void TrainSidebar::updateData(RealtimeData &rtData)
|
|
{
|
|
displayPower = rtData.getWatts();
|
|
displayCadence = rtData.getCadence();
|
|
displayHeartRate = rtData.getHr();
|
|
displaySpeed = rtData.getSpeed();
|
|
load = rtData.getLoad();
|
|
displayLRBalance = rtData.getLRBalance();
|
|
displayLTE = rtData.getLTE();
|
|
displayRTE = rtData.getRTE();
|
|
displayLPS = rtData.getLPS();
|
|
displayRPS = rtData.getRPS();
|
|
displaySMO2 = rtData.getSmO2();
|
|
displayTHB = rtData.gettHb();
|
|
displayO2HB = rtData.getO2Hb();
|
|
displayHHB = rtData.getHHb();
|
|
displayLatitude = rtData.getLatitude();
|
|
displayLongitude = rtData.getLongitude();
|
|
displayAltitude = rtData.getAltitude();
|
|
// Gradient not supported
|
|
return;
|
|
}
|
|
|
|
void TrainSidebar::toggleConnect()
|
|
{
|
|
if (status&RT_CONNECTED)
|
|
Disconnect();
|
|
else
|
|
Connect();
|
|
}
|
|
|
|
void TrainSidebar::Connect()
|
|
{
|
|
//qDebug() << "current tab:" << context->tab->currentView();
|
|
|
|
// only try and connect if we are in train view..
|
|
// fixme: these values are hard-coded throughout
|
|
if (!(context->tab->currentView() == 3)) return;
|
|
|
|
if (status&RT_CONNECTED) return; // already connected
|
|
|
|
qDebug() << "connecting..";
|
|
|
|
// if we have selected multiple devices lets
|
|
// configure the series we collect from each one
|
|
if (deviceTree->selectedItems().count() > 1) {
|
|
MultiDeviceDialog *multisetup = new MultiDeviceDialog(context, this);
|
|
if (multisetup->exec() == false) {
|
|
return;
|
|
}
|
|
} else if (deviceTree->selectedItems().count() == 1) {
|
|
bpmTelemetry = wattsTelemetry = kphTelemetry = rpmTelemetry =
|
|
deviceTree->selectedItems().first()->type();
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
activeDevices = devices();
|
|
|
|
foreach(int dev, activeDevices) {
|
|
Devices[dev].controller->setWheelCircumference(Devices[dev].wheelSize);
|
|
Devices[dev].controller->setRollingResistance(bicycle.RollingResistance());
|
|
Devices[dev].controller->setWindResistance(bicycle.WindResistance());
|
|
Devices[dev].controller->setWeight(bicycle.MassKG());
|
|
Devices[dev].controller->setWindSpeed(0); // Move to loadUpdate when wind simulation is added
|
|
|
|
Devices[dev].controller->start();
|
|
Devices[dev].controller->resetCalibrationState();
|
|
connect(Devices[dev].controller, &RealtimeController::setNotification, this, &TrainSidebar::setNotification);
|
|
}
|
|
setStatusFlags(RT_CONNECTED);
|
|
gui_timer->start(REFRESHRATE);
|
|
|
|
emit setNotification(tr("Connected.."), 2);
|
|
}
|
|
|
|
void TrainSidebar::Disconnect()
|
|
{
|
|
// don't try to disconnect if running or not connected
|
|
if ((status&RT_RUNNING) || ((status&RT_CONNECTED) == 0)) return;
|
|
|
|
static QIcon connectedIcon(":images/oxygen/power-on.png");
|
|
static QIcon disconnectedIcon(":images/oxygen/power-off.png");
|
|
|
|
qDebug() << "disconnecting..";
|
|
|
|
foreach(int dev, activeDevices) {
|
|
disconnect(Devices[dev].controller, &RealtimeController::setNotification, this, &TrainSidebar::setNotification);
|
|
Devices[dev].controller->stop();
|
|
}
|
|
clearStatusFlags(RT_CONNECTED);
|
|
|
|
gui_timer->stop();
|
|
|
|
emit setNotification(tr("Disconnected.."), 2);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// SCREEN UPDATE FUNCTIONS
|
|
//----------------------------------------------------------------------
|
|
|
|
void TrainSidebar::guiUpdate() // refreshes the telemetry
|
|
{
|
|
RealtimeData rtData;
|
|
rtData.setLap(displayWorkoutLap);
|
|
rtData.mode = mode;
|
|
|
|
// get latest telemetry from devices
|
|
if ((status&RT_RUNNING) || (status&RT_CONNECTED)) {
|
|
|
|
#ifdef Q_OS_MAC
|
|
// On a Mac prevent the screensaver from kicking in
|
|
// this is apparently the 'supported' mechanism for
|
|
// disabling the screen saver on a Mac instead of
|
|
// temporarily adjusting/disabling the user preferences
|
|
// for screen saving and power management. Makes sense.
|
|
|
|
CFStringRef reasonForActivity = CFSTR("TrainSidebar::guiUpdate");
|
|
IOPMAssertionID assertionID;
|
|
IOReturn suspendSreensaverSuccess = IOPMAssertionCreateWithName(kIOPMAssertionTypeNoDisplaySleep, kIOPMAssertionLevelOn, reasonForActivity, &assertionID);
|
|
|
|
#elif defined(WIN32)
|
|
// Multimedia applications, such as video players and presentation applications, must use ES_DISPLAY_REQUIRED
|
|
// when they display video for long periods of time without user input.
|
|
SetThreadExecutionState(ES_DISPLAY_REQUIRED);
|
|
#endif
|
|
|
|
if(calibrating) {
|
|
foreach(int dev, activeDevices) { // Do for selected device only
|
|
RealtimeData local = rtData;
|
|
|
|
if (calibrationDeviceIndex == dev) {
|
|
// need telemetry for calibration dialog updates
|
|
// (and F3 button press for Computrainer)
|
|
|
|
Devices[dev].controller->getRealtimeData(local);
|
|
calibrationCurrentSpeed = local.getSpeed();
|
|
calibrationTorque = local.getTorque();
|
|
calibrationCadence = local.getCadence();
|
|
|
|
calibrationTargetSpeed = Devices[dev].controller->getCalibrationTargetSpeed();
|
|
|
|
calibrationState = Devices[dev].controller->getCalibrationState();
|
|
|
|
calibrationSpindownTime = Devices[dev].controller->getCalibrationSpindownTime();
|
|
calibrationZeroOffset = Devices[dev].controller->getCalibrationZeroOffset();
|
|
calibrationSlope = Devices[dev].controller->getCalibrationSlope();
|
|
|
|
// if calibration is moving out of pending state..
|
|
if ((calibrationState == CALIBRATION_STATE_PENDING) && startCalibration) {
|
|
startCalibration = false;
|
|
qDebug() << "Sending calibration request..";
|
|
Devices[dev].controller->setCalibrationState(CALIBRATION_STATE_REQUESTED);
|
|
}
|
|
|
|
// if calibration was already requested, but not receiving updates, then try again..
|
|
if ((calibrationState == CALIBRATION_STATE_STARTING) && restartCalibration) {
|
|
restartCalibration = false;
|
|
qDebug() << "No response to our calibration request, re-requesting..";
|
|
Devices[dev].controller->setCalibrationState(CALIBRATION_STATE_REQUESTED);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
// calibration has completed (or failed), toggle out of calibration state
|
|
// - do this outside of dev loop in case of no valid/supported device
|
|
if (finishCalibration) {
|
|
finishCalibration = false;
|
|
Calibrate();
|
|
}
|
|
|
|
// Update the calibration dialog if necessary
|
|
updateCalibration();
|
|
|
|
// and exit. Nothing else to do until we finish calibrating
|
|
return;
|
|
} else {
|
|
rtData.setLoad(load); // always set load..
|
|
rtData.setSlope(slope); // always set load..
|
|
rtData.setAltitude(displayAltitude); // always set display altitude
|
|
|
|
double distanceTick = 0;
|
|
|
|
// fetch the right data from each device...
|
|
foreach(int dev, activeDevices) {
|
|
|
|
RealtimeData local = rtData;
|
|
Devices[dev].controller->getRealtimeData(local);
|
|
|
|
// get spinscan data from a computrainer?
|
|
if (Devices[dev].type == DEV_CT) {
|
|
memcpy((uint8_t*)rtData.spinScan, (uint8_t*)local.spinScan, 24);
|
|
rtData.setLoad(local.getLoad()); // and get load in case it was adjusted
|
|
rtData.setSlope(local.getSlope()); // and get slope in case it was adjusted
|
|
// to within defined limits
|
|
}
|
|
|
|
if (Devices[dev].type == DEV_FORTIUS || Devices[dev].type == DEV_IMAGIC) {
|
|
rtData.setLoad(local.getLoad()); // and get load in case it was adjusted
|
|
rtData.setSlope(local.getSlope()); // and get slope in case it was adjusted
|
|
// to within defined limits
|
|
}
|
|
|
|
if (Devices[dev].type == DEV_ANTLOCAL || Devices[dev].type == DEV_NULL) {
|
|
rtData.setHb(local.getSmO2(), local.gettHb()); //only moxy data from ant and robot devices right now
|
|
}
|
|
|
|
if (Devices[dev].type == DEV_NULL || Devices[dev].type == DEV_BT40) {
|
|
// Only robot and BT40 devices provides VO2 metrics
|
|
rtData.setRf(local.getRf());
|
|
rtData.setRMV(local.getRMV());
|
|
rtData.setVO2_VCO2(local.getVO2(), local.getVCO2());
|
|
rtData.setTv(local.getTv());
|
|
rtData.setFeO2(local.getFeO2());
|
|
}
|
|
|
|
// what are we getting from this one?
|
|
if (dev == bpmTelemetry) rtData.setHr(local.getHr());
|
|
if (dev == rpmTelemetry) rtData.setCadence(local.getCadence());
|
|
if (dev == kphTelemetry) {
|
|
rtData.setSpeed(local.getSpeed());
|
|
rtData.setDistance(local.getDistance());
|
|
rtData.setRouteDistance(local.getRouteDistance());
|
|
rtData.setDistanceRemaining(local.getDistanceRemaining());
|
|
rtData.setLapDistance(local.getLapDistance());
|
|
rtData.setLapDistanceRemaining(local.getLapDistanceRemaining());
|
|
}
|
|
if (dev == wattsTelemetry) {
|
|
rtData.setWatts(local.getWatts());
|
|
rtData.setAltWatts(local.getAltWatts());
|
|
rtData.setLRBalance(local.getLRBalance());
|
|
rtData.setLTE(local.getLTE());
|
|
rtData.setRTE(local.getRTE());
|
|
rtData.setLPS(local.getLPS());
|
|
rtData.setRPS(local.getRPS());
|
|
}
|
|
if (local.getTrainerStatusAvailable())
|
|
{
|
|
rtData.setTrainerStatusAvailable(true);
|
|
rtData.setTrainerReady(local.getTrainerReady());
|
|
rtData.setTrainerRunning(local.getTrainerRunning());
|
|
rtData.setTrainerCalibRequired(local.getTrainerCalibRequired());
|
|
rtData.setTrainerConfigRequired(local.getTrainerConfigRequired());
|
|
rtData.setTrainerBrakeFault(local.getTrainerBrakeFault());
|
|
}
|
|
}
|
|
|
|
// If simulated speed is *not* checked then you get speed reported by
|
|
// trainer which in ergo mode will be dictated by your gear and cadence,
|
|
// and in slope mode is whatever the trainer happens to implement.
|
|
if (useSimulatedSpeed) {
|
|
BicycleSimState newState(rtData);
|
|
SpeedDistance ret = bicycle.SampleSpeed(newState);
|
|
|
|
rtData.setSpeed(ret.v);
|
|
|
|
displaySpeed = ret.v;
|
|
distanceTick = ret.d;
|
|
} else {
|
|
distanceTick = displaySpeed / (5 * 3600); // assumes 200ms refreshrate
|
|
}
|
|
|
|
// only update time & distance if actively running (not just connected, and not running but paused)
|
|
if ((status&RT_RUNNING) && ((status&RT_PAUSED) == 0)) {
|
|
|
|
displayDistance += distanceTick;
|
|
displayLapDistance += distanceTick;
|
|
displayLapDistanceRemaining -= distanceTick;
|
|
displayWorkoutDistance += distanceTick;
|
|
|
|
if (!(status&RT_MODE_ERGO) && (context->currentVideoSyncFile()))
|
|
{
|
|
// If we reached the end of the RLV then stop
|
|
if (displayWorkoutDistance >= context->currentVideoSyncFile()->Distance) {
|
|
Stop(DEVICE_OK);
|
|
return;
|
|
}
|
|
// TODO : graphs to be shown at seek position
|
|
}
|
|
|
|
// If we just tripped over the end of the lap, we need to look at base data
|
|
// to find distance to next lap. This is primarily due to lap display updates
|
|
// -0.999 is chosen as a number that is less than 0, but greater than -1
|
|
if (displayLapDistanceRemaining < 0 && displayLapDistanceRemaining > -0.999) {
|
|
maintainLapDistanceState();
|
|
}
|
|
|
|
rtData.setDistance(displayDistance);
|
|
rtData.setRouteDistance(displayWorkoutDistance);
|
|
rtData.setLapDistance(displayLapDistance);
|
|
rtData.setLapDistanceRemaining(displayLapDistanceRemaining);
|
|
|
|
const ErgFile* ergFile = ergFileQueryAdapter.getErgFile();
|
|
if (ergFile) {
|
|
|
|
// update DistanceRemaining
|
|
if (ergFile->Duration / 1000.0 > displayWorkoutDistance)
|
|
rtData.setDistanceRemaining(ergFile->Duration / 1000.0 - displayWorkoutDistance);
|
|
else
|
|
rtData.setDistanceRemaining(0.0);
|
|
|
|
// If ergfile has no gradient then there is no location, or altitude (or slope.)
|
|
if (ergFile->hasGradient()) {
|
|
bool fAltitudeSet = false;
|
|
if (!ergFile->StrictGradient) {
|
|
// Attempt to obtain location and derived slope from altitude in ergfile.
|
|
geolocation geoloc;
|
|
if (ergFileQueryAdapter.locationAt(displayWorkoutDistance * 1000, displayWorkoutLap, geoloc, slope)) {
|
|
displayLatitude = geoloc.Lat();
|
|
displayLongitude = geoloc.Long();
|
|
displayAltitude = geoloc.Alt();
|
|
|
|
if (displayLatitude && displayLongitude) {
|
|
rtData.setLatitude(displayLatitude);
|
|
rtData.setLongitude(displayLongitude);
|
|
}
|
|
fAltitudeSet = true;
|
|
}
|
|
}
|
|
|
|
if (ergFile->StrictGradient || !fAltitudeSet) {
|
|
slope = ergFileQueryAdapter.gradientAt(displayWorkoutDistance * 1000, displayWorkoutLap);
|
|
}
|
|
|
|
if (!fAltitudeSet) {
|
|
// For classic rlv with no location data:
|
|
// Estimate vertical change based upon time passed and slope.
|
|
// Note this isn't exactly right but is very close - we should use the previous slope for the time passed.
|
|
double altitudeDeltaMeters = slope * (10 * distanceTick); // ((slope / 100) * distanceTick) * 1000
|
|
|
|
displayAltitude += altitudeDeltaMeters;
|
|
}
|
|
|
|
rtData.setSlope(slope);
|
|
rtData.setAltitude(displayAltitude);
|
|
}
|
|
}
|
|
|
|
// time
|
|
total_msecs = session_elapsed_msec + session_time.elapsed();
|
|
lap_msecs = lap_elapsed_msec + lap_time.elapsed();
|
|
|
|
rtData.setMsecs(total_msecs);
|
|
rtData.setLapMsecs(lap_msecs);
|
|
|
|
long lapTimeRemaining;
|
|
if (ergFile) lapTimeRemaining = ergFile->nextLap(load_msecs) - load_msecs;
|
|
else lapTimeRemaining = 0;
|
|
|
|
long ergTimeRemaining;
|
|
if (ergFile) ergTimeRemaining = ergFileQueryAdapter.currentTime() - load_msecs;
|
|
else ergTimeRemaining = 0;
|
|
|
|
double lapPosition = status & RT_MODE_ERGO ? load_msecs : displayWorkoutDistance * 1000;
|
|
|
|
// alert when approaching end of lap
|
|
if (lapAudioEnabled && lapAudioThisLap) {
|
|
|
|
// alert when 3 seconds from end of ERG lap, or 20 meters from end of CRS lap
|
|
bool fPlayAudio = false;
|
|
if (status & RT_MODE_ERGO && lapTimeRemaining > 0 && lapTimeRemaining < 3000) {
|
|
fPlayAudio = true;
|
|
} else {
|
|
double lapmarker = ergFileQueryAdapter.nextLap(lapPosition);
|
|
if (status&RT_MODE_SLOPE && (lapmarker >= 0.) && lapmarker - lapPosition < 20) {
|
|
fPlayAudio = true;
|
|
}
|
|
}
|
|
|
|
if (fPlayAudio) {
|
|
lapAudioThisLap = false;
|
|
QSound::play(":audio/lap.wav");
|
|
}
|
|
}
|
|
|
|
// Text Cues
|
|
if (lapPosition > textPositionEmitted) {
|
|
double searchRange = (status & RT_MODE_ERGO) ? 1000 : 10;
|
|
int rangeStart, rangeEnd;
|
|
if (ergFileQueryAdapter.textsInRange(lapPosition, searchRange, rangeStart, rangeEnd)) {
|
|
for (int idx = rangeStart; idx <= rangeEnd; idx++) {
|
|
ErgFileText cue = ergFile->Texts.at(idx);
|
|
emit setNotification(cue.text, cue.duration);
|
|
}
|
|
}
|
|
textPositionEmitted = lapPosition + searchRange;
|
|
}
|
|
|
|
// Maintain time in ERGO mode
|
|
if (status& RT_MODE_ERGO) {
|
|
if (lapTimeRemaining < 0) {
|
|
if (ergFile) lapTimeRemaining = ergFile->Duration - load_msecs;
|
|
if (lapTimeRemaining < 0)
|
|
lapTimeRemaining = 0;
|
|
}
|
|
rtData.setLapMsecsRemaining(lapTimeRemaining);
|
|
|
|
if (ergTimeRemaining < 0) {
|
|
if (ergFile) ergTimeRemaining = ergFile->Duration - load_msecs;
|
|
if (ergTimeRemaining < 0)
|
|
ergTimeRemaining = 0;
|
|
}
|
|
rtData.setErgMsecsRemaining(ergTimeRemaining);
|
|
}
|
|
} else {
|
|
rtData.setDistance(displayDistance);
|
|
rtData.setRouteDistance(displayWorkoutDistance);
|
|
rtData.setLapDistance(displayLapDistance);
|
|
rtData.setLapDistanceRemaining(displayLapDistanceRemaining);
|
|
rtData.setMsecs(session_elapsed_msec);
|
|
rtData.setLapMsecs(lap_elapsed_msec);
|
|
}
|
|
|
|
// local stuff ...
|
|
displayPower = rtData.getWatts();
|
|
displayCadence = rtData.getCadence();
|
|
displayHeartRate = rtData.getHr();
|
|
displaySpeed = rtData.getSpeed();
|
|
load = rtData.getLoad();
|
|
slope = rtData.getSlope();
|
|
displayLRBalance = rtData.getLRBalance();
|
|
displayLTE = rtData.getLTE();
|
|
displayRTE = rtData.getRTE();
|
|
displayLPS = rtData.getLPS();
|
|
displayRPS = rtData.getRPS();
|
|
displaySMO2 = rtData.getSmO2();
|
|
displayTHB = rtData.gettHb();
|
|
displayO2HB = rtData.getO2Hb();
|
|
displayHHB = rtData.getHHb();
|
|
displayLatitude = rtData.getLatitude();
|
|
displayLongitude = rtData.getLongitude();
|
|
displayAltitude = rtData.getAltitude();
|
|
|
|
double weightKG = context->athlete->getWeight(QDate::currentDate()) + 10; // 10kg bike
|
|
double vs = computeInstantSpeed(weightKG, rtData.getSlope(), rtData.getAltitude(), rtData.getWatts());
|
|
|
|
rtData.setVirtualSpeed(vs);
|
|
|
|
// W'bal on the fly
|
|
// using Dave Waterworth's reformulation
|
|
double TAU = appsettings->cvalue(context->athlete->cyclist, GC_WBALTAU, 300).toInt();
|
|
|
|
// any watts expended in last 200msec?
|
|
double JOULES = double(rtData.getWatts() - FTP) / 5.00f;
|
|
if (JOULES < 0) JOULES = 0;
|
|
|
|
// running total of replenishment
|
|
wbalr += JOULES * exp((total_msecs/1000.00f) / TAU);
|
|
wbal = WPRIME - (wbalr * exp((-total_msecs/1000.00f) / TAU));
|
|
|
|
rtData.setWbal(wbal);
|
|
|
|
// go update the displays...
|
|
context->notifyTelemetryUpdate(rtData); // signal everyone to update telemetry
|
|
}
|
|
|
|
#ifdef Q_OS_MAC
|
|
if (suspendSreensaverSuccess == kIOReturnSuccess)
|
|
{
|
|
// Re-enable screen saver
|
|
suspendSreensaverSuccess = IOPMAssertionRelease(assertionID);
|
|
//The system will be able to sleep again.
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
// can be called from the controller - when user presses "Lap" button
|
|
void TrainSidebar::newLap()
|
|
{
|
|
qDebug() << "running:" << (status&RT_RUNNING) << "paused:" << (status&RT_PAUSED);
|
|
|
|
if ((status&RT_RUNNING) && ((status&RT_PAUSED) == 0)) {
|
|
|
|
pwrcount = 0;
|
|
cadcount = 0;
|
|
hrcount = 0;
|
|
spdcount = 0;
|
|
|
|
ergFileQueryAdapter.addNewLap(displayWorkoutDistance * 1000.);
|
|
|
|
resetTextAudioEmitTracking();
|
|
maintainLapDistanceState();
|
|
|
|
context->notifyNewLap();
|
|
|
|
emit setNotification(tr("New lap.."), 2);
|
|
}
|
|
}
|
|
|
|
void TrainSidebar::resetLapTimer()
|
|
{
|
|
lap_time.restart();
|
|
lap_elapsed_msec = 0;
|
|
displayLapDistance = 0;
|
|
this->resetTextAudioEmitTracking();
|
|
this->maintainLapDistanceState();
|
|
}
|
|
|
|
void TrainSidebar::resetTextAudioEmitTracking()
|
|
{
|
|
lapAudioThisLap = true;
|
|
textPositionEmitted = -1;
|
|
}
|
|
|
|
// Can be called from the controller - when user steers to scroll display
|
|
void TrainSidebar::steerScroll(int scrollAmount)
|
|
{
|
|
if (scrollAmount == 0)
|
|
emit setNotification(tr("Recalibrating steering.."), 10);
|
|
else
|
|
context->notifySteerScroll(scrollAmount);
|
|
}
|
|
|
|
void TrainSidebar::warnnoConfig()
|
|
{
|
|
QMessageBox::warning(this, tr("No Devices Configured"), tr("Please configure a device in Preferences."));
|
|
}
|
|
|
|
template<class T, typename T_GetMethod, typename T_SetMethod, typename T_arg>
|
|
struct ScopedOp
|
|
{
|
|
T* m_pt;
|
|
T_SetMethod m_setMethod;
|
|
T_arg m_argSave;
|
|
|
|
ScopedOp(T* pt, T_GetMethod getMethod, T_SetMethod setMethod, T_arg argNew) : m_pt(pt), m_setMethod(setMethod) {
|
|
m_argSave = (m_pt->*getMethod)();
|
|
(m_pt->*m_setMethod)(argNew);
|
|
}
|
|
|
|
virtual ~ScopedOp() { (m_pt->*m_setMethod)(m_argSave); }
|
|
};
|
|
|
|
struct ScopedPrecision : ScopedOp<QTextStream, int (QTextStream::*)() const, void (QTextStream::*)(int), int> {
|
|
ScopedPrecision(QTextStream* pc, int tempPrecision) : ScopedOp::ScopedOp(pc, &QTextStream::realNumberPrecision, &QTextStream::setRealNumberPrecision, tempPrecision) {}
|
|
};
|
|
|
|
//----------------------------------------------------------------------
|
|
// DISK UPDATE FUNCTIONS
|
|
//----------------------------------------------------------------------
|
|
void TrainSidebar::diskUpdate()
|
|
{
|
|
int secs;
|
|
|
|
long torq = 0;
|
|
QTextStream recordFileStream(recordFile);
|
|
|
|
if (calibrating) return;
|
|
|
|
// convert from milliseconds to secondes
|
|
total_msecs = session_elapsed_msec + session_time.elapsed();
|
|
secs = round(total_msecs / 1000.0);
|
|
|
|
if (secs <= lastRecordSecs) return; // Avoid duplicates
|
|
lastRecordSecs = secs;
|
|
|
|
// GoldenCheetah CVS Format "secs, cad, hr, km, kph, nm, watts, alt, lon, lat, headwind, slope, temp, interval, lrbalance, lte, rte, lps, rps, smo2, thb, o2hb, hhb\n";
|
|
|
|
recordFileStream << secs
|
|
<< "," << displayCadence
|
|
<< "," << displayHeartRate
|
|
<< "," << displayDistance
|
|
<< "," << displaySpeed
|
|
<< "," << torq
|
|
<< "," << displayPower;
|
|
|
|
// QTextStream default precision is 6, location data needs much more than that.
|
|
// Avoid extra precision for other fields since it isn't needed and would grow
|
|
// the intermediate file for no reason.
|
|
{
|
|
ScopedPrecision tempPrecision(&recordFileStream, 20);
|
|
|
|
recordFileStream << "," << displayAltitude
|
|
<< "," << displayLongitude
|
|
<< "," << displayLatitude;
|
|
}
|
|
|
|
recordFileStream << "," // headwind
|
|
<< "," // slope
|
|
<< "," // temp
|
|
<< "," << displayWorkoutLap
|
|
<< "," << displayLRBalance
|
|
<< "," << displayLTE
|
|
<< "," << displayRTE
|
|
<< "," << displayLPS
|
|
<< "," << displayRPS
|
|
<< "," << displaySMO2
|
|
<< "," << displayTHB
|
|
<< "," << displayO2HB
|
|
<< "," << displayHHB
|
|
<< "," << load
|
|
<< "," << "\n";
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// WORKOUT MODE
|
|
//----------------------------------------------------------------------
|
|
|
|
void TrainSidebar::loadUpdate()
|
|
{
|
|
int curLap = 0;
|
|
|
|
// we hold our horses whilst calibration is taking place...
|
|
if (calibrating) return;
|
|
|
|
// the period between loadUpdate calls is not constant, and not exactly LOADRATE,
|
|
// therefore, use a QTime timer to measure the load period
|
|
load_msecs += load_period.restart();
|
|
|
|
if (status&RT_MODE_ERGO) {
|
|
if (context->currentErgFile()) {
|
|
load = ergFileQueryAdapter.wattsAt(load_msecs, curLap);
|
|
|
|
if (displayWorkoutLap != curLap)
|
|
{
|
|
context->notifyNewLap();
|
|
maintainLapDistanceState();
|
|
}
|
|
displayWorkoutLap = curLap;
|
|
}
|
|
|
|
// we got to the end!
|
|
if (load == -100) {
|
|
Stop(DEVICE_OK);
|
|
} else {
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setLoad(load);
|
|
context->notifySetNow(load_msecs);
|
|
}
|
|
} else {
|
|
if (context->currentErgFile()) {
|
|
// Call gradientAt to obtain current lap num.
|
|
ergFileQueryAdapter.gradientAt(displayWorkoutDistance * 1000., curLap);
|
|
|
|
if (displayWorkoutLap != curLap) {
|
|
context->notifyNewLap();
|
|
maintainLapDistanceState();
|
|
}
|
|
|
|
displayWorkoutLap = curLap;
|
|
}
|
|
|
|
// we got to the end!
|
|
if (slope == -100) {
|
|
Stop(DEVICE_OK);
|
|
} else {
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setGradient(slope);
|
|
context->notifySetNow(displayWorkoutDistance * 1000);
|
|
}
|
|
}
|
|
}
|
|
|
|
void TrainSidebar::Calibrate()
|
|
{
|
|
// Check we're running (and not paused) before attempting
|
|
// calibration, buttons should be disabled to prevent this,
|
|
// but could be triggered by remote control..
|
|
if ((status & RT_RUNNING) && ((status&RT_PAUSED) == 0)) {
|
|
toggleCalibration();
|
|
updateCalibration();
|
|
}
|
|
}
|
|
|
|
void TrainSidebar::toggleCalibration()
|
|
{
|
|
if (calibrating) {
|
|
|
|
// exiting calibration - restart gui etc
|
|
session_time.start();
|
|
lap_time.start();
|
|
load_period.restart();
|
|
|
|
clearStatusFlags(RT_CALIBRATING);
|
|
load_timer->start(LOADRATE);
|
|
if (status & RT_RECORDING) disk_timer->start(SAMPLERATE);
|
|
context->notifyUnPause(); // get video started again, amongst other things
|
|
|
|
// back to ergo/slope mode and restore load/gradient
|
|
if (status&RT_MODE_ERGO) {
|
|
|
|
foreach(int dev, activeDevices) {
|
|
if (calibrationDeviceIndex == dev) {
|
|
Devices[dev].controller->setCalibrationState(CALIBRATION_STATE_IDLE);
|
|
Devices[dev].controller->setMode(RT_MODE_ERGO);
|
|
Devices[dev].controller->setLoad(load);
|
|
}
|
|
}
|
|
} else {
|
|
|
|
foreach(int dev, activeDevices) {
|
|
if (calibrationDeviceIndex == dev) {
|
|
Devices[dev].controller->setCalibrationState(CALIBRATION_STATE_IDLE);
|
|
Devices[dev].controller->setMode(RT_MODE_SPIN);
|
|
Devices[dev].controller->setGradient(slope);
|
|
}
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
// entering calibration - pause gui/load, streaming and recording
|
|
// but keep the gui ticking so we get realtime telemetry for calibration
|
|
session_elapsed_msec += session_time.elapsed();
|
|
lap_elapsed_msec += lap_time.elapsed();
|
|
|
|
setStatusFlags(RT_CALIBRATING);
|
|
if (status & RT_RECORDING) disk_timer->stop();
|
|
load_timer->stop();
|
|
load_msecs += load_period.restart();
|
|
|
|
context->notifyPause(); // get video started again, amongst other things
|
|
|
|
calibrationDeviceIndex = getCalibrationIndex();
|
|
|
|
// only do this for the selected device
|
|
foreach(int dev, devices()) {
|
|
if (calibrationDeviceIndex == dev) {
|
|
calibrationType = Devices[dev].controller->getCalibrationType();
|
|
|
|
// trainer (tacx vortex smart) doesn't appear to reduce resistance automatically when entering calibration mode
|
|
if (status&RT_MODE_ERGO)
|
|
Devices[dev].controller->setLoad(0);
|
|
else
|
|
Devices[dev].controller->setGradient(0);
|
|
|
|
|
|
Devices[dev].controller->setMode(RT_MODE_CALIBRATE);
|
|
Devices[dev].controller->setCalibrationState(CALIBRATION_STATE_PENDING);
|
|
}
|
|
}
|
|
|
|
if (calibrationDeviceIndex == -1)
|
|
qDebug() << "No device(s) found with calibration support";
|
|
else
|
|
qDebug() << "Device" << calibrationDeviceIndex << "being used for calibration";
|
|
}
|
|
|
|
startCalibration = restartCalibration = finishCalibration = false;
|
|
calibrating = !calibrating; // toggle calibration
|
|
}
|
|
|
|
void TrainSidebar::updateCalibration()
|
|
{
|
|
static QString status;
|
|
static uint8_t lastState, stateCount;
|
|
|
|
//qDebug() << "TrainSidebar::updateCalibration()" << calibrating << calibrationState << stateCount;
|
|
|
|
if (!calibrating) {
|
|
|
|
stateCount = 1;
|
|
|
|
// leaving calibration, clear any notification text
|
|
status = QString(tr("Exiting calibration.."));
|
|
emit setNotification(status,3);
|
|
|
|
} else {
|
|
|
|
// Track how long we've been in the same state
|
|
if (calibrationState == lastState)
|
|
stateCount++;
|
|
else
|
|
stateCount = 1;
|
|
|
|
// update message depending on calibration type and state
|
|
switch (calibrationType) {
|
|
|
|
case CALIBRATION_TYPE_NOT_SUPPORTED:
|
|
status = QString(tr("Calibration not supported for this device."));
|
|
if ((stateCount % 10) == 0) {
|
|
finishCalibration = true;
|
|
}
|
|
break;
|
|
|
|
case CALIBRATION_TYPE_COMPUTRAINER:
|
|
status = QString(tr("Calibrating...\nPress F3 on Controller when done."));
|
|
break;
|
|
|
|
case CALIBRATION_TYPE_SPINDOWN:
|
|
|
|
switch (calibrationState) {
|
|
|
|
case CALIBRATION_STATE_IDLE:
|
|
break;
|
|
|
|
case CALIBRATION_STATE_PENDING:
|
|
// Can go straight into spindown calibration
|
|
startCalibration = true;
|
|
break;
|
|
|
|
case CALIBRATION_STATE_REQUESTED:
|
|
status = QString(tr("Requesting calibration.."));
|
|
break;
|
|
|
|
case CALIBRATION_STATE_STARTING:
|
|
status = QString(tr("Requesting calibration.."));
|
|
// if just spinning here, the device has not responded to calibration request
|
|
if ((stateCount % 5) == 0)
|
|
restartCalibration = true;
|
|
break;
|
|
|
|
case CALIBRATION_STATE_STARTED:
|
|
status = QString(tr("Calibrating..."));
|
|
break;
|
|
|
|
case CALIBRATION_STATE_POWER:
|
|
status = QString(tr("Calibrating...\nCurrent speed %1 kph\nIncrease speed to %2 kph")).arg(QString::number(calibrationCurrentSpeed, 'f', 1), QString::number(calibrationTargetSpeed, 'f', 1));
|
|
break;
|
|
|
|
case CALIBRATION_STATE_COAST:
|
|
status = QString(tr("Calibrating...\nStop pedalling until speed drops to 0"));
|
|
break;
|
|
|
|
case CALIBRATION_STATE_SUCCESS:
|
|
// display zero offset and spindown stats
|
|
status = QString(tr("Calibration completed successfully!\nSpindown %1 ms\nZero Offset %2")).arg(QString::number(calibrationSpindownTime), QString::number(calibrationZeroOffset));;
|
|
|
|
// No further ANT messages to set state, so must move ourselves on..
|
|
if ((stateCount % 25) == 0)
|
|
finishCalibration = true;
|
|
break;
|
|
|
|
case CALIBRATION_STATE_FAILURE:
|
|
status = QString(tr("Calibration failed!"));
|
|
|
|
// No further ANT messages to set state, so must move ourselves on..
|
|
if ((stateCount % 25) == 0)
|
|
finishCalibration = true;
|
|
break;
|
|
|
|
case CALIBRATION_STATE_FAILURE_SPINDOWN_TOO_FAST:
|
|
status = QString(tr("Calibration Failed: Loosen Roller"));
|
|
|
|
// No further ANT messages to set state, so must move ourselves on..
|
|
if ((stateCount % 25) == 0)
|
|
finishCalibration = true;
|
|
break;
|
|
|
|
case CALIBRATION_STATE_FAILURE_SPINDOWN_TOO_SLOW:
|
|
status = QString(tr("Calibration Failed: Tighten Roller"));
|
|
|
|
// No further ANT messages to set state, so must move ourselves on..
|
|
if ((stateCount % 25) == 0)
|
|
finishCalibration = true;
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
case CALIBRATION_TYPE_ZERO_OFFSET:
|
|
|
|
switch (calibrationState) {
|
|
|
|
case CALIBRATION_STATE_IDLE:
|
|
break;
|
|
|
|
case CALIBRATION_STATE_PENDING:
|
|
// Wait for cadence to be zero before requesting zero offset calibration
|
|
status = QString(tr("Unclip or stop pedalling to begin calibration.."));
|
|
if (calibrationCadence == 0)
|
|
startCalibration = true;
|
|
break;
|
|
|
|
case CALIBRATION_STATE_REQUESTED:
|
|
status = QString(tr("Requesting calibration.."));
|
|
break;
|
|
|
|
case CALIBRATION_STATE_STARTING:
|
|
break;
|
|
|
|
case CALIBRATION_STATE_STARTED:
|
|
break;
|
|
|
|
case CALIBRATION_STATE_POWER:
|
|
break;
|
|
|
|
case CALIBRATION_STATE_COAST:
|
|
status = QString(tr("Calibrating...\nUnclip or stop pedalling until process is completed..\nTorque %1")).arg(QString::number(calibrationTorque, 'f', 3));
|
|
break;
|
|
|
|
case CALIBRATION_STATE_SUCCESS:
|
|
// yuk, zero offset for FE-C devices is unsigned, but for power meters is signed..
|
|
status = QString(tr("Calibration completed successfully!\nZero Offset %1\nTorque %2")).arg(QString::number((int16_t)calibrationZeroOffset), QString::number(calibrationTorque, 'f', 3));;
|
|
|
|
// No further ANT messages to set state, so must move ourselves on..
|
|
if ((stateCount % 25) == 0)
|
|
finishCalibration = true;
|
|
break;
|
|
|
|
case CALIBRATION_STATE_FAILURE:
|
|
status = QString(tr("Calibration failed!"));
|
|
|
|
// No further ANT messages to set state, so must move ourselves on..
|
|
if ((stateCount % 25) == 0)
|
|
finishCalibration = true;
|
|
break;
|
|
|
|
}
|
|
break;
|
|
|
|
case CALIBRATION_TYPE_ZERO_OFFSET_SRM:
|
|
|
|
switch (calibrationState) {
|
|
|
|
case CALIBRATION_STATE_IDLE:
|
|
break;
|
|
|
|
case CALIBRATION_STATE_PENDING:
|
|
// Wait for cadence to be zero before requesting zero offset calibration
|
|
status = QString(tr("Unclip or stop pedalling to begin calibration.."));
|
|
if (calibrationCadence == 0)
|
|
startCalibration = true;
|
|
break;
|
|
|
|
case CALIBRATION_STATE_REQUESTED:
|
|
status = QString(tr("Requesting calibration.."));
|
|
break;
|
|
|
|
case CALIBRATION_STATE_STARTING:
|
|
status = QString(tr("Requesting calibration.."));
|
|
break;
|
|
|
|
case CALIBRATION_STATE_STARTED:
|
|
break;
|
|
|
|
case CALIBRATION_STATE_POWER:
|
|
break;
|
|
|
|
case CALIBRATION_STATE_COAST:
|
|
status = QString(tr("Calibrating...\nUnclip or stop pedalling until process is completed..\nZero Offset %1")).arg(QString::number((int16_t)calibrationZeroOffset));
|
|
break;
|
|
|
|
case CALIBRATION_STATE_SUCCESS:
|
|
// yuk, zero offset for FE-C devices is unsigned, but for power meters is signed..
|
|
status = QString(tr("Calibration completed successfully!\nZero Offset %1\nSlope %2")).arg(QString::number((int16_t)calibrationZeroOffset), QString::number(calibrationSlope));;
|
|
|
|
// No further ANT messages to set state, so must move ourselves on..
|
|
if ((stateCount % 25) == 0)
|
|
finishCalibration = true;
|
|
break;
|
|
|
|
case CALIBRATION_STATE_FAILURE:
|
|
status = QString(tr("Calibration failed!"));
|
|
|
|
// No further ANT messages to set state, so must move ourselves on..
|
|
if ((stateCount % 25) == 0)
|
|
finishCalibration = true;
|
|
break;
|
|
|
|
}
|
|
break;
|
|
|
|
case CALIBRATION_TYPE_FORTIUS:
|
|
|
|
switch (calibrationState) {
|
|
|
|
case CALIBRATION_STATE_IDLE:
|
|
case CALIBRATION_STATE_PENDING:
|
|
break;
|
|
|
|
case CALIBRATION_STATE_REQUESTED:
|
|
status = QString(tr("Give the pedal a kick to start calibration...\nThe motor will run until calibration is complete."));
|
|
break;
|
|
|
|
case CALIBRATION_STATE_STARTING:
|
|
status = QString(tr("Calibrating... DO NOT PEDAL, remain seated...\nGathering enough samples to calculate average: %1"))
|
|
.arg(QString::number((int16_t)calibrationZeroOffset));
|
|
break;
|
|
|
|
case CALIBRATION_STATE_STARTED:
|
|
{
|
|
const double calibrationPower_W = Fortius::rawForce_to_N(calibrationZeroOffset) * Fortius::kph_to_ms(calibrationTargetSpeed);
|
|
status = QString(tr("Calibrating... DO NOT PEDAL, remain seated...\nWaiting for value to stabilize (max %1s): %2 (%3W @ %4kph)"))
|
|
.arg(QString::number((int16_t)FortiusController::calibrationDurationLimit_s),
|
|
QString::number((int16_t)calibrationZeroOffset),
|
|
QString::number((int16_t)calibrationPower_W),
|
|
QString::number((int16_t)calibrationTargetSpeed));
|
|
}
|
|
break;
|
|
|
|
case CALIBRATION_STATE_POWER:
|
|
case CALIBRATION_STATE_COAST:
|
|
break;
|
|
|
|
case CALIBRATION_STATE_SUCCESS:
|
|
{
|
|
const double calibrationPower_W = Fortius::rawForce_to_N(calibrationZeroOffset) * Fortius::kph_to_ms(calibrationTargetSpeed);
|
|
status = QString(tr("Calibration completed successfully!\nFinal calibration value %1 (%2W @ %3kph)"))
|
|
.arg(QString::number((int16_t)calibrationZeroOffset),
|
|
QString::number((int16_t)calibrationPower_W),
|
|
QString::number((int16_t)calibrationTargetSpeed));
|
|
|
|
// No further ANT messages to set state, so must move ourselves on..
|
|
if ((stateCount % 25) == 0)
|
|
finishCalibration = true;
|
|
}
|
|
break;
|
|
|
|
case CALIBRATION_STATE_FAILURE:
|
|
status = QString(tr("Calibration failed! Do not pedal while calibration is taking place.\nAllow wheel to run freely."));
|
|
|
|
// No further ANT messages to set state, so must move ourselves on..
|
|
if ((stateCount % 25) == 0)
|
|
finishCalibration = true;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
lastState = calibrationState;
|
|
|
|
// set notification text, no timeout
|
|
emit setNotification(status, 0);
|
|
}
|
|
}
|
|
|
|
void TrainSidebar::FFwd()
|
|
{
|
|
if (((status&RT_RUNNING) == 0) || (status&RT_PAUSED)) return;
|
|
|
|
if (status&RT_MODE_ERGO) {
|
|
// In ergo mode seek is of time.
|
|
load_msecs += 10000; // jump forward 10 seconds
|
|
context->notifySeek(load_msecs);
|
|
}
|
|
else {
|
|
// Otherwise Seek is of Distance.
|
|
double stepSize = 1.; // jump forward a kilometer in the workout
|
|
if (context->currentVideoSyncFile()) {
|
|
// If step would take us past the end then step to end.
|
|
double videoDistance = context->currentVideoSyncFile()->Distance;
|
|
if ((displayWorkoutDistance + stepSize) > videoDistance) {
|
|
stepSize = videoDistance - displayWorkoutDistance;
|
|
}
|
|
context->notifySeek(stepSize); // in case of video with RLV file synchronisation just ask to go forward
|
|
}
|
|
displayWorkoutDistance += stepSize;
|
|
}
|
|
|
|
resetTextAudioEmitTracking();
|
|
|
|
maintainLapDistanceState();
|
|
|
|
emit setNotification(tr("Fast forward.."), 2);
|
|
}
|
|
|
|
void TrainSidebar::Rewind()
|
|
{
|
|
if (((status&RT_RUNNING) == 0) || (status&RT_PAUSED)) return;
|
|
|
|
if (status&RT_MODE_ERGO) {
|
|
// In ergo mode seek is of time.
|
|
load_msecs -=10000; // jump back 10 seconds
|
|
if (load_msecs < 0) load_msecs = 0;
|
|
context->notifySeek(load_msecs);
|
|
}
|
|
else {
|
|
// Otherwise Seek is of distance.
|
|
double stepSize = -1.; // jump back a kilometer
|
|
|
|
// If step would take us before the start then step to the start.
|
|
if ((displayWorkoutDistance + stepSize) < 0) {
|
|
stepSize = -displayWorkoutDistance;
|
|
}
|
|
|
|
if (context->currentVideoSyncFile()) {
|
|
context->notifySeek(stepSize);
|
|
}
|
|
|
|
displayWorkoutDistance += stepSize;
|
|
}
|
|
|
|
resetTextAudioEmitTracking();
|
|
|
|
maintainLapDistanceState();
|
|
|
|
emit setNotification(tr("Rewind.."), 2);
|
|
}
|
|
|
|
|
|
// jump to next Lap marker (if there is one?)
|
|
void TrainSidebar::FFwdLap()
|
|
{
|
|
if (((status&RT_RUNNING) == 0) || (status&RT_PAUSED)) return;
|
|
|
|
double lapmarker;
|
|
|
|
if (status&RT_MODE_ERGO) {
|
|
lapmarker = ergFileQueryAdapter.nextLap(load_msecs);
|
|
if (lapmarker >= 0.) load_msecs = lapmarker; // jump forward to lapmarker
|
|
context->notifySeek(load_msecs);
|
|
} else {
|
|
static const double s_BeforeOffset = 10.1;
|
|
lapmarker = ergFileQueryAdapter.nextLap((displayWorkoutDistance*1000) + s_BeforeOffset);
|
|
if (lapmarker >= 0) {
|
|
// Go to slightly before lap marker so the lap transition message will be displayed.
|
|
lapmarker = std::max(0., lapmarker - s_BeforeOffset);
|
|
|
|
displayWorkoutDistance = lapmarker / 1000; // jump forward to lapmarker
|
|
}
|
|
}
|
|
|
|
resetTextAudioEmitTracking();
|
|
|
|
maintainLapDistanceState();
|
|
|
|
if (lapmarker >= 0) emit setNotification(tr("Next Lap.."), 2);
|
|
}
|
|
|
|
// jump to next Lap marker (if there is one?)
|
|
void TrainSidebar::RewindLap()
|
|
{
|
|
if (((status & RT_RUNNING) == 0) || (status & RT_PAUSED)) return;
|
|
|
|
double lapmarker;
|
|
|
|
if (status & RT_MODE_ERGO) {
|
|
// Search for lap prior to 1 second ago.
|
|
long target = std::max<long>(0, load_msecs - 1000);
|
|
lapmarker = ergFileQueryAdapter.prevLap(target);
|
|
if (lapmarker >= 0.) load_msecs = lapmarker; // jump to lapmarker
|
|
context->notifySeek(load_msecs);
|
|
}
|
|
else {
|
|
// Search for lap prior to 50 meters ago.
|
|
double target = std::max(0., (displayWorkoutDistance * 1000) - 50.);
|
|
|
|
lapmarker = ergFileQueryAdapter.prevLap(target);
|
|
|
|
// Go to slightly before lap marker so the lap transition message will be displayed.
|
|
lapmarker = std::max(0., lapmarker - 10.1);
|
|
|
|
if (lapmarker >= 0.) displayWorkoutDistance = lapmarker / 1000; // jump to lapmarker
|
|
}
|
|
|
|
resetTextAudioEmitTracking();
|
|
|
|
maintainLapDistanceState();
|
|
|
|
if (lapmarker >= 0) emit setNotification(tr("Back Lap.."), 2);
|
|
}
|
|
|
|
|
|
// higher load/gradient
|
|
void TrainSidebar::Higher()
|
|
{
|
|
if ((status&RT_CONNECTED) == 0) return;
|
|
|
|
if (context->currentErgFile()) {
|
|
// adjust the workout IF
|
|
adjustIntensity(lastAppliedIntensity+5);
|
|
|
|
} else {
|
|
if (status&RT_MODE_ERGO) load += 5;
|
|
else slope += 0.1;
|
|
|
|
if (load >1500) load = 1500;
|
|
if (slope >40) slope = 40;
|
|
|
|
if (status&RT_MODE_ERGO)
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setLoad(load);
|
|
else
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setGradient(slope);
|
|
}
|
|
|
|
emit setNotification(tr("Increasing intensity.."), 2);
|
|
}
|
|
|
|
// lower load/gradient
|
|
void TrainSidebar::Lower()
|
|
{
|
|
if ((status&RT_CONNECTED) == 0) return;
|
|
|
|
if (context->currentErgFile()) {
|
|
// adjust the workout IF
|
|
adjustIntensity(std::max<int>(5, lastAppliedIntensity - 5));
|
|
|
|
} else {
|
|
|
|
if (status&RT_MODE_ERGO) load -= 5;
|
|
else slope -= 0.1;
|
|
|
|
if (load <0) load = 0;
|
|
if (slope <-40) slope = -40;
|
|
|
|
if (status&RT_MODE_ERGO)
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setLoad(load);
|
|
else
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setGradient(slope);
|
|
}
|
|
|
|
emit setNotification(tr("Decreasing intensity.."), 2);
|
|
}
|
|
|
|
void TrainSidebar::setLabels()
|
|
{
|
|
/* should this be kept, or removed? Currently these are always hidden.
|
|
if (context->currentErgFile()) {
|
|
|
|
if (context->currentErgFile()->format == CRS) {
|
|
|
|
stress->setText(QString("Elevation %1").arg(context->currentErgFile()->ELE, 0, 'f', 0));
|
|
intensity->setText(QString("Grade %1 %").arg(context->currentErgFile()->GRADE, 0, 'f', 1));
|
|
|
|
} else {
|
|
|
|
stress->setText(QString("BikeStress %1").arg(context->currentErgFile()->BikeStress, 0, 'f', 0));
|
|
intensity->setText(QString("IF %1").arg(context->currentErgFile()->IF, 0, 'f', 3));
|
|
}
|
|
|
|
} else {
|
|
stress->setText("");
|
|
intensity->setText("");
|
|
}
|
|
*/
|
|
}
|
|
|
|
void TrainSidebar::adjustIntensity(int value)
|
|
{
|
|
if (value == lastAppliedIntensity) {
|
|
return;
|
|
}
|
|
|
|
ErgFile* ergFile = const_cast<ErgFile*>(ergFileQueryAdapter.getErgFile());
|
|
if (!ergFile) return; // no workout selected
|
|
|
|
// block signals temporarily
|
|
context->mainWindow->blockSignals(true);
|
|
|
|
// work through the ergFile from NOW
|
|
// adjusting back from last setting
|
|
// and increasing to new intensity setting
|
|
|
|
double from = double(lastAppliedIntensity) / 100.00;
|
|
double to = double(value) / 100.00;
|
|
|
|
lastAppliedIntensity = value;
|
|
|
|
long starttime = context->getNow();
|
|
|
|
bool insertedNow = context->getNow() ? false : true; // don't add if at start
|
|
|
|
// what about gradient courses?
|
|
ErgFilePoint last;
|
|
for(int i = 0; i < ergFile->Points.count(); i++) {
|
|
|
|
if (ergFile->Points.at(i).x >= starttime) {
|
|
|
|
if (insertedNow == false) {
|
|
|
|
if (i) {
|
|
// add a point to adjust from
|
|
|
|
// This pass simply modifies load or gradient.
|
|
// Start with copy of 'last', then overwrite only the part we wish to change,
|
|
// this is necessary so crs point will start with an intact location and not
|
|
// zeros.
|
|
ErgFilePoint add = last;
|
|
add.x = context->getNow();
|
|
add.val = last.val / from * to;
|
|
|
|
// recalibrate altitude if gradient changing
|
|
if (ergFile->format == CRS) add.y = last.y + ((add.x-last.x) * (add.val/100));
|
|
else add.y = add.val;
|
|
|
|
ergFile->Points.insert(i, add);
|
|
|
|
last = add;
|
|
i++; // move on to next point (i.e. where we were!)
|
|
}
|
|
insertedNow = true;
|
|
}
|
|
|
|
ErgFilePoint *p = &ergFile->Points[i];
|
|
|
|
// recalibrate altitude if in CRS mode
|
|
p->val = p->val / from * to;
|
|
if (ergFile->format == CRS) {
|
|
if (i) p->y = last.y + ((p->x-last.x) * (last.val/100));
|
|
}
|
|
else p->y = p->val;
|
|
}
|
|
|
|
// remember last
|
|
last = ergFile->Points.at(i);
|
|
}
|
|
|
|
// recalculate metrics
|
|
ergFile->calculateMetrics();
|
|
setLabels();
|
|
|
|
// Ergfile points have been edited so reset interpolation and
|
|
// query state.
|
|
ergFileQueryAdapter.resetQueryState();
|
|
|
|
// unblock signals now we are done
|
|
context->mainWindow->blockSignals(false);
|
|
|
|
// force replot
|
|
context->notifySetNow(context->getNow());
|
|
|
|
emit intensityChanged(lastAppliedIntensity);
|
|
}
|
|
|
|
MultiDeviceDialog::MultiDeviceDialog(Context *, TrainSidebar *traintool) : traintool(traintool)
|
|
{
|
|
setAttribute(Qt::WA_DeleteOnClose);
|
|
setWindowFlags(windowFlags() | Qt::WindowStaysOnTopHint);
|
|
setWindowTitle(tr("Multiple Device Configuration"));
|
|
|
|
QVBoxLayout *main = new QVBoxLayout(this);
|
|
QFormLayout *mainLayout = new QFormLayout;
|
|
main->addLayout(mainLayout);
|
|
|
|
bpmSelect = new QComboBox(this);
|
|
mainLayout->addRow(new QLabel("Heartrate", this), bpmSelect);
|
|
|
|
wattsSelect = new QComboBox(this);
|
|
mainLayout->addRow(new QLabel("Power", this), wattsSelect);
|
|
|
|
rpmSelect = new QComboBox(this);
|
|
mainLayout->addRow(new QLabel("Cadence", this), rpmSelect);
|
|
|
|
kphSelect = new QComboBox(this);
|
|
mainLayout->addRow(new QLabel("Speed", this), kphSelect);
|
|
|
|
// update the device selections for the drop downs
|
|
foreach(QTreeWidgetItem *selected, traintool->deviceTree->selectedItems()) {
|
|
if (selected->type() == HEAD_TYPE) continue;
|
|
|
|
bpmSelect->addItem(selected->text(0), selected->type());
|
|
wattsSelect->addItem(selected->text(0), selected->type());
|
|
rpmSelect->addItem(selected->text(0), selected->type());
|
|
kphSelect->addItem(selected->text(0), selected->type());
|
|
}
|
|
|
|
bpmSelect->addItem("None", -1);
|
|
wattsSelect->addItem("None", -1);
|
|
rpmSelect->addItem("None", -1);
|
|
kphSelect->addItem("None", -1);
|
|
|
|
// set to the current values (if set)
|
|
if (traintool->bpmTelemetry != -1) {
|
|
int index = bpmSelect->findData(traintool->bpmTelemetry);
|
|
if (index >=0) bpmSelect->setCurrentIndex(index);
|
|
}
|
|
if (traintool->wattsTelemetry != -1) {
|
|
int index = wattsSelect->findData(traintool->wattsTelemetry);
|
|
if (index >=0) wattsSelect->setCurrentIndex(index);
|
|
}
|
|
if (traintool->rpmTelemetry != -1) {
|
|
int index = rpmSelect->findData(traintool->rpmTelemetry);
|
|
if (index >=0) rpmSelect->setCurrentIndex(index);
|
|
}
|
|
if (traintool->kphTelemetry != -1) {
|
|
int index = kphSelect->findData(traintool->kphTelemetry);
|
|
if (index >=0) kphSelect->setCurrentIndex(index);
|
|
}
|
|
|
|
QHBoxLayout *buttons = new QHBoxLayout;
|
|
buttons->addStretch();
|
|
main->addLayout(buttons);
|
|
|
|
cancelButton = new QPushButton(tr("Cancel"), this);
|
|
buttons->addWidget(cancelButton);
|
|
|
|
applyButton = new QPushButton(tr("Apply"), this);
|
|
buttons->addWidget(applyButton);
|
|
|
|
connect(cancelButton, SIGNAL(clicked()), this, SLOT(cancelClicked()));
|
|
connect(applyButton, SIGNAL(clicked()), this, SLOT(applyClicked()));
|
|
}
|
|
|
|
void
|
|
MultiDeviceDialog::applyClicked()
|
|
{
|
|
traintool->rpmTelemetry = rpmSelect->itemData(rpmSelect->currentIndex()).toInt();
|
|
traintool->bpmTelemetry = bpmSelect->itemData(bpmSelect->currentIndex()).toInt();
|
|
traintool->wattsTelemetry = wattsSelect->itemData(wattsSelect->currentIndex()).toInt();
|
|
traintool->kphTelemetry = kphSelect->itemData(kphSelect->currentIndex()).toInt();
|
|
accept();
|
|
}
|
|
|
|
void
|
|
MultiDeviceDialog::cancelClicked()
|
|
{
|
|
reject();
|
|
}
|
|
|
|
void
|
|
TrainSidebar::devicePopup()
|
|
{
|
|
// OK - we are working with a specific event..
|
|
QMenu menu(deviceTree);
|
|
|
|
QAction *addDevice = new QAction(tr("Add Device"), deviceTree);
|
|
connect(addDevice, SIGNAL(triggered(void)), context->mainWindow, SLOT(addDevice()));
|
|
menu.addAction(addDevice);
|
|
|
|
if (deviceTree->selectedItems().size() == 1) {
|
|
QAction *delDevice = new QAction(tr("Delete Device"), deviceTree);
|
|
connect(delDevice, SIGNAL(triggered(void)), this, SLOT(deleteDevice()));
|
|
menu.addAction(delDevice);
|
|
}
|
|
|
|
// execute the menu
|
|
menu.exec(trainSplitter->mapToGlobal(QPoint(deviceItem->pos().x()+deviceItem->width()-20,
|
|
deviceItem->pos().y())));
|
|
}
|
|
void
|
|
TrainSidebar::deviceTreeMenuPopup(const QPoint &pos)
|
|
{
|
|
QMenu menu(deviceTree);
|
|
QAction *addDevice = new QAction(tr("Add Device"), deviceTree);
|
|
connect(addDevice, SIGNAL(triggered(void)), context->mainWindow, SLOT(addDevice()));
|
|
menu.addAction(addDevice);
|
|
|
|
if (deviceTree->selectedItems().size() == 1) {
|
|
QAction *delDevice = new QAction(tr("Delete Device"), deviceTree);
|
|
connect(delDevice, SIGNAL(triggered(void)), this, SLOT(deleteDevice()));
|
|
menu.addAction(delDevice);
|
|
}
|
|
|
|
menu.exec(deviceTree->mapToGlobal(pos));
|
|
}
|
|
|
|
void
|
|
TrainSidebar::deleteDevice()
|
|
{
|
|
// get the configuration
|
|
DeviceConfigurations all;
|
|
QList<DeviceConfiguration>list = all.getList();
|
|
|
|
// Delete the selected device
|
|
QTreeWidgetItem *selected = deviceTree->selectedItems().first();
|
|
int index = deviceTree->invisibleRootItem()->indexOfChild(selected);
|
|
|
|
if (index < 0 || index > list.size()) return;
|
|
|
|
// make sure they really mean this!
|
|
QMessageBox msgBox;
|
|
msgBox.setText(tr("Are you sure you want to delete this device?"));
|
|
msgBox.setInformativeText(list[index].name);
|
|
QPushButton *deleteButton = msgBox.addButton(tr("Delete"),QMessageBox::YesRole);
|
|
msgBox.setStandardButtons(QMessageBox::Cancel);
|
|
msgBox.setDefaultButton(QMessageBox::Cancel);
|
|
msgBox.setIcon(QMessageBox::Critical);
|
|
msgBox.exec();
|
|
|
|
if(msgBox.clickedButton() != deleteButton) return;
|
|
|
|
// find this one and delete it
|
|
list.removeAt(index);
|
|
all.writeConfig(list);
|
|
|
|
// tell everyone
|
|
context->notifyConfigChanged(CONFIG_DEVICES);
|
|
}
|
|
|
|
void
|
|
TrainSidebar::moveDevices(int oldposition, int newposition)
|
|
{
|
|
// get the configuration
|
|
DeviceConfigurations all;
|
|
QList<DeviceConfiguration>list = all.getList();
|
|
|
|
// move the devices
|
|
list.move(oldposition, newposition);
|
|
all.writeConfig(list);
|
|
|
|
// tell everyone
|
|
context->notifyConfigChanged(CONFIG_DEVICES);
|
|
}
|
|
|
|
// we have been told to select this video (usually because
|
|
// the user just dragndropped it in)
|
|
void
|
|
TrainSidebar::selectVideo(QString fullpath)
|
|
{
|
|
// look at each entry in the top workoutTree
|
|
for (int i=0; i<mediaTree->model()->rowCount(); i++) {
|
|
QString path = mediaTree->model()->data(mediaTree->model()->index(i,0)).toString();
|
|
if (path == fullpath) {
|
|
mediaTree->setCurrentIndex(mediaTree->model()->index(i,0));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
TrainSidebar::selectVideoSync(QString fullpath)
|
|
{
|
|
// look at each entry in the top videosyncTree
|
|
for (int i=0; i<videosyncTree->model()->rowCount(); i++) {
|
|
QString path = videosyncTree->model()->data(videosyncTree->model()->index(i,0)).toString();
|
|
if (path == fullpath) {
|
|
videosyncTree->setCurrentIndex(videosyncTree->model()->index(i,0));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// we have been told to select this workout (usually because
|
|
// the user just dragndropped it in)
|
|
void
|
|
TrainSidebar::selectWorkout(QString fullpath)
|
|
{
|
|
// look at each entry in the top workoutTree
|
|
for (int i=0; i<workoutTree->model()->rowCount(); i++) {
|
|
QString path = workoutTree->model()->data(workoutTree->model()->index(i,0)).toString();
|
|
if (path == fullpath) {
|
|
workoutTree->setCurrentIndex(workoutTree->model()->index(i,0));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// got a remote control command
|
|
void
|
|
TrainSidebar::remoteControl(uint16_t command)
|
|
{
|
|
//qDebug() << "TrainSidebar::remoteControl()" << command;
|
|
|
|
switch(command){
|
|
|
|
case GC_REMOTE_CMD_START:
|
|
this->Start();
|
|
break;
|
|
|
|
case GC_REMOTE_CMD_STOP:
|
|
this->Stop();
|
|
break;
|
|
|
|
case GC_REMOTE_CMD_LAP:
|
|
this->newLap();
|
|
break;
|
|
|
|
case GC_REMOTE_CMD_HIGHER:
|
|
this->Higher();
|
|
break;
|
|
|
|
case GC_REMOTE_CMD_LOWER:
|
|
this->Lower();
|
|
break;
|
|
|
|
case GC_REMOTE_CMD_CALIBRATE:
|
|
this->Calibrate();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// HRV R-R data received
|
|
void TrainSidebar::rrData(uint16_t rrtime, uint8_t count, uint8_t bpm)
|
|
{
|
|
Q_UNUSED(count)
|
|
if (status&RT_RECORDING && rrFile == NULL && recordFile != NULL) {
|
|
QString rrfile = recordFile->fileName().replace("csv", "rr");
|
|
//fprintf(stderr, "First r-r, need to open file %s\n", rrfile.toStdString().c_str()); fflush(stderr);
|
|
|
|
// setup the rr file
|
|
rrFile = new QFile(rrfile);
|
|
if (!rrFile->open(QFile::WriteOnly | QFile::Truncate)) {
|
|
delete rrFile;
|
|
rrFile=NULL;
|
|
} else {
|
|
|
|
// CSV File header
|
|
QTextStream recordFileStream(rrFile);
|
|
recordFileStream << "secs, hr, msecs\n";
|
|
}
|
|
}
|
|
|
|
// output a line if recording and file ready
|
|
if (status&RT_RECORDING && rrFile) {
|
|
QTextStream recordFileStream(rrFile);
|
|
|
|
// convert from milliseconds to secondes
|
|
double secs = double(session_elapsed_msec + session_time.elapsed()) / 1000.00;
|
|
|
|
// output a line
|
|
recordFileStream << secs << ", " << bpm << ", " << rrtime << "\n";
|
|
}
|
|
//fprintf(stderr, "R-R: %d ms, HR=%d, count=%d\n", rrtime, bpm, count); fflush(stderr);
|
|
}
|
|
|
|
// VO2 Measurement data received
|
|
void TrainSidebar::vo2Data(double rf, double rmv, double vo2, double vco2, double tv, double feo2)
|
|
{
|
|
if (status&RT_RECORDING && vo2File == NULL && recordFile != NULL) {
|
|
QString vo2filename = recordFile->fileName().replace("csv", "vo2");
|
|
|
|
// setup the rr file
|
|
vo2File = new QFile(vo2filename);
|
|
if (!vo2File->open(QFile::WriteOnly | QFile::Truncate)) {
|
|
delete vo2File;
|
|
vo2File=NULL;
|
|
} else {
|
|
|
|
// CSV File header
|
|
QTextStream recordFileStream(vo2File);
|
|
recordFileStream << "secs, rf, rmv, vo2, vco2, tv, feo2\n";
|
|
}
|
|
}
|
|
|
|
// output a line if recording and file ready
|
|
if (status&RT_RECORDING && vo2File) {
|
|
QTextStream recordFileStream(vo2File);
|
|
|
|
// convert from milliseconds to secondes
|
|
double secs = double(session_elapsed_msec + session_time.elapsed()) / 1000.00;
|
|
|
|
// output a line
|
|
recordFileStream << secs << ", " << rf << ", " << rmv << ", " << vo2 << ", " << vco2 << ", " << tv << ", " << feo2 << "\n";
|
|
}
|
|
}
|
|
|
|
// connect/disconnect automatically when view changes
|
|
void
|
|
TrainSidebar::viewChanged(int index)
|
|
{
|
|
//qDebug() << "view has changed to:" << index;
|
|
|
|
// ensure buttons reflect current state
|
|
setStatusFlags(0);
|
|
|
|
if (!autoConnect) return;
|
|
|
|
// fixme: value hard-coded throughout
|
|
if (index == 3) {
|
|
//train view
|
|
if ((status&RT_CONNECTED) == 0) {
|
|
Connect();
|
|
}
|
|
} else {
|
|
// other view
|
|
if ((status&RT_CONNECTED) && (status&RT_RUNNING) == 0) {
|
|
Disconnect();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void TrainSidebar::setStatusFlags(int flags)
|
|
{
|
|
status |= flags;
|
|
context->isRunning = (status&RT_RUNNING);
|
|
context->isPaused = (status&RT_PAUSED);
|
|
|
|
emit statusChanged(status);
|
|
}
|
|
|
|
void TrainSidebar::clearStatusFlags(int flags)
|
|
{
|
|
status &=~flags;
|
|
context->isRunning = (status&RT_RUNNING);
|
|
context->isPaused = (status&RT_PAUSED);
|
|
|
|
emit statusChanged(status);
|
|
}
|
|
|
|
int TrainSidebar::getCalibrationIndex()
|
|
{
|
|
// select the least recently calibrated GC device that reports calibration capabilities.
|
|
//
|
|
// note that for for ANT devices, the calibration class handles the case of multiple sensors
|
|
// with support for calibration, and will select a suitable device/channel for calibration each time.
|
|
|
|
int index = -1;
|
|
QTime lastCal = QTime::currentTime();
|
|
|
|
foreach(int dev, devices()) {
|
|
if (Devices[dev].controller->getCalibrationType()) {
|
|
// device supports calibration
|
|
//qDebug() << "Device" << dev << "supports calibration, last cal attempt timestamp is" << Devices[dev].controller->getCalibrationTimestamp();
|
|
if (Devices[dev].controller->getCalibrationTimestamp() < lastCal) {
|
|
// older (or no) calibration timestamp, select this device
|
|
lastCal = Devices[dev].controller->getCalibrationTimestamp();
|
|
index = dev;
|
|
}
|
|
}
|
|
}
|
|
if (index != -1)
|
|
Devices[index].controller->setCalibrationTimestamp();
|
|
|
|
return index;
|
|
}
|
|
|
|
DeviceTreeView::DeviceTreeView()
|
|
{
|
|
setDragDropMode(QAbstractItemView::InternalMove);
|
|
setDragDropOverwriteMode(true);
|
|
}
|
|
|
|
void
|
|
DeviceTreeView::dropEvent(QDropEvent* event)
|
|
{
|
|
// get the list of the items that are about to be dropped
|
|
QTreeWidgetItem* item = selectedItems()[0];
|
|
|
|
// row we started on
|
|
int idx1 = indexFromItem(item).row();
|
|
|
|
// the default implementation takes care of the actual move inside the tree
|
|
QTreeWidget::dropEvent(event);
|
|
|
|
// moved to !
|
|
int idx2 = indexFromItem(item).row();
|
|
|
|
// notify subscribers in some useful way
|
|
Q_EMIT itemMoved(idx1, idx2);
|
|
}
|