zhaohuwei
/
QG4
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Updated validation rules 

Also uses new min/max/invalid widget display
QGC4.4
Don Gagne 11 years ago
parent
42d9a74e66
commit
e39b779ad0
4 changed files with 419 additions and 174 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 403
      src/qgcunittest/PX4RCCalibrationTest.cc
  2. 55
      src/qgcunittest/PX4RCCalibrationTest.h
  3. 108
      src/ui/px4_configuration/PX4RCCalibration.cc
  4. 17
      src/ui/px4_configuration/PX4RCCalibration.h

403
src/qgcunittest/PX4RCCalibrationTest.cc
Unescape View File

@ -26,7 +26,7 @@ @@ -26,7 +26,7 @@
#include "MockQGCUASParamManager.h"
/// @file
/// @brief QGCPX4RCCAlibration Widget unit test
/// @brief QPX4RCCalibration Widget unit test
///
/// @author Don Gagne <don@thegagnes.com>
@ -50,7 +50,7 @@ @@ -50,7 +50,7 @@
// by the Next button on the second iteration.
#define NEXT_OR_CANCEL(cancelNum) \
{ \
if (standaloneTest && tryCancel ## cancelNum) { \
if (mode == testModeStandalone && tryCancel ## cancelNum) { \
QTest::mouseClick(_cancelButton, Qt::LeftButton); \
QCOMPARE(_calWidget->_rcCalState, PX4RCCalibration::rcCalStateChannelWait); \
tryCancel ## cancelNum = false; \
@ -60,6 +60,65 @@ @@ -60,6 +60,65 @@
} \
}
const int PX4RCCalibrationTest::_testMinValue = PX4RCCalibration::_rcCalPWMDefaultMinValue + 10;
const int PX4RCCalibrationTest::_testMaxValue = PX4RCCalibration::_rcCalPWMDefaultMaxValue - 10;
const int PX4RCCalibrationTest::_testTrimValue = PX4RCCalibration::_rcCalPWMDefaultTrimValue + 10;
const int PX4RCCalibrationTest::_testThrottleTrimValue = PX4RCCalibration::_rcCalPWMDefaultMinValue + 10;
const struct PX4RCCalibrationTest::ChannelSettings PX4RCCalibrationTest::_rgChannelSettingsPreValidate[PX4RCCalibrationTest::_availableChannels] = {
//Min Value Max Value Trim Value Reversed MinMaxShown MinValid MaxValid
// Channel 0 : rcCalFunctionRoll
{ PX4RCCalibrationTest::_testMinValue, PX4RCCalibrationTest::_testMaxValue, PX4RCCalibrationTest::_testTrimValue, false, true, true, true },
// Channel 1 : rcCalFunctionPitch
{ PX4RCCalibrationTest::_testMinValue, PX4RCCalibrationTest::_testMaxValue, PX4RCCalibrationTest::_testTrimValue, false, true, true, true },
// Channel 2 : rcCalFunctionYaw
{ PX4RCCalibrationTest::_testMinValue, PX4RCCalibrationTest::_testMaxValue, PX4RCCalibrationTest::_testTrimValue, false, true, true, true },
// Channel 3 : rcCalFunctionThrottle
{ PX4RCCalibrationTest::_testMinValue, PX4RCCalibrationTest::_testMaxValue, PX4RCCalibrationTest::_testThrottleTrimValue, false, true, true, true },
// Channel 4 : rcCalFunctionModeSwitch
{ PX4RCCalibrationTest::_testMinValue, PX4RCCalibrationTest::_testMaxValue, PX4RCCalibration::_rcCalPWMCenterPoint, false, true, true, true },
// Channel 5 : Simulate invalid Min, valid Max
{ PX4RCCalibration::_rcCalPWMCenterPoint, PX4RCCalibration::_rcCalPWMDefaultMaxValue, PX4RCCalibration::_rcCalPWMCenterPoint, false, true, false, true },
// Channels 6-7: Invalid Min/Max, since available channel Min/Max is still shown
{ PX4RCCalibration::_rcCalPWMCenterPoint, PX4RCCalibration::_rcCalPWMCenterPoint, PX4RCCalibration::_rcCalPWMCenterPoint, false, true, false, false },
{ PX4RCCalibration::_rcCalPWMCenterPoint, PX4RCCalibration::_rcCalPWMCenterPoint, PX4RCCalibration::_rcCalPWMCenterPoint, false, true, false, false },
};
const struct PX4RCCalibrationTest::ChannelSettings PX4RCCalibrationTest::_rgChannelSettingsPostValidate[PX4RCCalibration::_chanMax] = {
// Min Value Max Value Trim Value Reversed MinMaxShown MinValid MaxValid
// Channel 0 : rcCalFunctionRoll
{ PX4RCCalibrationTest::_testMinValue, PX4RCCalibrationTest::_testMaxValue, PX4RCCalibrationTest::_testTrimValue, false, true, true, true },
// Channel 1 : rcCalFunctionPitch
{ PX4RCCalibrationTest::_testMinValue, PX4RCCalibrationTest::_testMaxValue, PX4RCCalibrationTest::_testTrimValue, false, true, true, true },
// Channel 2 : rcCalFunctionYaw
{ PX4RCCalibrationTest::_testMinValue, PX4RCCalibrationTest::_testMaxValue, PX4RCCalibrationTest::_testTrimValue, false, true, true, true },
// Channel 3 : rcCalFunctionThrottle
{ PX4RCCalibrationTest::_testMinValue, PX4RCCalibrationTest::_testMaxValue, PX4RCCalibrationTest::_testThrottleTrimValue, false, true, true, true },
// Channel 4 : rcCalFunctionModeSwitch
{ PX4RCCalibrationTest::_testMinValue, PX4RCCalibrationTest::_testMaxValue, PX4RCCalibration::_rcCalPWMCenterPoint, false, true, true, true },
// Channel 5 : Simulate invalid Min, valid Max, validation should switch back to defaults
{ PX4RCCalibration::_rcCalPWMDefaultMinValue, PX4RCCalibration::_rcCalPWMDefaultMaxValue, PX4RCCalibration::_rcCalPWMDefaultTrimValue, false, true, true, true },
// Channels 6-7: Invalid Min/Max, since available channel Min/Max is still shown, validation will set to defaults
{ PX4RCCalibration::_rcCalPWMDefaultMinValue, PX4RCCalibration::_rcCalPWMDefaultMaxValue, PX4RCCalibration::_rcCalPWMDefaultTrimValue, false, true, true, true },
{ PX4RCCalibration::_rcCalPWMDefaultMinValue, PX4RCCalibration::_rcCalPWMDefaultMaxValue, PX4RCCalibration::_rcCalPWMDefaultTrimValue, false, true, true, true },
// We are simulating an 8-channel radio, all other channel should be defaulted
{ PX4RCCalibration::_rcCalPWMDefaultMinValue, PX4RCCalibration::_rcCalPWMDefaultMaxValue, PX4RCCalibration::_rcCalPWMDefaultTrimValue, false, false, false, false },
{ PX4RCCalibration::_rcCalPWMDefaultMinValue, PX4RCCalibration::_rcCalPWMDefaultMaxValue, PX4RCCalibration::_rcCalPWMDefaultTrimValue, false, false, false, false },
{ PX4RCCalibration::_rcCalPWMDefaultMinValue, PX4RCCalibration::_rcCalPWMDefaultMaxValue, PX4RCCalibration::_rcCalPWMDefaultTrimValue, false, false, false, false },
{ PX4RCCalibration::_rcCalPWMDefaultMinValue, PX4RCCalibration::_rcCalPWMDefaultMaxValue, PX4RCCalibration::_rcCalPWMDefaultTrimValue, false, false, false, false },
{ PX4RCCalibration::_rcCalPWMDefaultMinValue, PX4RCCalibration::_rcCalPWMDefaultMaxValue, PX4RCCalibration::_rcCalPWMDefaultTrimValue, false, false, false, false },
{ PX4RCCalibration::_rcCalPWMDefaultMinValue, PX4RCCalibration::_rcCalPWMDefaultMaxValue, PX4RCCalibration::_rcCalPWMDefaultTrimValue, false, false, false, false },
{ PX4RCCalibration::_rcCalPWMDefaultMinValue, PX4RCCalibration::_rcCalPWMDefaultMaxValue, PX4RCCalibration::_rcCalPWMDefaultTrimValue, false, false, false, false },
{ PX4RCCalibration::_rcCalPWMDefaultMinValue, PX4RCCalibration::_rcCalPWMDefaultMaxValue, PX4RCCalibration::_rcCalPWMDefaultTrimValue, false, false, false, false },
{ PX4RCCalibration::_rcCalPWMDefaultMinValue, PX4RCCalibration::_rcCalPWMDefaultMaxValue, PX4RCCalibration::_rcCalPWMDefaultTrimValue, false, false, false, false },
{ PX4RCCalibration::_rcCalPWMDefaultMinValue, PX4RCCalibration::_rcCalPWMDefaultMaxValue, PX4RCCalibration::_rcCalPWMDefaultTrimValue, false, false, false, false },
};
PX4RCCalibrationTest::PX4RCCalibrationTest(void) :
_mockUASManager(NULL),
_calWidget(NULL)
@ -67,6 +126,30 @@ PX4RCCalibrationTest::PX4RCCalibrationTest(void) : @@ -67,6 +126,30 @@ PX4RCCalibrationTest::PX4RCCalibrationTest(void) :
}
/// @brief Called one time before any test cases are run.
void PX4RCCalibrationTest::initTestCase(void)
{
// The test case code makes the following assumptions about PX4RCCalibration class internals.
// Make sure these don't change out from under us.
Q_ASSERT(PX4RCCalibration::rcCalFunctionRoll == 0);
Q_ASSERT(PX4RCCalibration::rcCalFunctionPitch == 1);
Q_ASSERT(PX4RCCalibration::rcCalFunctionYaw == 2);
Q_ASSERT(PX4RCCalibration::rcCalFunctionThrottle == 3);
Q_ASSERT(PX4RCCalibration::rcCalFunctionModeSwitch == 4);
// We only set min/max for required channels. Make sure the set of required channels doesn't change out from under us.
for (int chanFunction=0; chanFunction<PX4RCCalibration::rcCalFunctionMax; chanFunction++) {
if (PX4RCCalibration::_rgFunctionInfo[chanFunction].required) {
Q_ASSERT(chanFunction == PX4RCCalibration::rcCalFunctionRoll ||
chanFunction == PX4RCCalibration::rcCalFunctionPitch ||
chanFunction == PX4RCCalibration::rcCalFunctionYaw ||
chanFunction == PX4RCCalibration::rcCalFunctionThrottle ||
chanFunction == PX4RCCalibration::rcCalFunctionModeSwitch);
}
}
}
void PX4RCCalibrationTest::init(void)
{
_mockUASManager = new MockUASManager();
@ -139,6 +222,11 @@ void PX4RCCalibrationTest::_minRCChannels_test(void) @@ -139,6 +222,11 @@ void PX4RCCalibrationTest::_minRCChannels_test(void)
// Next button won't be enabled until we see the minimum number of channels.
for (int i=0; i<PX4RCCalibration::_chanMinimum; i++) {
_mockUAS->emitRemoteControlChannelRawChanged(i, (float)PX4RCCalibration::_rcCalPWMCenterPoint);
// We use _chanCount internally so we should validate it
QCOMPARE(_calWidget->_chanCount, i+1);
// Validate Next button state
if (i == PX4RCCalibration::_chanMinimum - 1) {
// Last channel should trigger enable
CHK_BUTTONS(nextButtonMask);
@ -146,6 +234,12 @@ void PX4RCCalibrationTest::_minRCChannels_test(void) @@ -146,6 +234,12 @@ void PX4RCCalibrationTest::_minRCChannels_test(void)
// Still less than the minimum channels
CHK_BUTTONS(0);
}
// Only available channels should have enabled widget. A ui update cycle needs to have passed so we wait a little.
QTest::qWait(PX4RCCalibration::_updateInterval * 2);
for (int chanWidget=0; chanWidget<PX4RCCalibration::_chanMax; chanWidget++) {
QCOMPARE(_rgRadioWidget[chanWidget]->isEnabled(), !!(chanWidget <= i));
}
}
}
@ -167,13 +261,13 @@ void PX4RCCalibrationTest::_liveRC_test(void) @@ -167,13 +261,13 @@ void PX4RCCalibrationTest::_liveRC_test(void)
}
#endif
void PX4RCCalibrationTest::_beginState_worker(bool standaloneTest)
void PX4RCCalibrationTest::_beginState_worker(enum TestMode mode)
{
bool tryCancel1 = true;
StartOver:
if (standaloneTest) {
_centerAllChannels();
if (mode == testModeStandalone || mode == testModePrerequisite) {
_centerChannels();
_calWidget->_unitTestForceCalState(PX4RCCalibration::rcCalStateBegin);
}
@ -192,34 +286,41 @@ StartOver: @@ -192,34 +286,41 @@ StartOver:
void PX4RCCalibrationTest::_beginState_test(void)
{
_beginState_worker(true /* standalone test */);
_beginState_worker(testModeStandalone);
}
void PX4RCCalibrationTest::_identifyState_worker(bool standaloneTest, bool skipOptional)
void PX4RCCalibrationTest::_identifyState_worker(enum TestMode mode)
{
bool tryCancel1 = standaloneTest;
bool tryCancel1 = true;
StartOver:
if (standaloneTest) {
_centerAllChannels();
if (mode == testModeStandalone || mode == testModePrerequisite)
{
_centerChannels();
_calWidget->_unitTestForceCalState(PX4RCCalibration::rcCalStateIdentify);
}
// Loop over all functions setting them to a channel
// Loop over all function idenitfying required channels
for (int i=0; i<PX4RCCalibration::rcCalFunctionMax; i++) {
// If this function is required you can't skip it
bool skipAllowed = !PX4RCCalibration::_rgFunctionInfo[i].required;
int skipMask = skipAllowed ? skipButtonMask : 0;
bool skipNonRequired = !PX4RCCalibration::_rgFunctionInfo[i].required;
int skipMask = skipNonRequired ? skipButtonMask : 0;
// We should now be waiting for movement on a channel to identify the RC function. The Next button will stay
// disabled until the sticks are moved enough to identify the channel. For required functions the Skip button is
// disabled.
CHK_BUTTONS(cancelButtonMask | skipMask);
// Move channel lower than delta to make sure function is not identified
_mockUAS->emitRemoteControlChannelRawChanged(i, (float)PX4RCCalibration::_rcCalPWMCenterPoint - (PX4RCCalibration::_rcCalMoveDelta - 2.0f));
// Skip this mapping if allowed
if (skipNonRequired) {
QTest::mouseClick(_skipButton, Qt::LeftButton);
continue;
}
// Move channel less than delta to make sure function is not identified
_mockUAS->emitRemoteControlChannelRawChanged(i, (float)PX4RCCalibration::_rcCalPWMCenterPoint + (PX4RCCalibration::_rcCalMoveDelta - 2.0f));
CHK_BUTTONS(cancelButtonMask | skipMask);
if (i != 0) {
@ -229,20 +330,12 @@ StartOver: @@ -229,20 +330,12 @@ StartOver:
CHK_BUTTONS(cancelButtonMask | skipMask);
}
// Skip this mapping if allowed and requested
if (skipAllowed && skipOptional) {
QTest::mouseClick(_skipButton, Qt::LeftButton);
continue;
} else {
}
if (tryCancel1) {
NEXT_OR_CANCEL(1);
}
// Move channel larger than delta to identify channel. We should now be sitting in a found state.
_mockUAS->emitRemoteControlChannelRawChanged(i, (float)PX4RCCalibration::_rcCalPWMValidMinValue);
_mockUAS->emitRemoteControlChannelRawChanged(i, (float)PX4RCCalibration::_rcCalPWMCenterPoint + (PX4RCCalibration::_rcCalMoveDelta + 2.0f));
CHK_BUTTONS(cancelButtonMask | tryAgainButtonMask | nextButtonMask);
NEXT_OR_CANCEL(1);
@ -252,35 +345,30 @@ StartOver: @@ -252,35 +345,30 @@ StartOver:
QCOMPARE(_calWidget->_rcCalState, PX4RCCalibration::rcCalStateMinMax);
CHK_BUTTONS(nextButtonMask | cancelButtonMask);
if (standaloneTest) {
if (mode == testModeStandalone) {
_calWidget->_writeCalibration(false /* !trimsOnly */);
_validateParameters(validateMappingMask, skipOptional);
_validateParameters(validateMappingMask);
}
}
void PX4RCCalibrationTest::_identifyState_test(void)
{
_identifyState_worker(true /* standalone test */, false /* don't skip optional */);
_identifyState_worker(testModeStandalone);
}
void PX4RCCalibrationTest::_identifyStateSkipOptional_test(void)
{
_identifyState_worker(true /* standalone test */, true /* skip optional */);
}
void PX4RCCalibrationTest::_minMaxState_worker(bool standaloneTest)
void PX4RCCalibrationTest::_minMaxState_worker(enum TestMode mode)
{
bool tryCancel1 = true;
StartOver:
if (standaloneTest) {
if (mode == testModeStandalone || mode == testModePrerequisite) {
// The Min/Max calibration updates the radio channel ui widgets with the min/max values as you move the sticks.
// In order for the roll/pitch/yaw/throttle radio channel ui widgets to be updated correctly those fucntions
// In order for the roll/pitch/yaw/throttle radio channel ui widgets to be updated correctly those functions
// must be alread mapped to a channel. So we have to run the _identifyState_test first to set up the internal
// state correctly.
_identifyState_test();
_identifyState_worker(testModePrerequisite);
_centerAllChannels();
_centerChannels();
_calWidget->_unitTestForceCalState(PX4RCCalibration::rcCalStateMinMax);
@ -288,12 +376,27 @@ StartOver: @@ -288,12 +376,27 @@ StartOver:
CHK_BUTTONS(nextButtonMask | cancelButtonMask);
}
// Send min/max values for all channels
for (int i=0; i<PX4RCCalibration::_chanMax; i++) {
_mockUAS->emitRemoteControlChannelRawChanged(i, (float)PX4RCCalibration::_rcCalPWMValidMinValue);
_mockUAS->emitRemoteControlChannelRawChanged(i, (float)PX4RCCalibration::_rcCalPWMValidMaxValue);
// Before we start sending rc values the widgets should all have min/max as invalid
for (int chan=0; chan<PX4RCCalibration::_chanMax; chan++) {
QCOMPARE(_rgRadioWidget[chan]->isMinValid(), false);
QCOMPARE(_rgRadioWidget[chan]->isMaxValid(), false);
}
// Try setting a min/max value that is below the threshold to make sure min/max doesn't go valid
_mockUAS->emitRemoteControlChannelRawChanged(0, (float)(PX4RCCalibration::_rcCalPWMValidMinValue + 1));
_mockUAS->emitRemoteControlChannelRawChanged(0, (float)(PX4RCCalibration::_rcCalPWMValidMaxValue - 1));
QCOMPARE(_rgRadioWidget[0]->isMinValid(), false);
QCOMPARE(_rgRadioWidget[0]->isMaxValid(), false);
// Send min/max values
for (int chan=0; chan<_minMaxChannels; chan++) {
// Send Min/Max
_mockUAS->emitRemoteControlChannelRawChanged(chan, (float)_rgChannelSettingsPreValidate[chan].rcMin);
_mockUAS->emitRemoteControlChannelRawChanged(chan, (float)_rgChannelSettingsPreValidate[chan].rcMax);
}
_validateWidgets(validateMinMaxMask, _rgChannelSettingsPreValidate);
// Make sure throttle is at min
_mockUAS->emitRemoteControlChannelRawChanged(PX4RCCalibration::rcCalFunctionThrottle, (float)PX4RCCalibration::_rcCalPWMValidMinValue);
@ -303,18 +406,7 @@ StartOver: @@ -303,18 +406,7 @@ StartOver:
QCOMPARE(_calWidget->_rcCalState, PX4RCCalibration::rcCalStateCenterThrottle);
CHK_BUTTONS(cancelButtonMask);
// Also at this point the radio channel widgets should be displaying the current min/max we just set.
for (int i=0; i<PX4RCCalibration::_chanMax; i++) {
RCChannelWidget* radioWidget = _rgRadioWidget[i];
Q_ASSERT(radioWidget);
QCOMPARE(radioWidget->isMinMaxShown(), true);
QCOMPARE(radioWidget->min(), PX4RCCalibration::_rcCalPWMValidMinValue);
QCOMPARE(radioWidget->max(), PX4RCCalibration::_rcCalPWMValidMaxValue);
}
if (standaloneTest) {
if (mode == testModeStandalone) {
_calWidget->_writeCalibration(false /* !trimsOnly */);
_validateParameters(validateMinMaxMask);
}
@ -322,20 +414,20 @@ StartOver: @@ -322,20 +414,20 @@ StartOver:
void PX4RCCalibrationTest::_minMaxState_test(void)
{
_minMaxState_worker(true /* standalone test */);
_minMaxState_worker(testModeStandalone);
}
void PX4RCCalibrationTest::_centerThrottleState_worker(bool standaloneTest)
void PX4RCCalibrationTest::_centerThrottleState_worker(enum TestMode mode)
{
bool tryCancel1 = true;
StartOver:
if (standaloneTest) {
if (mode == testModeStandalone || mode == testModePrerequisite) {
// In order to perform the center throttle state test the throttle channel has to have been identified.
// So we have to run the _identifyState_test first to set up the internal state correctly.
_identifyState_test();
_identifyState_worker(testModePrerequisite);
_centerAllChannels();
_centerChannels();
_mockUAS->emitRemoteControlChannelRawChanged(PX4RCCalibration::rcCalFunctionThrottle, (float)PX4RCCalibration::_rcCalPWMValidMinValue);
_calWidget->_unitTestForceCalState(PX4RCCalibration::rcCalStateCenterThrottle);
@ -362,21 +454,21 @@ StartOver: @@ -362,21 +454,21 @@ StartOver:
void PX4RCCalibrationTest::_centerThrottleState_test(void)
{
_centerThrottleState_worker(true /* standalone test */);
_centerThrottleState_worker(testModeStandalone);
}
void PX4RCCalibrationTest::_detectInversionState_worker(bool standaloneTest)
void PX4RCCalibrationTest::_detectInversionState_worker(enum TestMode mode)
{
bool tryCancel1 = true;
bool tryCancel2 = true;
StartOver:
if (standaloneTest) {
if (mode == testModeStandalone || mode == testModePrerequisite) {
// In order to perform the detect inversion test the roll/pitch/yaw/throttle functions must be mapped to a channel.
// So we have to run the _identifyState_test first to set up the internal state correctly.
_identifyState_test();
_identifyState_worker(testModePrerequisite);
_centerAllChannels();
_centerChannels();
_calWidget->_unitTestForceCalState(PX4RCCalibration::rcCalStateDetectInversion);
@ -394,27 +486,31 @@ StartOver: @@ -394,27 +486,31 @@ StartOver:
}
// Move all channels except for the one we are trying to detect to min and max value to make sure there is no effect.
for (int chan=0; chan<PX4RCCalibration::_chanMax; chan++) {
for (int chan=0; chan<_availableChannels; chan++) {
if (chanFunction != chan) {
_mockUAS->emitRemoteControlChannelRawChanged(chan, PX4RCCalibration::_rcCalPWMValidMaxValue);
_mockUAS->emitRemoteControlChannelRawChanged(chan, (float)PX4RCCalibration::_rcCalPWMCenterPoint + (PX4RCCalibration::_rcCalMoveDelta + 2.0f));
_mockUAS->emitRemoteControlChannelRawChanged(chan, (float)PX4RCCalibration::_rcCalPWMCenterPoint - (PX4RCCalibration::_rcCalMoveDelta + 2.0f));
CHK_BUTTONS(cancelButtonMask);
// Make sure to re-center for next inversion detect
_mockUAS->emitRemoteControlChannelRawChanged(chan, (float)PX4RCCalibration::_rcCalPWMCenterPoint);
}
}
// Move the channel we are detecting inversion on to the min value which should indicate no inversion.
// This should put us in the found state and enable the Next button.
_mockUAS->emitRemoteControlChannelRawChanged(chanFunction, PX4RCCalibration::_rcCalPWMValidMinValue);
_mockUAS->emitRemoteControlChannelRawChanged(chanFunction, (float)PX4RCCalibration::_rcCalPWMCenterPoint - (PX4RCCalibration::_rcCalMoveDelta + 2.0f));
CHK_BUTTONS(cancelButtonMask | tryAgainButtonMask | nextButtonMask);
}
// Click the next button: We should now be waiting for low throttle in prep for trim detection.
// Throttle channel is at minimum so Next button should be disabled.
_centerAllChannels();
_centerChannels();
NEXT_OR_CANCEL(2);
QCOMPARE(_calWidget->_rcCalState, PX4RCCalibration::rcCalStateTrims);
CHK_BUTTONS(cancelButtonMask);
if (standaloneTest) {
if (mode == testModeStandalone) {
_calWidget->_writeCalibration(false /* !trimsOnly */);
_validateParameters(validateMappingMask | validateReversedMask);
}
@ -422,21 +518,20 @@ StartOver: @@ -422,21 +518,20 @@ StartOver:
void PX4RCCalibrationTest::_detectInversionState_test(void)
{
_detectInversionState_worker(true /* standalone test */);
_detectInversionState_worker(testModeStandalone);
}
void PX4RCCalibrationTest::_trimsState_worker(bool standaloneTest)
void PX4RCCalibrationTest::_trimsState_worker(enum TestMode mode)
{
bool tryCancel1 = true;
StartOver:
if (standaloneTest) {
if (mode == testModeStandalone || mode == testModePrerequisite) {
// In order to perform the trim state test the functions must be mapped and the min/max values must be set.
// So we have to run the _identifyState_test and _minMaxState_test first to set up the internal state correctly.
_identifyState_test();
_minMaxState_test();
// So we have to run the _minMaxState_test first to set up the internal state correctly.
_minMaxState_worker(testModePrerequisite);
_centerAllChannels();
_centerChannels();
_calWidget->_unitTestForceCalState(PX4RCCalibration::rcCalStateTrims);
@ -444,16 +539,23 @@ StartOver: @@ -444,16 +539,23 @@ StartOver:
CHK_BUTTONS(cancelButtonMask);
}
// Move the throttle to min. Next should enable
_mockUAS->emitRemoteControlChannelRawChanged(PX4RCCalibration::rcCalFunctionThrottle, PX4RCCalibration::_rcCalPWMValidMinValue);
// Send trim values to attitude control function channels
for (int chan=0; chan<_attitudeChannels; chan++) {
_mockUAS->emitRemoteControlChannelRawChanged(chan, _rgChannelSettingsPreValidate[chan].rcTrim);
}
_validateWidgets(validateTrimsMask, _rgChannelSettingsPreValidate);
// Throttle trim was set, so next should be enabled
CHK_BUTTONS(cancelButtonMask | nextButtonMask);
// Click the next button which should set Trims and take us the Save step.
NEXT_OR_CANCEL(1);
QCOMPARE(_calWidget->_rcCalState, PX4RCCalibration::rcCalStateSave);
CHK_BUTTONS(cancelButtonMask | nextButtonMask);
_validateWidgets(validateTrimsMask, _rgChannelSettingsPostValidate);
if (standaloneTest) {
if (mode == testModeStandalone) {
_calWidget->_writeCalibration(false /* !trimsOnly */);
_validateParameters(validateTrimsMask);
}
@ -461,37 +563,38 @@ StartOver: @@ -461,37 +563,38 @@ StartOver:
void PX4RCCalibrationTest::_trimsState_test(void)
{
_trimsState_worker(true /* standalone test */);
_trimsState_worker(testModeStandalone);
}
void PX4RCCalibrationTest::_fullCalibration_test(void) {
_centerAllChannels();
_centerChannels();
QTest::mouseClick(_nextButton, Qt::LeftButton);
_beginState_worker(false);
_identifyState_worker(false, false);
_minMaxState_worker(false);
_centerThrottleState_worker(false);
_detectInversionState_worker(false);
_trimsState_worker(false);
_beginState_worker(testModeFullSequence);
_identifyState_worker(testModeFullSequence);
_minMaxState_worker(testModeFullSequence);
_centerThrottleState_worker(testModeFullSequence);
_detectInversionState_worker(testModeFullSequence);
_trimsState_worker(testModeFullSequence);
// One more click and the parameters should get saved
QTest::mouseClick(_nextButton, Qt::LeftButton);
_validateParameters(validateAllMask);
_validateWidgets(validateAllMask, _rgChannelSettingsPostValidate);
}
/// @brief Sends RC center point values on all channels.
void PX4RCCalibrationTest::_centerAllChannels(void)
/// @brief Sends RC center point values on minimum set of channels.
void PX4RCCalibrationTest::_centerChannels(void)
{
// We use all channels for testing. Initialize to center point. This should set the channel count above the minimum
// such that we can enter the idle state.
for (int i=0; i<PX4RCCalibration::_chanMax; i++) {
// Initialize available channels them to center point. This should also set the channel count above the
// minimum such that we can enter the idle state.
for (int i=0; i<_availableChannels; i++) {
_mockUAS->emitRemoteControlChannelRawChanged(i, (float)PX4RCCalibration::_rcCalPWMCenterPoint);
}
}
void PX4RCCalibrationTest::_validateParameters(int validateMask, bool skipOptional)
void PX4RCCalibrationTest::_validateParameters(int validateMask)
{
MockQGCUASParamManager* paramMgr = _mockUAS->getMockQGCUASParamManager();
MockQGCUASParamManager::ParamMap_t mapParamsSet = paramMgr->getMockSetParameters();
@ -501,51 +604,117 @@ void PX4RCCalibrationTest::_validateParameters(int validateMask, bool skipOption @@ -501,51 +604,117 @@ void PX4RCCalibrationTest::_validateParameters(int validateMask, bool skipOption
QString trimTpl("RC%1_TRIM");
QString revTpl("RC%1_REV");
// Set Min/Max/Reversed parameter for all channels. Not that parameter name is 1-based.
for (int chan = 1; chan <= PX4RCCalibration::_chanMax; chan++) {
// Check mapping for all fuctions
for (int chanFunction=0; chanFunction<PX4RCCalibration::rcCalFunctionMax; chanFunction++) {
int expectedParameterValue;
int expectedChannelValue;
if (PX4RCCalibration::_rgFunctionInfo[chanFunction].required) {
// We only map the required functions. All functions should be mapped to the same channel index
expectedParameterValue = chanFunction + 1; // 1-based parameter value
expectedChannelValue = chanFunction;
} else {
expectedParameterValue = 0; // 0 signals no mapping
expectedChannelValue = PX4RCCalibration::_chanMax;
}
if (validateMask & validateMappingMask) {
QCOMPARE(mapParamsSet.contains(PX4RCCalibration::_rgFunctionInfo[chanFunction].parameterName), true);
QCOMPARE(mapParamsSet[PX4RCCalibration::_rgFunctionInfo[chanFunction].parameterName].toInt(), expectedParameterValue);
}
}
// Validate the channel settings. Note the channels are 1-based in parameter names.
for (int chan = 0; chan<PX4RCCalibration::_chanMax; chan++) {
int oneBasedChannel = chan + 1;
int rcMinExpected, rcMaxExpected, rcTrimExpected;
bool convertOk;
// Required channels have min/max set on them. Remaining channels are left to default.
if (chan < PX4RCCalibration::_chanMinimum) {
rcMinExpected = _testMinValue;
rcMaxExpected = _testMaxValue;
} else {
rcMinExpected = PX4RCCalibration::_rcCalPWMDefaultMinValue;
rcMaxExpected = PX4RCCalibration::_rcCalPWMDefaultMaxValue;
}
// Attitude control functions have trim set, other channels trim should be default
if (chan >= PX4RCCalibration::rcCalFunctionFirstAttitudeFunction && chan <= PX4RCCalibration::rcCalFunctionLastAttitudeFunction) {
if (chan == PX4RCCalibration::rcCalFunctionThrottle) {
rcTrimExpected = _testThrottleTrimValue;
} else {
rcTrimExpected = _testTrimValue;
}
} else {
rcTrimExpected = PX4RCCalibration::_rcCalPWMDefaultTrimValue;
}
if (validateMask & validateMinMaxMask) {
QCOMPARE(mapParamsSet.contains(minTpl.arg(chan)), true);
QCOMPARE(mapParamsSet[minTpl.arg(chan)].toInt(), PX4RCCalibration::_rcCalPWMValidMinValue);
QCOMPARE(mapParamsSet.contains(maxTpl.arg(chan)), true);
QCOMPARE(mapParamsSet[maxTpl.arg(chan)].toInt(), PX4RCCalibration::_rcCalPWMValidMaxValue);
QCOMPARE(mapParamsSet.contains(minTpl.arg(oneBasedChannel)), true);
QCOMPARE(mapParamsSet.contains(maxTpl.arg(oneBasedChannel)), true);
QCOMPARE(mapParamsSet[minTpl.arg(oneBasedChannel)].toInt(&convertOk), rcMinExpected);
QCOMPARE(convertOk, true);
QCOMPARE(mapParamsSet[maxTpl.arg(oneBasedChannel)].toInt(&convertOk), rcMaxExpected);
QCOMPARE(convertOk, true);
}
if (validateMask & validateTrimsMask) {
QCOMPARE(mapParamsSet.contains(trimTpl.arg(oneBasedChannel)), true);
QCOMPARE(mapParamsSet[trimTpl.arg(oneBasedChannel)].toInt(&convertOk), rcTrimExpected);
QCOMPARE(convertOk, true);
}
// No channels are reversed
if (validateMask & validateReversedMask) {
QCOMPARE(mapParamsSet.contains(revTpl.arg(chan)), true);
QCOMPARE(mapParamsSet[revTpl.arg(chan)].toFloat(), 1.0f /* not reversed */);
QCOMPARE(mapParamsSet.contains(revTpl.arg(oneBasedChannel)), true);
QCOMPARE(mapParamsSet[revTpl.arg(oneBasedChannel)].toFloat(&convertOk), 1.0f /* not reversed */);
QCOMPARE(convertOk, true);
}
}
if (validateMask & validateMappingMask) {
// Check mapping for all fuctions
for (int chanFunction=0; chanFunction<PX4RCCalibration::rcCalFunctionMax; chanFunction++) {
// All functions should be mapped to the same channel index
QCOMPARE(mapParamsSet.contains(PX4RCCalibration::_rgFunctionInfo[chanFunction].parameterName), true);
// We only map the required functions
int expectedValue;
if (skipOptional && !PX4RCCalibration::_rgFunctionInfo[chanFunction].required) {
expectedValue = 0; // 0 signals no mapping
} else {
if (PX4RCCalibration::_rgFunctionInfo[chanFunction].required) {
// All functions should be mapped to the same channel index
expectedValue = chanFunction + 1; // 1-based
} else {
expectedValue = 0; // 0 signals no mapping
}
QCOMPARE(mapParamsSet[PX4RCCalibration::_rgFunctionInfo[chanFunction].parameterName].toInt(), expectedValue);
}
}
}
if (validateMask & validateTrimsMask) {
// Trims should be set for all Control Functions
for (int chanFunction=0; chanFunction<PX4RCCalibration::rcCalFunctionMax; chanFunction++) {
// For the unit test the function index == mapped channel. Also parameter name is 1-based.
int mappedChannel = chanFunction + 1;
void PX4RCCalibrationTest::_validateWidgets(int validateMask, const struct ChannelSettings* rgChannelSettings)
{
// Radio channel widgets should be displaying the current min/max we just set. Wait a bit for ui to update before checking.
QCOMPARE(mapParamsSet.contains(trimTpl.arg(mappedChannel)), true);
QTest::qWait(PX4RCCalibration::_updateInterval * 2);
int trimValue;
if (chanFunction == PX4RCCalibration::rcCalFunctionThrottle) {
trimValue = PX4RCCalibration::_rcCalPWMValidMinValue;
} else {
trimValue = PX4RCCalibration::_rcCalPWMCenterPoint;
}
QCOMPARE(mapParamsSet[trimTpl.arg(mappedChannel)].toInt(), trimValue);
for (int chan=0; chan<_availableChannels; chan++) {
RCChannelWidget* radioWidget = _rgRadioWidget[chan];
Q_ASSERT(radioWidget);
if (validateMask & validateMinMaxMask) {
QCOMPARE(radioWidget->isMinMaxShown(), rgChannelSettings[chan].isMinMaxShown);
QCOMPARE(radioWidget->min(), rgChannelSettings[chan].rcMin);
QCOMPARE(radioWidget->max(), rgChannelSettings[chan].rcMax);
QCOMPARE(radioWidget->isMinValid(), rgChannelSettings[chan].isMinValid);
QCOMPARE(radioWidget->isMaxValid(), rgChannelSettings[chan].isMaxValid);
}
if (validateMask & validateTrimsMask) {
QCOMPARE(radioWidget->trim(), rgChannelSettings[chan].rcTrim);
}
}
for (int chan=_availableChannels; chan<=PX4RCCalibration::_chanMax; chan++) {
QCOMPARE(_rgRadioWidget[chan]->isEnabled(), false);
}
}

55
src/qgcunittest/PX4RCCalibrationTest.h
Unescape View File

@ -30,10 +30,11 @@ @@ -30,10 +30,11 @@
#include "px4_configuration/PX4RCCalibration.h"
/// @file
/// @brief QGCPX4RCCAlibration Widget unit test
/// @brief PX4RCCalibration Widget unit test
///
/// @author Don Gagne <don@thegagnes.com>
/// @brief PX4RCCalibration Widget unit test
class PX4RCCalibrationTest : public QObject
{
Q_OBJECT
@ -42,6 +43,7 @@ public: @@ -42,6 +43,7 @@ public:
PX4RCCalibrationTest(void);
private slots:
void initTestCase(void);
void init(void);
void cleanup(void);
@ -50,7 +52,6 @@ private slots: @@ -50,7 +52,6 @@ private slots:
//void _liveRC_test(void);
void _beginState_test(void);
void _identifyState_test(void);
void _identifyStateSkipOptional_test(void);
void _minMaxState_test(void);
void _centerThrottleState_test(void);
void _detectInversionState_test(void);
@ -58,13 +59,20 @@ private slots: @@ -58,13 +59,20 @@ private slots:
void _fullCalibration_test(void);
private:
void _centerAllChannels(void);
void _beginState_worker(bool standaloneTest);
void _identifyState_worker(bool standaloneTest, bool skipOptional);
void _minMaxState_worker(bool standaloneTest);
void _centerThrottleState_worker(bool standaloneTest);
void _detectInversionState_worker(bool standaloneTest);
void _trimsState_worker(bool standaloneTest);
/// @brief Modes to run worker functions
enum TestMode {
testModeStandalone, ///< Perform standalone test of calibration state
testModePrerequisite, ///< Setup prequisites for subsequent calibration state
testModeFullSequence, ///< Run as full calibration sequence
};
void _centerChannels(void);
void _beginState_worker(enum TestMode mode);
void _identifyState_worker(enum TestMode mode);
void _minMaxState_worker(enum TestMode mode);
void _centerThrottleState_worker(enum TestMode mode);
void _detectInversionState_worker(enum TestMode mode);
void _trimsState_worker(enum TestMode mode);
enum {
validateMinMaxMask = 1 << 0,
@ -73,7 +81,19 @@ private: @@ -73,7 +81,19 @@ private:
validateMappingMask = 1 << 3,
validateAllMask = 0xFFFF
};
void _validateParameters(int validateMask, bool skipOptional = false);
struct ChannelSettings {
int rcMin;
int rcMax;
int rcTrim;
int reversed;
bool isMinMaxShown;
bool isMinValid;
bool isMaxValid;
};
void _validateParameters(int validateMask);
void _validateWidgets(int validateMask, const struct ChannelSettings* rgChannelSettings);
MockUASManager* _mockUASManager;
MockUAS* _mockUAS;
@ -94,6 +114,21 @@ private: @@ -94,6 +114,21 @@ private:
QLabel* _statusLabel;
RCChannelWidget* _rgRadioWidget[PX4RCCalibration::_chanMax];
// When settings values into min/max/trim we set them slightly different than the defaults so that
// we can distinguish between the two values.
static const int _testMinValue;
static const int _testMaxValue;
static const int _testTrimValue;
static const int _testThrottleTrimValue;
static const int _availableChannels = 8; ///< 8 channel RC Trasmitter
static const int _requiredChannels = 5; ///< Required channels are 0-4
static const int _minMaxChannels = _requiredChannels + 1; ///< Send min/max to channels 0-5
static const int _attitudeChannels = 4; ///< Attitude channels are 0-3
static const struct ChannelSettings _rgChannelSettingsPreValidate[_availableChannels];
static const struct ChannelSettings _rgChannelSettingsPostValidate[PX4RCCalibration::_chanMax];
};
DECLARE_TEST(PX4RCCalibrationTest)

108
src/ui/px4_configuration/PX4RCCalibration.cc
Unescape View File

@ -31,13 +31,16 @@ @@ -31,13 +31,16 @@
#include "PX4RCCalibration.h"
#include "UASManager.h"
const int PX4RCCalibration::_updateInterval = 150; ///< Interval for timer which updates radio channel widgets
const int PX4RCCalibration::_rcCalPWMValidMinValue = 1000;
const int PX4RCCalibration::_rcCalPWMValidMaxValue = 2000;
const int PX4RCCalibration::_updateInterval = 150; ///< Interval for timer which updates radio channel widgets
const int PX4RCCalibration::_rcCalPWMCenterPoint = ((PX4RCCalibration::_rcCalPWMValidMaxValue - PX4RCCalibration::_rcCalPWMValidMinValue) / 2.0f) + PX4RCCalibration::_rcCalPWMValidMinValue;
const int PX4RCCalibration::_rcCalRoughCenterDelta = 200; ///< Delta around center point which is considered to be roughly centered
const float PX4RCCalibration::_rcCalMoveDelta = 300.0f; ///< Amount of delta which is considered stick movement
const float PX4RCCalibration::_rcCalMinDelta = 100.0f; ///< Amount of delta allowed around min value to consider channel at min
const int PX4RCCalibration::_rcCalPWMValidMinValue = 1300; ///< Largest valid minimum PWM Min range value
const int PX4RCCalibration::_rcCalPWMValidMaxValue = 1700; ///< Smallest valid maximum PWM Max range value
const int PX4RCCalibration::_rcCalPWMDefaultMinValue = 1000; ///< Default value for Min if not set
const int PX4RCCalibration::_rcCalPWMDefaultMaxValue = 2000; ///< Default value for Max if not set
const int PX4RCCalibration::_rcCalPWMDefaultTrimValue = PX4RCCalibration::_rcCalPWMCenterPoint; ///< Default value for Trim if not set
const int PX4RCCalibration::_rcCalRoughCenterDelta = 200; ///< Delta around center point which is considered to be roughly centered
const float PX4RCCalibration::_rcCalMoveDelta = 300.0f; ///< Amount of delta which is considered stick movement
const float PX4RCCalibration::_rcCalMinDelta = 100.0f; ///< Amount of delta allowed around min value to consider channel at min
const struct PX4RCCalibration::FunctionInfo PX4RCCalibration::_rgFunctionInfo[PX4RCCalibration::rcCalFunctionMax] = {
// Name Inversion Message Parameter required
@ -274,6 +277,31 @@ void PX4RCCalibration::_setActiveUAS(UASInterface* active) @@ -274,6 +277,31 @@ void PX4RCCalibration::_setActiveUAS(UASInterface* active)
setEnabled(_mav ? true : false);
}
/// @brief Validates the current settings against the calibration rules resetting values as necessary.
void PX4RCCalibration::_validateCalibration(void)
{
for (int chan = 0; chan<_chanMax; chan++) {
struct ChannelInfo* info = &_rgChannelInfo[chan];
if (chan < _chanCount) {
// Validate Min/Max values. Although the channel appears as available we still may
// not have good min/max/trim values for it. Set to defaults if needed.
if (info->rcMin > _rcCalPWMValidMinValue || info->rcMax < _rcCalPWMValidMaxValue) {
info->rcMin = _rcCalPWMDefaultMinValue;
info->rcMax = _rcCalPWMDefaultMaxValue;
info->rcTrim = _rcCalPWMDefaultTrimValue;
}
} else {
// Unavailable channels are set to defaults
info->rcMin = _rcCalPWMDefaultMinValue;
info->rcMax = _rcCalPWMDefaultMaxValue;
info->rcTrim = _rcCalPWMDefaultTrimValue;
info->reversed = false;
}
}
}
/// @brief Saves the rc calibration values to the board parameters.
/// @param trimsOnly true: write only trim values, false: write all calibration values
void PX4RCCalibration::_writeCalibration(bool trimsOnly)
@ -282,6 +310,8 @@ void PX4RCCalibration::_writeCalibration(bool trimsOnly) @@ -282,6 +310,8 @@ void PX4RCCalibration::_writeCalibration(bool trimsOnly)
_mav->endRadioControlCalibration();
_validateCalibration();
QGCUASParamManagerInterface* paramMgr = _mav->getParamManager();
Q_ASSERT(paramMgr);
@ -290,17 +320,14 @@ void PX4RCCalibration::_writeCalibration(bool trimsOnly) @@ -290,17 +320,14 @@ void PX4RCCalibration::_writeCalibration(bool trimsOnly)
QString trimTpl("RC%1_TRIM");
QString revTpl("RC%1_REV");
// Do not write the RC type, as these values depend on this
// active onboard parameter
for (int i = 0; i < _chanCount; ++i) {
struct ChannelInfo* info = &_rgChannelInfo[i];
paramMgr->setPendingParam(0, trimTpl.arg(i+1), info->rcTrim);
for (int chan = 0; chan<_chanMax; chan++) {
struct ChannelInfo* info = &_rgChannelInfo[chan];
int oneBasedChannel = chan + 1;
paramMgr->setPendingParam(0, trimTpl.arg(oneBasedChannel), info->rcTrim);
if (!trimsOnly) {
paramMgr->setPendingParam(0, minTpl.arg(i+1), info->rcMin);
paramMgr->setPendingParam(0, maxTpl.arg(i+1), info->rcMax);
paramMgr->setPendingParam(0, revTpl.arg(i+1), info->reversed ? -1.0f : 1.0f);
paramMgr->setPendingParam(0, minTpl.arg(oneBasedChannel), info->rcMin);
paramMgr->setPendingParam(0, maxTpl.arg(oneBasedChannel), info->rcMax);
paramMgr->setPendingParam(0, revTpl.arg(oneBasedChannel), info->reversed ? -1.0f : 1.0f);
}
}
@ -355,13 +382,7 @@ void PX4RCCalibration::_remoteControlChannelRawChanged(int chan, float fval) @@ -355,13 +382,7 @@ void PX4RCCalibration::_remoteControlChannelRawChanged(int chan, float fval)
case rcCalStateIdentify:
if (!_rcCalStateChannelComplete) {
// If this channel is already used in a mapping we can't used it again
bool channelAlreadyMapped = false;
for (int chanFunction=0; chanFunction<rcCalFunctionMax; chanFunction++) {
if (_rgFunctionChannelMapping[chanFunction] == chan) {
channelAlreadyMapped = true;
break;
}
}
bool channelAlreadyMapped = !(_rgChannelInfo[chan].function == rcCalFunctionMax);
// If the channel moved considerably, pick it
if (!channelAlreadyMapped && fabsf(_rcValueSave[chan] - fval) > _rcCalMoveDelta) {
@ -383,10 +404,12 @@ void PX4RCCalibration::_remoteControlChannelRawChanged(int chan, float fval) @@ -383,10 +404,12 @@ void PX4RCCalibration::_remoteControlChannelRawChanged(int chan, float fval)
break;
case rcCalStateMinMax:
if (fval < _rgChannelInfo[chan].rcMin) {
if (fval < _rgChannelInfo[chan].rcMin && fval <= _rcCalPWMValidMinValue) {
_rgRadioWidget[chan]->setMinValid(true);
_rgChannelInfo[chan].rcMin = fval;
}
if (fval > _rgChannelInfo[chan].rcMax) {
if (fval > _rgChannelInfo[chan].rcMax && fval >= _rcCalPWMValidMaxValue) {
_rgRadioWidget[chan]->setMaxValid(true);
_rgChannelInfo[chan].rcMax = fval;
}
break;
@ -572,7 +595,11 @@ void PX4RCCalibration::_rcCalChannelWait(bool firstTime) @@ -572,7 +595,11 @@ void PX4RCCalibration::_rcCalChannelWait(bool firstTime)
{
_rcCalState = rcCalStateChannelWait;
_resetInternalCalibrationValues();
if (firstTime) {
_resetInternalCalibrationValues();
} else {
_setInternalCalibrationValuesFromParameters();
}
if (_chanCount == 0) {
_ui->rcCalFound->setText(tr("Please turn on Radio"));
@ -741,18 +768,9 @@ void PX4RCCalibration::_rcCalTrims(void) @@ -741,18 +768,9 @@ void PX4RCCalibration::_rcCalTrims(void)
_ui->rcCalSkip->setEnabled(false);
_ui->rcCalCancel->setEnabled(true);
_initializeTrims();
_showTrimOnRadioWidgets(true);
}
/// @brief Initializes the trim values based on current min/max.
void PX4RCCalibration::_initializeTrims(void)
{
for (int chan=0; chan<=_chanMax; chan++) {
_rgChannelInfo[chan].rcTrim = ((_rgChannelInfo[chan].rcMax - _rgChannelInfo[chan].rcMin) / 2.0f) + _rgChannelInfo[chan].rcMin;
}
}
/// @brief Set up the Save state of calibration.
void PX4RCCalibration::_rcCalSave(void)
{
@ -766,6 +784,12 @@ void PX4RCCalibration::_rcCalSave(void) @@ -766,6 +784,12 @@ void PX4RCCalibration::_rcCalSave(void)
_ui->rcCalTryAgain->setEnabled(false);
_ui->rcCalSkip->setEnabled(false);
_ui->rcCalCancel->setEnabled(true);
// This updates the internal values according to the validation rules. Then _updateView will tick and update ui
// such that the settings that will be written our are displayed.
_validateCalibration();
_showMinMaxOnRadioWidgets(true);
}
/// @brief This is used by unit test code to force the calibration state machine to the specified state.
@ -811,12 +835,26 @@ void PX4RCCalibration::_unitTestForceCalState(enum rcCalStates state) { @@ -811,12 +835,26 @@ void PX4RCCalibration::_unitTestForceCalState(enum rcCalStates state) {
/// @param show true: show the min/max values, false: hide the min/max values
void PX4RCCalibration::_showMinMaxOnRadioWidgets(bool show)
{
// Force a view update to widget have current values
_updateView();
// Turn on min/max display for all radio widgets
for (int i=0; i<_chanMax; i++) {
RCChannelWidget* radioWidget = _rgRadioWidget[i];
Q_ASSERT(radioWidget);
radioWidget->showMinMax(show);
if (show) {
if (radioWidget->min() <= _rcCalPWMValidMinValue) {
radioWidget->setMinValid(true);
}
if (radioWidget->max() >= _rcCalPWMValidMaxValue) {
radioWidget->setMaxValid(true);
}
} else {
radioWidget->setMinValid(false);
radioWidget->setMaxValid(false);
}
}
}

17
src/ui/px4_configuration/PX4RCCalibration.h
Unescape View File

@ -124,10 +124,10 @@ private: @@ -124,10 +124,10 @@ private:
// Methods - see source code for documentation
void _validateCalibration(void);
void _writeCalibration(bool trimsOnly);
void _resetInternalCalibrationValues(void);
void _setInternalCalibrationValuesFromParameters(void);
void _initializeTrims(void);
void _rcCalChannelWait(bool firstTime);
void _rcCalBegin(void);
@ -164,12 +164,15 @@ private: @@ -164,12 +164,15 @@ private:
int _rcCalStateIdentifyOldMapping; ///< Previous mapping for channel being currently identified
int _rcCalStateReverseOldMapping; ///< Previous mapping for channel being currently used to detect inversion
static const int _rcCalPWMCenterPoint; ///< PWM center value;
static const int _rcCalPWMValidMinValue; ///< Valid minimum PWM value
static const int _rcCalPWMValidMaxValue; ///< Valid maximum PWM value
static const int _rcCalRoughCenterDelta; ///< Delta around center point which is considered to be roughly centered
static const float _rcCalMoveDelta; ///< Amount of delta which is considered stick movement
static const float _rcCalMinDelta; ///< Amount of delta allowed around min value to consider channel at min
static const int _rcCalPWMCenterPoint;
static const int _rcCalPWMValidMinValue;
static const int _rcCalPWMValidMaxValue;
static const int _rcCalPWMDefaultMinValue;
static const int _rcCalPWMDefaultMaxValue;
static const int _rcCalPWMDefaultTrimValue;
static const int _rcCalRoughCenterDelta;
static const float _rcCalMoveDelta;
static const float _rcCalMinDelta;
float _rcValueSave[_chanMax]; ///< Saved values prior to detecting channel movement

Write Preview
Loading…
Cancel
Save