diff --git a/Makefile b/Makefile index 45d8554ce..f18e3efbd 100644 --- a/Makefile +++ b/Makefile @@ -81,8 +81,10 @@ $(foreach var, $(SANITIZE_DEPRECATED_VARS), $(eval $(call SANITIZE_VAR,$(var),de # Make sure this isn't being run as root unless installing (no whoami on Windows, but that is ok here) ifeq ($(shell whoami 2>/dev/null),root) - ifeq ($(filter install all_clean,$(MAKECMDGOALS)),) - $(error You should not be running this as root) + ifeq ($(filter install,$(MAKECMDGOALS)),) + ifndef FAKEROOTKEY + $(error You should not be running this as root) + endif endif endif @@ -785,15 +787,19 @@ endif # - calls paltform-specific packaging script # Define some variables -export PACKAGE_LBL := $(shell $(VERSION_INFO) --format=\$${LABEL}) -export PACKAGE_NAME := OpenPilot -export PACKAGE_SEP := - +PACKAGE_LBL := $(shell $(VERSION_INFO) --format=\$${LABEL}) +PACKAGE_NAME := OpenPilot +PACKAGE_SEP := - +PACKAGE_FULL_NAME := $(PACKAGE_NAME)$(PACKAGE_SEP)$(PACKAGE_LBL) + +# Source distribution is never dirty because it uses git archive +DIST_NAME := $(DIST_DIR)/$(subst dirty-,,$(PACKAGE_FULL_NAME)).tar .PHONY: package include $(ROOT_DIR)/package/$(UNAME).mk -package: all_fw all_ground uavobjects_matlab $(PACKAGE_DIR) +package: all_fw all_ground uavobjects_matlab | $(PACKAGE_DIR) ifneq ($(GCS_BUILD_CONF),release) # We can only package release builds $(error Packaging is currently supported for release builds only) @@ -882,20 +888,20 @@ build-info: DIST_VER_INFO := $(DIST_DIR)/version-info.json -.PHONY: $(DIST_VER_INFO) # Because to many deps to list -$(DIST_VER_INFO): $(DIST_DIR) +$(DIST_VER_INFO): .git/index | $(DIST_DIR) $(V1) $(VERSION_INFO) --jsonpath="$(DIST_DIR)" -.PHONY: dist -dist: $(DIST_DIR) $(DIST_VER_INFO) - @$(ECHO) " SOURCE FOR DISTRIBUTION $(call toprel, $(DIST_DIR))" - $(eval DIST_NAME := $(call toprel, "$(DIST_DIR)/OpenPilot-$(shell git describe).tar")) - $(V1) git archive --prefix="OpenPilot/" -o "$(DIST_NAME)" HEAD + +$(DIST_NAME).gz: $(DIST_VER_INFO) .git/index | $(DIST_DIR) + @$(ECHO) " SOURCE FOR DISTRIBUTION $(call toprel, $(DIST_NAME).gz)" + $(V1) git archive --prefix="$(PACKAGE_NAME)/" -o "$(DIST_NAME)" HEAD $(V1) tar --append --file="$(DIST_NAME)" \ - --transform='s,.*version-info.json,OpenPilot/version-info.json,' \ + --transform='s,.*version-info.json,$(PACKAGE_NAME)/version-info.json,' \ $(call toprel, "$(DIST_VER_INFO)") $(V1) gzip -f "$(DIST_NAME)" +.PHONY: dist +dist: $(DIST_NAME).gz ############################## # diff --git a/WHATSNEW.txt b/WHATSNEW.txt index 456ae5ef2..b0fae48e4 100644 --- a/WHATSNEW.txt +++ b/WHATSNEW.txt @@ -1,4 +1,4 @@ ---- RELEASE-15.02 RC5 +--- RELEASE-15.02 --- Ragin' Cajun --- This release introduces major flight performance improvements, enhancements as well as bug fixes. Many enhancements have been made to reducing dead-time of the communication between the flight controller and ESCs. In our testing, we have found this to be not only the best flight performance so far in the OpenPilot project but the best flight performance of any project we have tested against. This is a recommended upgrade for everyone and the more skilled of a pilot you are, the more you will love this release. A key improvement that helped achieve this was the addition of the PWMSync code path, this is now enabled by default. Some restrictions applies to CC3D/CC as it needs a compatible input method to enable PWMSync. Compatible input methods are PPM, S.Bus, DSM and OPLink. This release also introduces support for OneShot125 capable ESCs, such as the KISS ESCs and all ESCs supported in BLHeli V13 and above. Note that OneShot125 support has the same restrictions as PWMSync for CC and CC3D. @@ -8,14 +8,15 @@ Note for CC3D/CC: To support PWMSync/OneShot125 PPM input pin has changed from e Other enhancements include key parts of the GCS translated to Chinese and further OPLink reliability additions allowing us to confidently say it can be used as a primary control link as well as for telemetry. The full list of features, improvements and bugfixes in this release is accessible here: -https://progress.openpilot.org/issues/?filter=12161 +https://progress.openpilot.org/issues/?filter=12161 Release Notes - OpenPilot - Version RELEASE-15.02 ** Bug * [OP-969] - Input Configuration Wizard has scrollbars showing up and next/previous buttons are pushed down out of sight * [OP-1034] - CCPM Config Widget crashes GCS if required boxes aren't set i.e. Channel set to None + * [OP-1236] - Icons on Welcome tab - moves to the left * [OP-1466] - Gcs crashes on Helicopter config tab * [OP-1522] - Improve Robustness of OPLink radio * [OP-1601] - Still not enough ram on CC for gps to be usable @@ -38,6 +39,8 @@ Release Notes - OpenPilot - Version RELEASE-15.02 * [OP-1755] - Add additional path for cloudconfigs * [OP-1758] - Upgrade hidapi for all OSs (except windows) to solve mac issue:Fix incorrect device list after device removal * [OP-1761] - Wizard bad config when PPM in, RapidESC out and hexa frame with CC/CC3D/Atom + * [OP-1764] - System should sanity check RC Input Channel value ranges and raise alarm accordingly + * [OP-1768] - PWM Sync and OneShot125 wizard output level and warning are incorrect ** Improvement @@ -60,13 +63,13 @@ Release Notes - OpenPilot - Version RELEASE-15.02 ** Task * [OP-1721] - C++ enable flight controller and upgrade ARM tools * [OP-1738] - change default flight modes and thrust settings + * [OP-1747] - 15.02 rc1 motor end points do not reflect oneshot125 / pwmsync ** Sub task * [OP-1748] - Chinese translation for 15.02 * [OP-1752] - Add Alarm sub status to SystemHealth - --- RELEASE-15.01 --- Look Ma, No hands --- This release mainly focuses on a new feature, GPSAssist which is a new form of assisted control for multirotors. Assisted Control provides assistance functions on top of existing flight modes. GPSAssist is the diff --git a/flight/libraries/sanitycheck.c b/flight/libraries/sanitycheck.c index 13bca13be..a55a05a70 100644 --- a/flight/libraries/sanitycheck.c +++ b/flight/libraries/sanitycheck.c @@ -43,7 +43,8 @@ #include // a number of useful macros -#define ADDSEVERITY(check) severity = (severity != SYSTEMALARMS_ALARM_OK ? severity : ((check) ? SYSTEMALARMS_ALARM_OK : SYSTEMALARMS_ALARM_CRITICAL)) +#define ADDSEVERITY(check) severity = (severity != SYSTEMALARMS_ALARM_OK ? severity : ((check) ? SYSTEMALARMS_ALARM_OK : SYSTEMALARMS_ALARM_CRITICAL)) +#define ADDEXTENDEDALARMSTATUS(error_code, error_substatus) if ((severity != SYSTEMALARMS_ALARM_OK) && (alarmstatus == SYSTEMALARMS_EXTENDEDALARMSTATUS_NONE)) { alarmstatus = (error_code); alarmsubstatus = (error_substatus); } // private types typedef struct SANITYCHECK_CustomHookInstance { @@ -178,6 +179,27 @@ int32_t configuration_check() } } + + // Check throttle/collective channel range for valid configuration of input for critical control + SystemSettingsThrustControlOptions thrustType; + SystemSettingsThrustControlGet(&thrustType); + ManualControlSettingsChannelMinData channelMin; + ManualControlSettingsChannelMaxData channelMax; + ManualControlSettingsChannelMinGet(&channelMin); + ManualControlSettingsChannelMaxGet(&channelMax); + switch (thrustType) { + case SYSTEMSETTINGS_THRUSTCONTROL_THROTTLE: + ADDSEVERITY(fabsf(channelMax.Throttle - channelMin.Throttle) > 300.0f); + ADDEXTENDEDALARMSTATUS(SYSTEMALARMS_EXTENDEDALARMSTATUS_BADTHROTTLEORCOLLECTIVEINPUTRANGE, 0); + break; + case SYSTEMSETTINGS_THRUSTCONTROL_COLLECTIVE: + ADDSEVERITY(fabsf(channelMax.Collective - channelMin.Collective) > 300.0f); + ADDEXTENDEDALARMSTATUS(SYSTEMALARMS_EXTENDEDALARMSTATUS_BADTHROTTLEORCOLLECTIVEINPUTRANGE, 0); + break; + default: + break; + } + // query sanity check hooks if (severity < SYSTEMALARMS_ALARM_CRITICAL) { SANITYCHECK_CustomHookInstance *instance = NULL; diff --git a/flight/modules/Actuator/actuator.c b/flight/modules/Actuator/actuator.c index e6789f7dd..4e795027b 100644 --- a/flight/modules/Actuator/actuator.c +++ b/flight/modules/Actuator/actuator.c @@ -45,6 +45,11 @@ #include "cameradesired.h" #include "manualcontrolcommand.h" #include "taskinfo.h" +#include +#include +#ifndef PIOS_EXCLUDE_ADVANCED_FEATURES +#include +#endif #undef PIOS_INCLUDE_INSTRUMENTATION #ifdef PIOS_INCLUDE_INSTRUMENTATION #include @@ -76,26 +81,33 @@ static int8_t counter; // Private variables static xQueueHandle queue; static xTaskHandle taskHandle; +static FrameType_t frameType = FRAME_TYPE_MULTIROTOR; +static SystemSettingsThrustControlOptions thrustType = SYSTEMSETTINGS_THRUSTCONTROL_THROTTLE; static float lastResult[MAX_MIX_ACTUATORS] = { 0 }; static float filterAccumulator[MAX_MIX_ACTUATORS] = { 0 }; static uint8_t pinsMode[MAX_MIX_ACTUATORS]; // used to inform the actuator thread that actuator update rate is changed -static volatile bool actuator_settings_updated; +static ActuatorSettingsData actuatorSettings; +static bool spinWhileArmed; + // used to inform the actuator thread that mixer settings are changed -static volatile bool mixer_settings_updated; +static MixerSettingsData mixerSettings; +static int mixer_settings_count = 2; // Private functions static void actuatorTask(void *parameters); static int16_t scaleChannel(float value, int16_t max, int16_t min, int16_t neutral); -static void setFailsafe(const ActuatorSettingsData *actuatorSettings, const MixerSettingsData *mixerSettings); -static float MixerCurve(const float throttle, const float *curve, uint8_t elements); -static bool set_channel(uint8_t mixer_channel, uint16_t value, const ActuatorSettingsData *actuatorSettings); -static void actuator_update_rate_if_changed(const ActuatorSettingsData *actuatorSettings, bool force_update); +static void setFailsafe(); +static float MixerCurveFullRangeProportional(const float input, const float *curve, uint8_t elements); +static float MixerCurveFullRangeAbsolute(const float input, const float *curve, uint8_t elements); +static bool set_channel(uint8_t mixer_channel, uint16_t value); +static void actuator_update_rate_if_changed(bool force_update); static void MixerSettingsUpdatedCb(UAVObjEvent *ev); static void ActuatorSettingsUpdatedCb(UAVObjEvent *ev); +static void SettingsUpdatedCb(UAVObjEvent *ev); float ProcessMixer(const int index, const float curve1, const float curve2, - const MixerSettingsData *mixerSettings, ActuatorDesiredData *desired, + ActuatorDesiredData *desired, const float period); // this structure is equivalent to the UAVObjects for one mixer. @@ -116,6 +128,9 @@ int32_t ActuatorStart() #ifdef PIOS_INCLUDE_WDG PIOS_WDG_RegisterFlag(PIOS_WDG_ACTUATOR); #endif + SettingsUpdatedCb(NULL); + MixerSettingsUpdatedCb(NULL); + ActuatorSettingsUpdatedCb(NULL); return 0; } @@ -149,6 +164,13 @@ int32_t ActuatorInitialize() MixerStatusInitialize(); #endif +#ifndef PIOS_EXCLUDE_ADVANCED_FEATURES + VtolPathFollowerSettingsInitialize(); + VtolPathFollowerSettingsConnectCallback(&SettingsUpdatedCb); +#endif + SystemSettingsInitialize(); + SystemSettingsConnectCallback(&SettingsUpdatedCb); + return 0; } MODULE_INITCALL(ActuatorInitialize, ActuatorStart); @@ -178,7 +200,6 @@ static void actuatorTask(__attribute__((unused)) void *parameters) ActuatorDesiredData desired; MixerStatusData mixerStatus; FlightStatusData flightStatus; - SystemSettingsThrustControlOptions thrustType; float throttleDesired; float collectiveDesired; @@ -186,21 +207,17 @@ static void actuatorTask(__attribute__((unused)) void *parameters) counter = PIOS_Instrumentation_CreateCounter(0xAC700001); #endif /* Read initial values of ActuatorSettings */ - ActuatorSettingsData actuatorSettings; - actuator_settings_updated = false; ActuatorSettingsGet(&actuatorSettings); /* Read initial values of MixerSettings */ - MixerSettingsData mixerSettings; - mixer_settings_updated = false; MixerSettingsGet(&mixerSettings); /* Force an initial configuration of the actuator update rates */ - actuator_update_rate_if_changed(&actuatorSettings, true); + actuator_update_rate_if_changed(true); // Go to the neutral (failsafe) values until an ActuatorDesired update is received - setFailsafe(&actuatorSettings, &mixerSettings); + setFailsafe(); // Main task loop lastSysTime = xTaskGetTickCount(); @@ -214,20 +231,10 @@ static void actuatorTask(__attribute__((unused)) void *parameters) #ifdef PIOS_INCLUDE_INSTRUMENTATION PIOS_Instrumentation_TimeStart(counter); #endif - /* Process settings updated events even in timeout case so we always act on the latest settings */ - if (actuator_settings_updated) { - actuator_settings_updated = false; - ActuatorSettingsGet(&actuatorSettings); - actuator_update_rate_if_changed(&actuatorSettings, false); - } - if (mixer_settings_updated) { - mixer_settings_updated = false; - MixerSettingsGet(&mixerSettings); - } if (rc != pdTRUE) { /* Update of ActuatorDesired timed out. Go to failsafe */ - setFailsafe(&actuatorSettings, &mixerSettings); + setFailsafe(); continue; } @@ -240,7 +247,6 @@ static void actuatorTask(__attribute__((unused)) void *parameters) FlightStatusGet(&flightStatus); ActuatorDesiredGet(&desired); ActuatorCommandGet(&command); - SystemSettingsThrustControlGet(&thrustType); // read in throttle and collective -demultiplex thrust switch (thrustType) { @@ -258,12 +264,15 @@ static void actuatorTask(__attribute__((unused)) void *parameters) } bool armed = flightStatus.Armed == FLIGHTSTATUS_ARMED_ARMED; + bool activeThrottle = (throttleDesired < -0.001f || throttleDesired > 0.001f); // for ground and reversible motors + bool positiveThrottle = (throttleDesired > 0.00f); // safety settings if (!armed) { throttleDesired = 0; } - if (throttleDesired <= 0.00f || !armed) { + + if ((frameType == FRAME_TYPE_GROUND && !activeThrottle) || (frameType != FRAME_TYPE_GROUND && throttleDesired <= 0.00f) || !armed) { // force set all other controls to zero if throttle is cut (previously set in Stabilization) if (actuatorSettings.LowThrottleZeroAxis.Roll == ACTUATORSETTINGS_LOWTHROTTLEZEROAXIS_TRUE) { desired.Roll = 0; @@ -279,46 +288,47 @@ static void actuatorTask(__attribute__((unused)) void *parameters) #ifdef DIAG_MIXERSTATUS MixerStatusGet(&mixerStatus); #endif - int nMixers = 0; - Mixer_t *mixers = (Mixer_t *)&mixerSettings.Mixer1Type; - for (int ct = 0; ct < MAX_MIX_ACTUATORS; ct++) { - if (mixers[ct].type != MIXERSETTINGS_MIXER1TYPE_DISABLED) { - nMixers++; - } - } - if ((nMixers < 2) && !ActuatorCommandReadOnly()) { // Nothing can fly with less than two mixers. - setFailsafe(&actuatorSettings, &mixerSettings); // So that channels like PWM buzzer keep working + + if ((mixer_settings_count < 2) && !ActuatorCommandReadOnly()) { // Nothing can fly with less than two mixers. + setFailsafe(); continue; } AlarmsClear(SYSTEMALARMS_ALARM_ACTUATOR); - bool activeThrottle = (throttleDesired < 0.00f || throttleDesired > 0.00f); - bool positiveThrottle = (throttleDesired > 0.00f); - bool spinWhileArmed = actuatorSettings.MotorsSpinWhileArmed == ACTUATORSETTINGS_MOTORSSPINWHILEARMED_TRUE; + float curve1 = 0.0f; + float curve2 = 0.0f; - float curve1 = MixerCurve(throttleDesired, mixerSettings.ThrottleCurve1, MIXERSETTINGS_THROTTLECURVE1_NUMELEM); + // Interpolate curve 1 from throttleDesired as input. + // assume reversible motor/mixer initially. We can later reverse this. The difference is simply that -ve throttleDesired values + // map differently + curve1 = MixerCurveFullRangeProportional(throttleDesired, mixerSettings.ThrottleCurve1, MIXERSETTINGS_THROTTLECURVE1_NUMELEM); // The source for the secondary curve is selectable - float curve2 = 0; AccessoryDesiredData accessory; - switch (mixerSettings.Curve2Source) { + uint8_t curve2Source = mixerSettings.Curve2Source; + switch (curve2Source) { case MIXERSETTINGS_CURVE2SOURCE_THROTTLE: - curve2 = MixerCurve(throttleDesired, mixerSettings.ThrottleCurve2, MIXERSETTINGS_THROTTLECURVE2_NUMELEM); + // assume reversible motor/mixer initially + curve2 = MixerCurveFullRangeProportional(throttleDesired, mixerSettings.ThrottleCurve2, MIXERSETTINGS_THROTTLECURVE2_NUMELEM); break; case MIXERSETTINGS_CURVE2SOURCE_ROLL: - curve2 = MixerCurve(desired.Roll, mixerSettings.ThrottleCurve2, MIXERSETTINGS_THROTTLECURVE2_NUMELEM); + // Throttle curve contribution the same for +ve vs -ve roll + curve2 = MixerCurveFullRangeAbsolute(desired.Roll, mixerSettings.ThrottleCurve2, MIXERSETTINGS_THROTTLECURVE2_NUMELEM); break; case MIXERSETTINGS_CURVE2SOURCE_PITCH: - curve2 = MixerCurve(desired.Pitch, mixerSettings.ThrottleCurve2, - MIXERSETTINGS_THROTTLECURVE2_NUMELEM); + // Throttle curve contribution the same for +ve vs -ve pitch + curve2 = MixerCurveFullRangeAbsolute(desired.Pitch, mixerSettings.ThrottleCurve2, + MIXERSETTINGS_THROTTLECURVE2_NUMELEM); break; case MIXERSETTINGS_CURVE2SOURCE_YAW: - curve2 = MixerCurve(desired.Yaw, mixerSettings.ThrottleCurve2, MIXERSETTINGS_THROTTLECURVE2_NUMELEM); + // Throttle curve contribution the same for +ve vs -ve yaw + curve2 = MixerCurveFullRangeAbsolute(desired.Yaw, mixerSettings.ThrottleCurve2, MIXERSETTINGS_THROTTLECURVE2_NUMELEM); break; case MIXERSETTINGS_CURVE2SOURCE_COLLECTIVE: - curve2 = MixerCurve(collectiveDesired, mixerSettings.ThrottleCurve2, - MIXERSETTINGS_THROTTLECURVE2_NUMELEM); + // assume reversible motor/mixer initially + curve2 = MixerCurveFullRangeProportional(collectiveDesired, mixerSettings.ThrottleCurve2, + MIXERSETTINGS_THROTTLECURVE2_NUMELEM); break; case MIXERSETTINGS_CURVE2SOURCE_ACCESSORY0: case MIXERSETTINGS_CURVE2SOURCE_ACCESSORY1: @@ -327,14 +337,19 @@ static void actuatorTask(__attribute__((unused)) void *parameters) case MIXERSETTINGS_CURVE2SOURCE_ACCESSORY4: case MIXERSETTINGS_CURVE2SOURCE_ACCESSORY5: if (AccessoryDesiredInstGet(mixerSettings.Curve2Source - MIXERSETTINGS_CURVE2SOURCE_ACCESSORY0, &accessory) == 0) { - curve2 = MixerCurve(accessory.AccessoryVal, mixerSettings.ThrottleCurve2, MIXERSETTINGS_THROTTLECURVE2_NUMELEM); + // Throttle curve contribution the same for +ve vs -ve accessory....maybe not want we want. + curve2 = MixerCurveFullRangeAbsolute(accessory.AccessoryVal, mixerSettings.ThrottleCurve2, MIXERSETTINGS_THROTTLECURVE2_NUMELEM); } else { - curve2 = 0; + curve2 = 0.0f; } break; + default: + curve2 = 0.0f; + break; } - float *status = (float *)&mixerStatus; // access status objects as an array of floats + float *status = (float *)&mixerStatus; // access status objects as an array of floats + Mixer_t *mixers = (Mixer_t *)&mixerSettings.Mixer1Type; for (int ct = 0; ct < MAX_MIX_ACTUATORS; ct++) { // During boot all camera actuators should be completely disabled (PWM pulse = 0). @@ -343,20 +358,22 @@ static void actuatorTask(__attribute__((unused)) void *parameters) // Setting it to 1 by default means "Rescale this channel and enable PWM on its output". command.Channel[ct] = 1; - if (mixers[ct].type == MIXERSETTINGS_MIXER1TYPE_DISABLED) { + uint8_t mixer_type = mixers[ct].type; + + if (mixer_type == MIXERSETTINGS_MIXER1TYPE_DISABLED) { // Set to minimum if disabled. This is not the same as saying PWM pulse = 0 us status[ct] = -1; continue; } - if ((mixers[ct].type == MIXERSETTINGS_MIXER1TYPE_MOTOR) || (mixers[ct].type == MIXERSETTINGS_MIXER1TYPE_REVERSABLEMOTOR) || (mixers[ct].type == MIXERSETTINGS_MIXER1TYPE_SERVO)) { - status[ct] = ProcessMixer(ct, curve1, curve2, &mixerSettings, &desired, dTSeconds); - } else { - status[ct] = -1; - } - - // Motors have additional protection for when to be on - if (mixers[ct].type == MIXERSETTINGS_MIXER1TYPE_MOTOR) { + if ((mixer_type == MIXERSETTINGS_MIXER1TYPE_MOTOR)) { + if (curve1 < 0.0f) { + curve1 = 0.0f; + } + if (curve2 < 0.0f) { + curve2 = 0.0f; + } + status[ct] = ProcessMixer(ct, curve1, curve2, &desired, dTSeconds); // If not armed or motors aren't meant to spin all the time if (!armed || (!spinWhileArmed && !positiveThrottle)) { @@ -369,57 +386,60 @@ static void actuatorTask(__attribute__((unused)) void *parameters) (status[ct] < 0)) { status[ct] = 0; } - } - - // Reversable Motors are like Motors but go to neutral instead of minimum - if (mixers[ct].type == MIXERSETTINGS_MIXER1TYPE_REVERSABLEMOTOR) { + } else if (mixer_type == MIXERSETTINGS_MIXER1TYPE_REVERSABLEMOTOR) { + status[ct] = ProcessMixer(ct, curve1, curve2, &desired, dTSeconds); + // Reversable Motors are like Motors but go to neutral instead of minimum // If not armed or motor is inactive - no "spinwhilearmed" for this engine type if (!armed || !activeThrottle) { filterAccumulator[ct] = 0; lastResult[ct] = 0; status[ct] = 0; // force neutral throttle } - } + } else if (mixer_type == MIXERSETTINGS_MIXER1TYPE_SERVO) { + status[ct] = ProcessMixer(ct, curve1, curve2, &desired, dTSeconds); + } else { + status[ct] = -1; - // If an accessory channel is selected for direct bypass mode - // In this configuration the accessory channel is scaled and mapped - // directly to output. Note: THERE IS NO SAFETY CHECK HERE FOR ARMING - // these also will not be updated in failsafe mode. I'm not sure what - // the correct behavior is since it seems domain specific. I don't love - // this code - if ((mixers[ct].type >= MIXERSETTINGS_MIXER1TYPE_ACCESSORY0) && - (mixers[ct].type <= MIXERSETTINGS_MIXER1TYPE_ACCESSORY5)) { - if (AccessoryDesiredInstGet(mixers[ct].type - MIXERSETTINGS_MIXER1TYPE_ACCESSORY0, &accessory) == 0) { - status[ct] = accessory.AccessoryVal; - } else { - status[ct] = -1; - } - } - - if ((mixers[ct].type >= MIXERSETTINGS_MIXER1TYPE_CAMERAROLLORSERVO1) && - (mixers[ct].type <= MIXERSETTINGS_MIXER1TYPE_CAMERAYAW)) { - CameraDesiredData cameraDesired; - if (CameraDesiredGet(&cameraDesired) == 0) { - switch (mixers[ct].type) { - case MIXERSETTINGS_MIXER1TYPE_CAMERAROLLORSERVO1: - status[ct] = cameraDesired.RollOrServo1; - break; - case MIXERSETTINGS_MIXER1TYPE_CAMERAPITCHORSERVO2: - status[ct] = cameraDesired.PitchOrServo2; - break; - case MIXERSETTINGS_MIXER1TYPE_CAMERAYAW: - status[ct] = cameraDesired.Yaw; - break; - default: - break; + // If an accessory channel is selected for direct bypass mode + // In this configuration the accessory channel is scaled and mapped + // directly to output. Note: THERE IS NO SAFETY CHECK HERE FOR ARMING + // these also will not be updated in failsafe mode. I'm not sure what + // the correct behavior is since it seems domain specific. I don't love + // this code + if ((mixer_type >= MIXERSETTINGS_MIXER1TYPE_ACCESSORY0) && + (mixer_type <= MIXERSETTINGS_MIXER1TYPE_ACCESSORY5)) { + if (AccessoryDesiredInstGet(mixer_type - MIXERSETTINGS_MIXER1TYPE_ACCESSORY0, &accessory) == 0) { + status[ct] = accessory.AccessoryVal; + } else { + status[ct] = -1; } - } else { - status[ct] = -1; } - // Disable camera actuators for CAMERA_BOOT_DELAY_MS after boot - if (thisSysTime < (CAMERA_BOOT_DELAY_MS / portTICK_RATE_MS)) { - command.Channel[ct] = 0; + if ((mixer_type >= MIXERSETTINGS_MIXER1TYPE_CAMERAROLLORSERVO1) && + (mixer_type <= MIXERSETTINGS_MIXER1TYPE_CAMERAYAW)) { + CameraDesiredData cameraDesired; + if (CameraDesiredGet(&cameraDesired) == 0) { + switch (mixer_type) { + case MIXERSETTINGS_MIXER1TYPE_CAMERAROLLORSERVO1: + status[ct] = cameraDesired.RollOrServo1; + break; + case MIXERSETTINGS_MIXER1TYPE_CAMERAPITCHORSERVO2: + status[ct] = cameraDesired.PitchOrServo2; + break; + case MIXERSETTINGS_MIXER1TYPE_CAMERAYAW: + status[ct] = cameraDesired.Yaw; + break; + default: + break; + } + } else { + status[ct] = -1; + } + + // Disable camera actuators for CAMERA_BOOT_DELAY_MS after boot + if (thisSysTime < (CAMERA_BOOT_DELAY_MS / portTICK_RATE_MS)) { + command.Channel[ct] = 0; + } } } } @@ -454,7 +474,7 @@ static void actuatorTask(__attribute__((unused)) void *parameters) bool success = true; for (int n = 0; n < ACTUATORCOMMAND_CHANNEL_NUMELEM; ++n) { - success &= set_channel(n, command.Channel[n], &actuatorSettings); + success &= set_channel(n, command.Channel[n]); } PIOS_Servo_Update(); @@ -475,10 +495,10 @@ static void actuatorTask(__attribute__((unused)) void *parameters) * Process mixing for one actuator */ float ProcessMixer(const int index, const float curve1, const float curve2, - const MixerSettingsData *mixerSettings, ActuatorDesiredData *desired, const float period) + ActuatorDesiredData *desired, const float period) { static float lastFilteredResult[MAX_MIX_ACTUATORS]; - const Mixer_t *mixers = (Mixer_t *)&mixerSettings->Mixer1Type; // pointer to array of mixers in UAVObjects + const Mixer_t *mixers = (Mixer_t *)&mixerSettings.Mixer1Type; // pointer to array of mixers in UAVObjects const Mixer_t *mixer = &mixers[index]; float result = ((((float)mixer->matrix[MIXERSETTINGS_MIXER1VECTOR_THROTTLECURVE1]) * curve1) + @@ -495,18 +515,18 @@ float ProcessMixer(const int index, const float curve1, const float curve2, // feed forward float accumulator = filterAccumulator[index]; - accumulator += (result - lastResult[index]) * mixerSettings->FeedForward; + accumulator += (result - lastResult[index]) * mixerSettings.FeedForward; lastResult[index] = result; result += accumulator; if (period > 0.0f) { if (accumulator > 0.0f) { - float invFilter = period / mixerSettings->AccelTime; + float invFilter = period / mixerSettings.AccelTime; if (invFilter > 1) { invFilter = 1; } accumulator -= accumulator * invFilter; } else { - float invFilter = period / mixerSettings->DecelTime; + float invFilter = period / mixerSettings.DecelTime; if (invFilter > 1) { invFilter = 1; } @@ -518,7 +538,7 @@ float ProcessMixer(const int index, const float curve1, const float curve2, // acceleration limit float dt = result - lastFilteredResult[index]; - float maxDt = mixerSettings->MaxAccel * period; + float maxDt = mixerSettings.MaxAccel * period; if (dt > maxDt) { // we are accelerating too hard result = lastFilteredResult[index] + maxDt; } @@ -530,17 +550,43 @@ float ProcessMixer(const int index, const float curve1, const float curve2, /** - * Interpolate a throttle curve. Throttle input should be in the range 0 to 1. - * Output is in the range 0 to 1. + * Interpolate a throttle curve + * Full range input (-1 to 1) for yaw, roll, pitch + * Output range (-1 to 1) reversible motor/throttle curve + * + * Input of -1 -> -lookup(1) + * Input of 0 -> lookup(0) + * Input of 1 -> lookup(1) */ -static float MixerCurve(const float throttle, const float *curve, uint8_t elements) +static float MixerCurveFullRangeProportional(const float input, const float *curve, uint8_t elements) { - float scale = throttle * (float)(elements - 1); - int idx1 = scale; + float unsigned_value = MixerCurveFullRangeAbsolute(input, curve, elements); + + if (input < 0.0f) { + return -unsigned_value; + } else { + return unsigned_value; + } +} + +/** + * Interpolate a throttle curve + * Full range input (-1 to 1) for yaw, roll, pitch + * Output range (0 to 1) non-reversible motor/throttle curve + * + * Input of -1 -> lookup(1) + * Input of 0 -> lookup(0) + * Input of 1 -> lookup(1) + */ +static float MixerCurveFullRangeAbsolute(const float input, const float *curve, uint8_t elements) +{ + float abs_input = fabsf(input); + float scale = abs_input * (float)(elements - 1); + int idx1 = scale; scale -= (float)idx1; // remainder if (curve[0] < -1) { - return throttle; + return input; } if (idx1 < 0) { idx1 = 0; // clamp to lowest entry in table @@ -553,7 +599,9 @@ static float MixerCurve(const float throttle, const float *curve, uint8_t elemen idx1 = elements - 1; } } - return curve[idx1] * (1.0f - scale) + curve[idx2] * scale; + + float unsigned_value = curve[idx1] * (1.0f - scale) + curve[idx2] * scale; + return unsigned_value; } @@ -593,21 +641,22 @@ static int16_t scaleChannel(float value, int16_t max, int16_t min, int16_t neutr /** * Set actuator output to the neutral values (failsafe) */ -static void setFailsafe(const ActuatorSettingsData *actuatorSettings, const MixerSettingsData *mixerSettings) +static void setFailsafe() { /* grab only the parts that we are going to use */ int16_t Channel[ACTUATORCOMMAND_CHANNEL_NUMELEM]; ActuatorCommandChannelGet(Channel); - const Mixer_t *mixers = (Mixer_t *)&mixerSettings->Mixer1Type; // pointer to array of mixers in UAVObjects + const Mixer_t *mixers = (Mixer_t *)&mixerSettings.Mixer1Type; // pointer to array of mixers in UAVObjects // Reset ActuatorCommand to safe values for (int n = 0; n < ACTUATORCOMMAND_CHANNEL_NUMELEM; ++n) { if (mixers[n].type == MIXERSETTINGS_MIXER1TYPE_MOTOR) { - Channel[n] = actuatorSettings->ChannelMin[n]; + Channel[n] = actuatorSettings.ChannelMin[n]; } else if (mixers[n].type == MIXERSETTINGS_MIXER1TYPE_SERVO || mixers[n].type == MIXERSETTINGS_MIXER1TYPE_REVERSABLEMOTOR) { - Channel[n] = actuatorSettings->ChannelNeutral[n]; + // reversible motors need calibration wizard that allows channel neutral to be the 0 velocity point + Channel[n] = actuatorSettings.ChannelNeutral[n]; } else { Channel[n] = 0; } @@ -618,7 +667,7 @@ static void setFailsafe(const ActuatorSettingsData *actuatorSettings, const Mixe // Update servo outputs for (int n = 0; n < ACTUATORCOMMAND_CHANNEL_NUMELEM; ++n) { - set_channel(n, Channel[n], actuatorSettings); + set_channel(n, Channel[n]); } // Send the updated command PIOS_Servo_Update(); @@ -713,39 +762,39 @@ static inline bool buzzerState(buzzertype type) #if defined(ARCH_POSIX) || defined(ARCH_WIN32) -static bool set_channel(uint8_t mixer_channel, uint16_t value, const ActuatorSettingsData *actuatorSettings) +static bool set_channel(uint8_t mixer_channel, uint16_t value) { return true; } #else -static bool set_channel(uint8_t mixer_channel, uint16_t value, const ActuatorSettingsData *actuatorSettings) +static bool set_channel(uint8_t mixer_channel, uint16_t value) { - switch (actuatorSettings->ChannelType[mixer_channel]) { + switch (actuatorSettings.ChannelType[mixer_channel]) { case ACTUATORSETTINGS_CHANNELTYPE_PWMALARMBUZZER: - PIOS_Servo_Set(actuatorSettings->ChannelAddr[mixer_channel], - buzzerState(BUZZ_BUZZER) ? actuatorSettings->ChannelMax[mixer_channel] : actuatorSettings->ChannelMin[mixer_channel]); + PIOS_Servo_Set(actuatorSettings.ChannelAddr[mixer_channel], + buzzerState(BUZZ_BUZZER) ? actuatorSettings.ChannelMax[mixer_channel] : actuatorSettings.ChannelMin[mixer_channel]); return true; case ACTUATORSETTINGS_CHANNELTYPE_ARMINGLED: - PIOS_Servo_Set(actuatorSettings->ChannelAddr[mixer_channel], - buzzerState(BUZZ_ARMING) ? actuatorSettings->ChannelMax[mixer_channel] : actuatorSettings->ChannelMin[mixer_channel]); + PIOS_Servo_Set(actuatorSettings.ChannelAddr[mixer_channel], + buzzerState(BUZZ_ARMING) ? actuatorSettings.ChannelMax[mixer_channel] : actuatorSettings.ChannelMin[mixer_channel]); return true; case ACTUATORSETTINGS_CHANNELTYPE_INFOLED: - PIOS_Servo_Set(actuatorSettings->ChannelAddr[mixer_channel], - buzzerState(BUZZ_INFO) ? actuatorSettings->ChannelMax[mixer_channel] : actuatorSettings->ChannelMin[mixer_channel]); + PIOS_Servo_Set(actuatorSettings.ChannelAddr[mixer_channel], + buzzerState(BUZZ_INFO) ? actuatorSettings.ChannelMax[mixer_channel] : actuatorSettings.ChannelMin[mixer_channel]); return true; case ACTUATORSETTINGS_CHANNELTYPE_PWM: { - uint8_t mode = pinsMode[actuatorSettings->ChannelAddr[mixer_channel]]; + uint8_t mode = pinsMode[actuatorSettings.ChannelAddr[mixer_channel]]; switch (mode) { case ACTUATORSETTINGS_BANKMODE_ONESHOT125: // Remap 1000-2000 range to 125-250 - PIOS_Servo_Set(actuatorSettings->ChannelAddr[mixer_channel], value / ACTUATOR_ONESHOT125_PULSE_SCALE); + PIOS_Servo_Set(actuatorSettings.ChannelAddr[mixer_channel], value / ACTUATOR_ONESHOT125_PULSE_SCALE); break; default: - PIOS_Servo_Set(actuatorSettings->ChannelAddr[mixer_channel], value); + PIOS_Servo_Set(actuatorSettings.ChannelAddr[mixer_channel], value); break; } return true; @@ -770,12 +819,12 @@ static bool set_channel(uint8_t mixer_channel, uint16_t value, const ActuatorSet /** * @brief Update the servo update rate */ -static void actuator_update_rate_if_changed(const ActuatorSettingsData *actuatorSettings, bool force_update) +static void actuator_update_rate_if_changed(bool force_update) { static uint16_t prevBankUpdateFreq[ACTUATORSETTINGS_BANKUPDATEFREQ_NUMELEM]; static uint8_t prevBankMode[ACTUATORSETTINGS_BANKMODE_NUMELEM]; - bool updateMode = force_update || (memcmp(prevBankMode, actuatorSettings->BankMode, sizeof(prevBankMode)) != 0); - bool updateFreq = force_update || (memcmp(prevBankUpdateFreq, actuatorSettings->BankUpdateFreq, sizeof(prevBankUpdateFreq)) != 0); + bool updateMode = force_update || (memcmp(prevBankMode, actuatorSettings.BankMode, sizeof(prevBankMode)) != 0); + bool updateFreq = force_update || (memcmp(prevBankUpdateFreq, actuatorSettings.BankUpdateFreq, sizeof(prevBankUpdateFreq)) != 0); // check if any setting is changed if (updateMode || updateFreq) { @@ -784,15 +833,15 @@ static void actuator_update_rate_if_changed(const ActuatorSettingsData *actuator uint16_t freq[ACTUATORSETTINGS_BANKUPDATEFREQ_NUMELEM]; uint32_t clock[ACTUATORSETTINGS_BANKUPDATEFREQ_NUMELEM] = { 0 }; for (uint8_t i = 0; i < ACTUATORSETTINGS_BANKMODE_NUMELEM; i++) { - if (force_update || (actuatorSettings->BankMode[i] != prevBankMode[i])) { + if (force_update || (actuatorSettings.BankMode[i] != prevBankMode[i])) { PIOS_Servo_SetBankMode(i, - actuatorSettings->BankMode[i] == + actuatorSettings.BankMode[i] == ACTUATORSETTINGS_BANKMODE_PWM ? PIOS_SERVO_BANK_MODE_PWM : PIOS_SERVO_BANK_MODE_SINGLE_PULSE ); } - switch (actuatorSettings->BankMode[i]) { + switch (actuatorSettings.BankMode[i]) { case ACTUATORSETTINGS_BANKMODE_ONESHOT125: freq[i] = 100; // Value must be small enough so CCr isn't update until the PIOS_Servo_Update is triggered clock[i] = ACTUATOR_ONESHOT125_CLOCK; // Setup an 2MHz timer clock @@ -802,37 +851,73 @@ static void actuator_update_rate_if_changed(const ActuatorSettingsData *actuator clock[i] = ACTUATOR_PWM_CLOCK; break; default: // PWM - freq[i] = actuatorSettings->BankUpdateFreq[i]; + freq[i] = actuatorSettings.BankUpdateFreq[i]; clock[i] = ACTUATOR_PWM_CLOCK; break; } } memcpy(prevBankMode, - actuatorSettings->BankMode, + actuatorSettings.BankMode, sizeof(prevBankMode)); PIOS_Servo_SetHz(freq, clock, ACTUATORSETTINGS_BANKUPDATEFREQ_NUMELEM); memcpy(prevBankUpdateFreq, - actuatorSettings->BankUpdateFreq, + actuatorSettings.BankUpdateFreq, sizeof(prevBankUpdateFreq)); // retrieve mode from related bank for (uint8_t i = 0; i < MAX_MIX_ACTUATORS; i++) { uint8_t bank = PIOS_Servo_GetPinBank(i); - pinsMode[i] = actuatorSettings->BankMode[bank]; + pinsMode[i] = actuatorSettings.BankMode[bank]; } } } static void ActuatorSettingsUpdatedCb(__attribute__((unused)) UAVObjEvent *ev) { - actuator_settings_updated = true; + ActuatorSettingsGet(&actuatorSettings); + spinWhileArmed = actuatorSettings.MotorsSpinWhileArmed == ACTUATORSETTINGS_MOTORSSPINWHILEARMED_TRUE; + if (frameType == FRAME_TYPE_GROUND) { + spinWhileArmed = false; + } + actuator_update_rate_if_changed(false); } static void MixerSettingsUpdatedCb(__attribute__((unused)) UAVObjEvent *ev) { - mixer_settings_updated = true; + MixerSettingsGet(&mixerSettings); + mixer_settings_count = 0; + Mixer_t *mixers = (Mixer_t *)&mixerSettings.Mixer1Type; + for (int ct = 0; ct < MAX_MIX_ACTUATORS; ct++) { + if (mixers[ct].type != MIXERSETTINGS_MIXER1TYPE_DISABLED) { + mixer_settings_count++; + } + } +} +static void SettingsUpdatedCb(__attribute__((unused)) UAVObjEvent *ev) +{ + frameType = GetCurrentFrameType(); +#ifndef PIOS_EXCLUDE_ADVANCED_FEATURES + uint8_t TreatCustomCraftAs; + VtolPathFollowerSettingsTreatCustomCraftAsGet(&TreatCustomCraftAs); + + if (frameType == FRAME_TYPE_CUSTOM) { + switch (TreatCustomCraftAs) { + case VTOLPATHFOLLOWERSETTINGS_TREATCUSTOMCRAFTAS_FIXEDWING: + frameType = FRAME_TYPE_FIXED_WING; + break; + case VTOLPATHFOLLOWERSETTINGS_TREATCUSTOMCRAFTAS_VTOL: + frameType = FRAME_TYPE_MULTIROTOR; + break; + case VTOLPATHFOLLOWERSETTINGS_TREATCUSTOMCRAFTAS_GROUND: + frameType = FRAME_TYPE_GROUND; + break; + } + } +#endif + + SystemSettingsThrustControlGet(&thrustType); } /** diff --git a/flight/modules/ManualControl/armhandler.c b/flight/modules/ManualControl/armhandler.c index b17ce8334..7d35e840c 100644 --- a/flight/modules/ManualControl/armhandler.c +++ b/flight/modules/ManualControl/armhandler.c @@ -37,7 +37,8 @@ #include // Private constants -#define ARMED_THRESHOLD 0.50f +#define ARMED_THRESHOLD 0.50f +#define GROUND_LOW_THROTTLE 0.01f // Private types typedef enum { @@ -62,7 +63,7 @@ static bool forcedDisArm(void); * @input: ManualControlCommand, AccessoryDesired * @output: FlightStatus.Arming */ -void armHandler(bool newinit) +void armHandler(bool newinit, FrameType_t frameType) { static ArmState_t armState; @@ -82,7 +83,12 @@ void armHandler(bool newinit) bool lowThrottle = cmd.Throttle < 0; - bool armSwitch = false; + if (frameType == FRAME_TYPE_GROUND) { + // Deadbanding applied in receiver.c typically at 2% but we don't assume its enabled. + lowThrottle = fabsf(cmd.Throttle) < GROUND_LOW_THROTTLE; + } + + bool armSwitch = false; switch (settings.Arming) { case FLIGHTMODESETTINGS_ARMING_ACCESSORY0: diff --git a/flight/modules/ManualControl/inc/manualcontrol.h b/flight/modules/ManualControl/inc/manualcontrol.h index 6fce4ecf9..a52264443 100644 --- a/flight/modules/ManualControl/inc/manualcontrol.h +++ b/flight/modules/ManualControl/inc/manualcontrol.h @@ -32,6 +32,7 @@ #include #include +#include typedef void (*handlerFunc)(bool newinit); @@ -45,7 +46,7 @@ typedef struct controlHandlerStruct { * @input: ManualControlCommand, AccessoryDesired * @output: FlightStatus.Arming */ -void armHandler(bool newinit); +void armHandler(bool newinit, FrameType_t frameType); /** * @brief Handler to control Manual flightmode - input directly steers actuators diff --git a/flight/modules/ManualControl/manualcontrol.c b/flight/modules/ManualControl/manualcontrol.c index cf65a9328..2299ce674 100644 --- a/flight/modules/ManualControl/manualcontrol.c +++ b/flight/modules/ManualControl/manualcontrol.c @@ -108,6 +108,7 @@ static float thrustHi = 0.0f; #endif /* ifndef PIOS_EXCLUDE_ADVANCED_FEATURES */ // Private variables static DelayedCallbackInfo *callbackHandle; +static FrameType_t frameType = FRAME_TYPE_MULTIROTOR; // Private functions static void configurationUpdatedCb(UAVObjEvent *ev); @@ -116,6 +117,7 @@ static void manualControlTask(void); #ifndef PIOS_EXCLUDE_ADVANCED_FEATURES static uint8_t isAssistedFlightMode(uint8_t position, uint8_t flightMode, FlightModeSettingsData *modeSettings); #endif +static void SettingsUpdatedCb(UAVObjEvent *ev); #define assumptions (assumptions1 && assumptions2 && assumptions3 && assumptions4 && assumptions5 && assumptions6 && assumptions7 && assumptions_flightmode) @@ -135,11 +137,14 @@ int32_t ManualControlStart() // clear alarms AlarmsClear(SYSTEMALARMS_ALARM_MANUALCONTROL); + SettingsUpdatedCb(NULL); + // Make sure unarmed on power up - armHandler(true); + armHandler(true, frameType); #ifndef PIOS_EXCLUDE_ADVANCED_FEATURES takeOffLocationHandlerInit(); + #endif // Start main task PIOS_CALLBACKSCHEDULER_Dispatch(callbackHandle); @@ -164,6 +169,8 @@ int32_t ManualControlInitialize() #ifndef PIOS_EXCLUDE_ADVANCED_FEATURES VtolSelfTuningStatsInitialize(); VtolPathFollowerSettingsInitialize(); + VtolPathFollowerSettingsConnectCallback(&SettingsUpdatedCb); + SystemSettingsConnectCallback(&SettingsUpdatedCb); #endif callbackHandle = PIOS_CALLBACKSCHEDULER_Create(&manualControlTask, CALLBACK_PRIORITY, CBTASK_PRIORITY, CALLBACKINFO_RUNNING_MANUALCONTROL, STACK_SIZE_BYTES); @@ -171,13 +178,37 @@ int32_t ManualControlInitialize() } MODULE_INITCALL(ManualControlInitialize, ManualControlStart); +static void SettingsUpdatedCb(__attribute__((unused)) UAVObjEvent *ev) +{ + frameType = GetCurrentFrameType(); +#ifndef PIOS_EXCLUDE_ADVANCED_FEATURES + uint8_t TreatCustomCraftAs; + VtolPathFollowerSettingsTreatCustomCraftAsGet(&TreatCustomCraftAs); + + + if (frameType == FRAME_TYPE_CUSTOM) { + switch (TreatCustomCraftAs) { + case VTOLPATHFOLLOWERSETTINGS_TREATCUSTOMCRAFTAS_FIXEDWING: + frameType = FRAME_TYPE_FIXED_WING; + break; + case VTOLPATHFOLLOWERSETTINGS_TREATCUSTOMCRAFTAS_VTOL: + frameType = FRAME_TYPE_MULTIROTOR; + break; + case VTOLPATHFOLLOWERSETTINGS_TREATCUSTOMCRAFTAS_GROUND: + frameType = FRAME_TYPE_GROUND; + break; + } + } +#endif +} + /** * Module task */ static void manualControlTask(void) { // Process Arming - armHandler(false); + armHandler(false, frameType); #ifndef PIOS_EXCLUDE_ADVANCED_FEATURES takeOffLocationHandler(); #endif diff --git a/flight/modules/Receiver/receiver.c b/flight/modules/Receiver/receiver.c index 2f42b7eed..3ff31a704 100644 --- a/flight/modules/Receiver/receiver.c +++ b/flight/modules/Receiver/receiver.c @@ -41,10 +41,12 @@ #include #ifndef PIOS_EXCLUDE_ADVANCED_FEATURES #include +#include #endif #include #include #include +#include #if defined(PIOS_INCLUDE_USB_RCTX) @@ -72,6 +74,7 @@ // Private variables static xTaskHandle taskHandle; static portTickType lastSysTime; +static FrameType_t frameType = FRAME_TYPE_MULTIROTOR; #ifdef USE_INPUT_LPF static portTickType lastSysTimeLPF; @@ -84,6 +87,7 @@ static float scaleChannel(int16_t value, int16_t max, int16_t min, int16_t neutr static uint32_t timeDifferenceMs(portTickType start_time, portTickType end_time); static bool validInputRange(int16_t min, int16_t max, uint16_t value); static void applyDeadband(float *value, float deadband); +static void SettingsUpdatedCb(UAVObjEvent *ev); #ifndef PIOS_EXCLUDE_ADVANCED_FEATURES static uint8_t isAssistedFlightMode(uint8_t position); @@ -124,6 +128,7 @@ int32_t ReceiverStart() #ifdef PIOS_INCLUDE_WDG PIOS_WDG_RegisterFlag(PIOS_WDG_MANUAL); #endif + SettingsUpdatedCb(NULL); return 0; } @@ -141,13 +146,43 @@ int32_t ReceiverInitialize() ManualControlSettingsInitialize(); #ifndef PIOS_EXCLUDE_ADVANCED_FEATURES StabilizationSettingsInitialize(); + VtolPathFollowerSettingsInitialize(); + VtolPathFollowerSettingsConnectCallback(&SettingsUpdatedCb); #endif + SystemSettingsInitialize(); + SystemSettingsConnectCallback(&SettingsUpdatedCb); return 0; } MODULE_INITCALL(ReceiverInitialize, ReceiverStart); +static void SettingsUpdatedCb(__attribute__((unused)) UAVObjEvent *ev) +{ + frameType = GetCurrentFrameType(); + +#ifndef PIOS_EXCLUDE_ADVANCED_FEATURES + uint8_t TreatCustomCraftAs; + VtolPathFollowerSettingsTreatCustomCraftAsGet(&TreatCustomCraftAs); + + + if (frameType == FRAME_TYPE_CUSTOM) { + switch (TreatCustomCraftAs) { + case VTOLPATHFOLLOWERSETTINGS_TREATCUSTOMCRAFTAS_FIXEDWING: + frameType = FRAME_TYPE_FIXED_WING; + break; + case VTOLPATHFOLLOWERSETTINGS_TREATCUSTOMCRAFTAS_VTOL: + frameType = FRAME_TYPE_MULTIROTOR; + break; + case VTOLPATHFOLLOWERSETTINGS_TREATCUSTOMCRAFTAS_GROUND: + frameType = FRAME_TYPE_GROUND; + break; + } + } +#endif +} + + /** * Module task */ @@ -243,22 +278,16 @@ static void receiverTask(__attribute__((unused)) void *parameters) } } - // Check settings, if error raise alarm - if (settings.ChannelGroups.Roll >= MANUALCONTROLSETTINGS_CHANNELGROUPS_NONE - || settings.ChannelGroups.Pitch >= MANUALCONTROLSETTINGS_CHANNELGROUPS_NONE - || settings.ChannelGroups.Yaw >= MANUALCONTROLSETTINGS_CHANNELGROUPS_NONE + // Sanity Check Throttle and Yaw + if (settings.ChannelGroups.Yaw >= MANUALCONTROLSETTINGS_CHANNELGROUPS_NONE || settings.ChannelGroups.Throttle >= MANUALCONTROLSETTINGS_CHANNELGROUPS_NONE || // Check all channel mappings are valid - cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_ROLL] == (uint16_t)PIOS_RCVR_INVALID - || cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_PITCH] == (uint16_t)PIOS_RCVR_INVALID - || cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_YAW] == (uint16_t)PIOS_RCVR_INVALID + cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_YAW] == (uint16_t)PIOS_RCVR_INVALID || cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_THROTTLE] == (uint16_t)PIOS_RCVR_INVALID || // Check the driver exists - cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_ROLL] == (uint16_t)PIOS_RCVR_NODRIVER - || cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_PITCH] == (uint16_t)PIOS_RCVR_NODRIVER - || cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_YAW] == (uint16_t)PIOS_RCVR_NODRIVER + cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_YAW] == (uint16_t)PIOS_RCVR_NODRIVER || cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_THROTTLE] == (uint16_t)PIOS_RCVR_NODRIVER || // Check collective if required @@ -282,15 +311,39 @@ static void receiverTask(__attribute__((unused)) void *parameters) continue; } + + if (frameType != FRAME_TYPE_GROUND) { + // Sanity Check Pitch and Roll + if (settings.ChannelGroups.Roll >= MANUALCONTROLSETTINGS_CHANNELGROUPS_NONE + || settings.ChannelGroups.Pitch >= MANUALCONTROLSETTINGS_CHANNELGROUPS_NONE + || + // Check all channel mappings are valid + cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_ROLL] == (uint16_t)PIOS_RCVR_INVALID + || cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_PITCH] == (uint16_t)PIOS_RCVR_INVALID + || + // Check the driver exists + cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_ROLL] == (uint16_t)PIOS_RCVR_NODRIVER + || cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_PITCH] == (uint16_t)PIOS_RCVR_NODRIVER) { + AlarmsSet(SYSTEMALARMS_ALARM_RECEIVER, SYSTEMALARMS_ALARM_CRITICAL); + cmd.Connected = MANUALCONTROLCOMMAND_CONNECTED_FALSE; + ManualControlCommandSet(&cmd); + + continue; + } + } + // decide if we have valid manual input or not valid_input_detected &= validInputRange(settings.ChannelMin.Throttle, settings.ChannelMax.Throttle, cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_THROTTLE]) - && validInputRange(settings.ChannelMin.Roll, - settings.ChannelMax.Roll, cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_ROLL]) && validInputRange(settings.ChannelMin.Yaw, - settings.ChannelMax.Yaw, cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_YAW]) - && validInputRange(settings.ChannelMin.Pitch, - settings.ChannelMax.Pitch, cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_PITCH]); + settings.ChannelMax.Yaw, cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_YAW]); + + if (frameType != FRAME_TYPE_GROUND) { + valid_input_detected &= validInputRange(settings.ChannelMin.Roll, + settings.ChannelMax.Roll, cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_ROLL]) + && validInputRange(settings.ChannelMin.Pitch, + settings.ChannelMax.Pitch, cmd.Channel[MANUALCONTROLSETTINGS_CHANNELGROUPS_PITCH]); + } if (settings.ChannelGroups.Collective != MANUALCONTROLSETTINGS_CHANNELGROUPS_NONE) { valid_input_detected &= validInputRange(settings.ChannelMin.Collective, @@ -321,10 +374,14 @@ static void receiverTask(__attribute__((unused)) void *parameters) } if (cmd.Connected == MANUALCONTROLCOMMAND_CONNECTED_FALSE) { - cmd.Throttle = settings.FailsafeChannel.Throttle; - cmd.Roll = settings.FailsafeChannel.Roll; - cmd.Pitch = settings.FailsafeChannel.Pitch; - cmd.Yaw = settings.FailsafeChannel.Yaw; + if (frameType != FRAME_TYPE_GROUND) { + cmd.Throttle = settings.FailsafeChannel.Throttle; + } else { + cmd.Throttle = 0.0f; + } + cmd.Roll = settings.FailsafeChannel.Roll; + cmd.Pitch = settings.FailsafeChannel.Pitch; + cmd.Yaw = settings.FailsafeChannel.Yaw; cmd.Collective = settings.FailsafeChannel.Collective; switch (thrustType) { case SYSTEMSETTINGS_THRUSTCONTROL_THROTTLE: @@ -401,6 +458,9 @@ static void receiverTask(__attribute__((unused)) void *parameters) applyDeadband(&cmd.Roll, deadband_checked); applyDeadband(&cmd.Pitch, deadband_checked); applyDeadband(&cmd.Yaw, deadband_checked); + if (frameType == FRAME_TYPE_GROUND) { // assumes reversible motors + applyDeadband(&cmd.Throttle, deadband_checked); + } } #ifdef USE_INPUT_LPF // Apply Low Pass Filter to input channels, time delta between calls in ms diff --git a/ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/H-King320mmCarbonARF-Multirotor-QuadrocopterX-3fe218baaba.optmpl b/ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/H-King320mmCarbonARF-Multirotor-QuadrocopterX-3fe218baaba.optmpl new file mode 100644 index 000000000..7f9dd92d0 --- /dev/null +++ b/ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/H-King320mmCarbonARF-Multirotor-QuadrocopterX-3fe218baaba.optmpl @@ -0,0 +1,2186 @@ +{ + "battery": "3s 2200 ", + "comment": "Acro tune for Rate , Acro +, Attitude and rattitude\nBank 1 Attitude / Acro +\nBank 2 Rattitude ", + "controller": "CC3D", + "esc": "Argonaut 20a Blheli", + "motor": "DYS 1806-2203kv", + "name": "H-King 320mm Carbon ARF", + "nick": "Failsafe", + "objects": [ + { + "fields": [ + { + "name": "VbarSensitivity", + "type": "float32", + "unit": "frac", + "values": [ + { + "name": "Roll", + "value": 0.5 + }, + { + "name": "Pitch", + "value": 0.5 + }, + { + "name": "Yaw", + "value": 0.5 + } + ] + }, + { + "name": "VbarRollPI", + "type": "float32", + "unit": "1/(deg/s)", + "values": [ + { + "name": "Kp", + "value": 0.004999999888241291 + }, + { + "name": "Ki", + "value": 0.0020000000949949026 + } + ] + }, + { + "name": "VbarPitchPI", + "type": "float32", + "unit": "1/(deg/s)", + "values": [ + { + "name": "Kp", + "value": 0.004999999888241291 + }, + { + "name": "Ki", + "value": 0.0020000000949949026 + } + ] + }, + { + "name": "VbarYawPI", + "type": "float32", + "unit": "1/(deg/s)", + "values": [ + { + "name": "Kp", + "value": 0.004999999888241291 + }, + { + "name": "Ki", + "value": 0.0020000000949949026 + } + ] + }, + { + "name": "VbarTau", + "type": "float32", + "unit": "sec", + "values": [ + { + "name": "0", + "value": 0.5 + } + ] + }, + { + "name": "GyroTau", + "type": "float32", + "unit": "", + "values": [ + { + "name": "0", + "value": 0.004999999888241291 + } + ] + }, + { + "name": "DerivativeGamma", + "type": "float32", + "unit": "", + "values": [ + { + "name": "0", + "value": 1 + } + ] + }, + { + "name": "AxisLockKp", + "type": "float32", + "unit": "", + "values": [ + { + "name": "0", + "value": 2.5 + } + ] + }, + { + "name": "WeakLevelingKp", + "type": "float32", + "unit": "(deg/s)/deg", + "values": [ + { + "name": "0", + "value": 0.10000000149011612 + } + ] + }, + { + "name": "CruiseControlMaxPowerFactor", + "type": "float32", + "unit": "x", + "values": [ + { + "name": "0", + "value": 3 + } + ] + }, + { + "name": "CruiseControlPowerTrim", + "type": "float32", + "unit": "%", + "values": [ + { + "name": "0", + "value": 100 + } + ] + }, + { + "name": "CruiseControlPowerDelayComp", + "type": "float32", + "unit": "sec", + "values": [ + { + "name": "0", + "value": 0.25 + } + ] + }, + { + "name": "ScaleToAirspeed", + "type": "float32", + "unit": "m/s", + "values": [ + { + "name": "0", + "value": 0 + } + ] + }, + { + "name": "ScaleToAirspeedLimits", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Min", + "value": 0.05000000074505806 + }, + { + "name": "Max", + "value": 3 + } + ] + }, + { + "name": "FlightModeMap", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Bank1" + }, + { + "name": "1", + "value": "Bank1" + }, + { + "name": "2", + "value": "Bank1" + }, + { + "name": "3", + "value": "Bank1" + }, + { + "name": "4", + "value": "Bank1" + }, + { + "name": "5", + "value": "Bank1" + } + ] + }, + { + "name": "VbarGyroSuppress", + "type": "int8", + "unit": "%", + "values": [ + { + "name": "0", + "value": 30 + } + ] + }, + { + "name": "VbarPiroComp", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "VbarMaxAngle", + "type": "uint8", + "unit": "deg", + "values": [ + { + "name": "0", + "value": 10 + } + ] + }, + { + "name": "DerivativeCutoff", + "type": "uint8", + "unit": "Hz", + "values": [ + { + "name": "0", + "value": 20 + } + ] + }, + { + "name": "MaxAxisLock", + "type": "uint8", + "unit": "deg", + "values": [ + { + "name": "0", + "value": 30 + } + ] + }, + { + "name": "MaxAxisLockRate", + "type": "uint8", + "unit": "deg/s", + "values": [ + { + "name": "0", + "value": 2 + } + ] + }, + { + "name": "MaxWeakLevelingRate", + "type": "uint8", + "unit": "deg/s", + "values": [ + { + "name": "0", + "value": 5 + } + ] + }, + { + "name": "RattitudeModeTransition", + "type": "uint8", + "unit": "%", + "values": [ + { + "name": "0", + "value": 80 + } + ] + }, + { + "name": "CruiseControlMinThrust", + "type": "int8", + "unit": "%", + "values": [ + { + "name": "0", + "value": 5 + } + ] + }, + { + "name": "CruiseControlMaxThrust", + "type": "uint8", + "unit": "%", + "values": [ + { + "name": "0", + "value": 90 + } + ] + }, + { + "name": "CruiseControlMaxAngle", + "type": "uint8", + "unit": "deg", + "values": [ + { + "name": "0", + "value": 105 + } + ] + }, + { + "name": "CruiseControlFlightModeSwitchPosEnable", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + }, + { + "name": "1", + "value": "FALSE" + }, + { + "name": "2", + "value": "FALSE" + }, + { + "name": "3", + "value": "FALSE" + }, + { + "name": "4", + "value": "FALSE" + }, + { + "name": "5", + "value": "FALSE" + } + ] + }, + { + "name": "CruiseControlInvertedThrustReversing", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Unreversed" + } + ] + }, + { + "name": "CruiseControlInvertedPowerOutput", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Zero" + } + ] + }, + { + "name": "LowThrottleZeroIntegral", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "TRUE" + } + ] + }, + { + "name": "FlightModeAssistMap", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "None" + }, + { + "name": "1", + "value": "None" + }, + { + "name": "2", + "value": "None" + }, + { + "name": "3", + "value": "None" + }, + { + "name": "4", + "value": "None" + }, + { + "name": "5", + "value": "None" + } + ] + } + ], + "id": "73603180", + "instance": 0, + "name": "StabilizationSettings", + "setting": true + }, + { + "fields": [ + { + "name": "ManualRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 300 + }, + { + "name": "Pitch", + "value": 300 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "MaximumRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 400 + }, + { + "name": "Pitch", + "value": 400 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "RollRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0022499999031424522 + }, + { + "name": "Ki", + "value": 0.0051400000229477882 + }, + { + "name": "Kd", + "value": 2.5999999706982635e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "PitchRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0037299999967217445 + }, + { + "name": "Ki", + "value": 0.010089999996125698 + }, + { + "name": "Kd", + "value": 3.9999998989515007e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "YawRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.008139999583363533 + }, + { + "name": "Ki", + "value": 0.0086000002920627594 + }, + { + "name": "Kd", + "value": 3.9999998989515007e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "RollPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.2999999523162842 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "PitchPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.7999999523162842 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "YawPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "AcroInsanityFactor", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.40000000596046448 + } + ] + }, + { + "name": "ThrustPIDScaleCurve", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": -1.427447386959102e-05 + }, + { + "name": "25", + "value": -0.0085789738222956657 + }, + { + "name": "50", + "value": -0.038573265075683594 + }, + { + "name": "75", + "value": -0.15000000596046448 + }, + { + "name": "100", + "value": -0.30000001192092896 + } + ] + }, + { + "name": "RollMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "PitchMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "YawMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 35 + } + ] + }, + { + "name": "StickExpo", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "EnablePiroComp", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "EnableThrustPIDScaling", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "TRUE" + } + ] + }, + { + "name": "ThrustPIDScaleSource", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "ActuatorDesiredThrust" + } + ] + }, + { + "name": "ThrustPIDScaleTarget", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "PD" + } + ] + }, + { + "name": "ThrustPIDScaleAxes", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Roll Pitch" + } + ] + } + ], + "id": "E8EBBD48", + "instance": 0, + "name": "StabilizationSettingsBank1", + "setting": true + }, + { + "fields": [ + { + "name": "ManualRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 400 + }, + { + "name": "Pitch", + "value": 400 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "MaximumRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 400 + }, + { + "name": "Pitch", + "value": 400 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "RollRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0022499999031424522 + }, + { + "name": "Ki", + "value": 0.0051400000229477882 + }, + { + "name": "Kd", + "value": 2.5999999706982635e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "PitchRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0037299999967217445 + }, + { + "name": "Ki", + "value": 0.010089999996125698 + }, + { + "name": "Kd", + "value": 3.9999998989515007e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "YawRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.008139999583363533 + }, + { + "name": "Ki", + "value": 0.0086000002920627594 + }, + { + "name": "Kd", + "value": 3.9999998989515007e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "RollPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.2999999523162842 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "PitchPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.7999999523162842 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "YawPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "AcroInsanityFactor", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.40000000596046448 + } + ] + }, + { + "name": "ThrustPIDScaleCurve", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": -1.427447386959102e-05 + }, + { + "name": "25", + "value": -0.0085789738222956657 + }, + { + "name": "50", + "value": -0.038573265075683594 + }, + { + "name": "75", + "value": -0.15000000596046448 + }, + { + "name": "100", + "value": -0.30000001192092896 + } + ] + }, + { + "name": "RollMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "PitchMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "YawMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 35 + } + ] + }, + { + "name": "StickExpo", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "EnablePiroComp", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "EnableThrustPIDScaling", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "TRUE" + } + ] + }, + { + "name": "ThrustPIDScaleSource", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "ActuatorDesiredThrust" + } + ] + }, + { + "name": "ThrustPIDScaleTarget", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "PD" + } + ] + }, + { + "name": "ThrustPIDScaleAxes", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Roll Pitch" + } + ] + } + ], + "id": "70E9539A", + "instance": 0, + "name": "StabilizationSettingsBank2", + "setting": true + }, + { + "fields": [ + { + "name": "ManualRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 220 + }, + { + "name": "Pitch", + "value": 220 + }, + { + "name": "Yaw", + "value": 220 + } + ] + }, + { + "name": "MaximumRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 300 + }, + { + "name": "Pitch", + "value": 300 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "RollRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0030000000260770321 + }, + { + "name": "Ki", + "value": 0.0065000001341104507 + }, + { + "name": "Kd", + "value": 3.3000000257743523e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "PitchRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0030000000260770321 + }, + { + "name": "Ki", + "value": 0.0065000001341104507 + }, + { + "name": "Kd", + "value": 3.3000000257743523e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "YawRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0062000001780688763 + }, + { + "name": "Ki", + "value": 0.0099999997764825821 + }, + { + "name": "Kd", + "value": 4.9999998736893758e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "RollPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "PitchPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "YawPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "AcroInsanityFactor", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.40000000596046448 + } + ] + }, + { + "name": "ThrustPIDScaleCurve", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.30000001192092896 + }, + { + "name": "25", + "value": 0.15000000596046448 + }, + { + "name": "50", + "value": 0 + }, + { + "name": "75", + "value": -0.15000000596046448 + }, + { + "name": "100", + "value": -0.30000001192092896 + } + ] + }, + { + "name": "RollMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "PitchMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "YawMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 35 + } + ] + }, + { + "name": "StickExpo", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "EnablePiroComp", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "TRUE" + } + ] + }, + { + "name": "EnableThrustPIDScaling", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "ThrustPIDScaleSource", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "ActuatorDesiredThrust" + } + ] + }, + { + "name": "ThrustPIDScaleTarget", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "PID" + } + ] + }, + { + "name": "ThrustPIDScaleAxes", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Roll Pitch" + } + ] + } + ], + "id": "C02DAA6A", + "instance": 0, + "name": "StabilizationSettingsBank3", + "setting": true + }, + { + "fields": [ + { + "name": "MaxAccel", + "type": "float32", + "unit": "units/sec", + "values": [ + { + "name": "0", + "value": 1000 + } + ] + }, + { + "name": "FeedForward", + "type": "float32", + "unit": "", + "values": [ + { + "name": "0", + "value": 0 + } + ] + }, + { + "name": "AccelTime", + "type": "float32", + "unit": "ms", + "values": [ + { + "name": "0", + "value": 0 + } + ] + }, + { + "name": "DecelTime", + "type": "float32", + "unit": "ms", + "values": [ + { + "name": "0", + "value": 0 + } + ] + }, + { + "name": "ThrottleCurve1", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0 + }, + { + "name": "25", + "value": 0.22499999403953552 + }, + { + "name": "50", + "value": 0.44999998807907104 + }, + { + "name": "75", + "value": 0.67499995231628418 + }, + { + "name": "100", + "value": 0.89999997615814209 + } + ] + }, + { + "name": "ThrottleCurve2", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0 + }, + { + "name": "25", + "value": 0.22499999403953552 + }, + { + "name": "50", + "value": 0.44999998807907104 + }, + { + "name": "75", + "value": 0.67499995231628418 + }, + { + "name": "100", + "value": 0.89999997615814209 + } + ] + }, + { + "name": "MixerValueRoll", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 50 + } + ] + }, + { + "name": "MixerValuePitch", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 50 + } + ] + }, + { + "name": "MixerValueYaw", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 50 + } + ] + }, + { + "name": "Curve2Source", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Throttle" + } + ] + }, + { + "name": "Mixer1Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Motor" + } + ] + }, + { + "name": "Mixer1Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 127 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 64 + }, + { + "name": "Pitch", + "value": 64 + }, + { + "name": "Yaw", + "value": -64 + } + ] + }, + { + "name": "Mixer2Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Motor" + } + ] + }, + { + "name": "Mixer2Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 127 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": -64 + }, + { + "name": "Pitch", + "value": 64 + }, + { + "name": "Yaw", + "value": 64 + } + ] + }, + { + "name": "Mixer3Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Motor" + } + ] + }, + { + "name": "Mixer3Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 127 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": -64 + }, + { + "name": "Pitch", + "value": -64 + }, + { + "name": "Yaw", + "value": -64 + } + ] + }, + { + "name": "Mixer4Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Motor" + } + ] + }, + { + "name": "Mixer4Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 127 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 64 + }, + { + "name": "Pitch", + "value": -64 + }, + { + "name": "Yaw", + "value": 64 + } + ] + }, + { + "name": "Mixer5Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer5Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer6Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer6Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer7Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer7Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer8Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer8Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer9Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer9Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer10Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer10Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer11Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer11Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer12Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer12Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + } + ], + "id": "7BF2CFA8", + "instance": 0, + "name": "MixerSettings", + "setting": true + }, + { + "fields": [ + { + "name": "P", + "type": "float32", + "unit": "1^2", + "values": [ + { + "name": "PositionNorth", + "value": 10 + }, + { + "name": "PositionEast", + "value": 10 + }, + { + "name": "PositionDown", + "value": 10 + }, + { + "name": "VelocityNorth", + "value": 1 + }, + { + "name": "VelocityEast", + "value": 1 + }, + { + "name": "VelocityDown", + "value": 1 + }, + { + "name": "AttitudeQ1", + "value": 0.0070000002160668373 + }, + { + "name": "AttitudeQ2", + "value": 0.0070000002160668373 + }, + { + "name": "AttitudeQ3", + "value": 0.0070000002160668373 + }, + { + "name": "AttitudeQ4", + "value": 0.0070000002160668373 + }, + { + "name": "GyroDriftX", + "value": 9.9999999747524271e-07 + }, + { + "name": "GyroDriftY", + "value": 9.9999999747524271e-07 + }, + { + "name": "GyroDriftZ", + "value": 9.9999999747524271e-07 + } + ] + }, + { + "name": "Q", + "type": "float32", + "unit": "1^2", + "values": [ + { + "name": "GyroX", + "value": 0.0099999997764825821 + }, + { + "name": "GyroY", + "value": 0.0099999997764825821 + }, + { + "name": "GyroZ", + "value": 0.0099999997764825821 + }, + { + "name": "AccelX", + "value": 0.0099999997764825821 + }, + { + "name": "AccelY", + "value": 0.0099999997764825821 + }, + { + "name": "AccelZ", + "value": 0.0099999997764825821 + }, + { + "name": "GyroDriftX", + "value": 9.9999999747524271e-07 + }, + { + "name": "GyroDriftY", + "value": 9.9999999747524271e-07 + }, + { + "name": "GyroDriftZ", + "value": 9.9999999747524271e-07 + } + ] + }, + { + "name": "R", + "type": "float32", + "unit": "1^2", + "values": [ + { + "name": "GPSPosNorth", + "value": 1 + }, + { + "name": "GPSPosEast", + "value": 1 + }, + { + "name": "GPSPosDown", + "value": 1000000 + }, + { + "name": "GPSVelNorth", + "value": 0.0010000000474974513 + }, + { + "name": "GPSVelEast", + "value": 0.0010000000474974513 + }, + { + "name": "GPSVelDown", + "value": 0.0010000000474974513 + }, + { + "name": "MagX", + "value": 10 + }, + { + "name": "MagY", + "value": 10 + }, + { + "name": "MagZ", + "value": 10 + }, + { + "name": "BaroZ", + "value": 0.0099999997764825821 + } + ] + }, + { + "name": "FakeR", + "type": "float32", + "unit": "1^2", + "values": [ + { + "name": "FakeGPSPosIndoor", + "value": 10 + }, + { + "name": "FakeGPSVelIndoor", + "value": 1 + }, + { + "name": "FakeGPSVelAirspeed", + "value": 1000 + } + ] + } + ], + "id": "5E91213C", + "instance": 0, + "name": "EKFConfiguration", + "setting": true + } + ], + "owner": "Jim", + "photo": "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", + "propeller": "6 x 4.5", + "servo": "", + "size": "320", + "subtype": 2, + "type": 1, + "uuid": "{cf693467-fcb3-4eae-a0ab-43fe218baaba}", + "weight": "898" +} diff --git a/ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/H-KingCarbon250ARF-Multirotor-QuadrocopterX-b91ae8ac277.optmpl b/ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/H-KingCarbon250ARF-Multirotor-QuadrocopterX-b91ae8ac277.optmpl new file mode 100644 index 000000000..700e289ad --- /dev/null +++ b/ground/openpilotgcs/share/openpilotgcs/cloudconfig/multirotor/H-KingCarbon250ARF-Multirotor-QuadrocopterX-b91ae8ac277.optmpl @@ -0,0 +1,2186 @@ +{ + "battery": "3s 1300 35c", + "comment": "Acro tune for Rate , Acro +, Attitude and rattitude\nBank 1 Attitude / Acro +\nBank 2 Rattitude ", + "controller": "CC3D", + "esc": "Argonaut 20a Blheli", + "motor": "DYS 1806-2300kv", + "name": "H-King Carbon 250 ARF", + "nick": "Failsafe", + "objects": [ + { + "fields": [ + { + "name": "VbarSensitivity", + "type": "float32", + "unit": "frac", + "values": [ + { + "name": "Roll", + "value": 0.5 + }, + { + "name": "Pitch", + "value": 0.5 + }, + { + "name": "Yaw", + "value": 0.5 + } + ] + }, + { + "name": "VbarRollPI", + "type": "float32", + "unit": "1/(deg/s)", + "values": [ + { + "name": "Kp", + "value": 0.004999999888241291 + }, + { + "name": "Ki", + "value": 0.0020000000949949026 + } + ] + }, + { + "name": "VbarPitchPI", + "type": "float32", + "unit": "1/(deg/s)", + "values": [ + { + "name": "Kp", + "value": 0.004999999888241291 + }, + { + "name": "Ki", + "value": 0.0020000000949949026 + } + ] + }, + { + "name": "VbarYawPI", + "type": "float32", + "unit": "1/(deg/s)", + "values": [ + { + "name": "Kp", + "value": 0.004999999888241291 + }, + { + "name": "Ki", + "value": 0.0020000000949949026 + } + ] + }, + { + "name": "VbarTau", + "type": "float32", + "unit": "sec", + "values": [ + { + "name": "0", + "value": 0.5 + } + ] + }, + { + "name": "GyroTau", + "type": "float32", + "unit": "", + "values": [ + { + "name": "0", + "value": 0.004999999888241291 + } + ] + }, + { + "name": "DerivativeGamma", + "type": "float32", + "unit": "", + "values": [ + { + "name": "0", + "value": 1 + } + ] + }, + { + "name": "AxisLockKp", + "type": "float32", + "unit": "", + "values": [ + { + "name": "0", + "value": 2.5 + } + ] + }, + { + "name": "WeakLevelingKp", + "type": "float32", + "unit": "(deg/s)/deg", + "values": [ + { + "name": "0", + "value": 0.10000000149011612 + } + ] + }, + { + "name": "CruiseControlMaxPowerFactor", + "type": "float32", + "unit": "x", + "values": [ + { + "name": "0", + "value": 3 + } + ] + }, + { + "name": "CruiseControlPowerTrim", + "type": "float32", + "unit": "%", + "values": [ + { + "name": "0", + "value": 100 + } + ] + }, + { + "name": "CruiseControlPowerDelayComp", + "type": "float32", + "unit": "sec", + "values": [ + { + "name": "0", + "value": 0.25 + } + ] + }, + { + "name": "ScaleToAirspeed", + "type": "float32", + "unit": "m/s", + "values": [ + { + "name": "0", + "value": 0 + } + ] + }, + { + "name": "ScaleToAirspeedLimits", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Min", + "value": 0.05000000074505806 + }, + { + "name": "Max", + "value": 3 + } + ] + }, + { + "name": "FlightModeMap", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Bank1" + }, + { + "name": "1", + "value": "Bank1" + }, + { + "name": "2", + "value": "Bank1" + }, + { + "name": "3", + "value": "Bank1" + }, + { + "name": "4", + "value": "Bank1" + }, + { + "name": "5", + "value": "Bank1" + } + ] + }, + { + "name": "VbarGyroSuppress", + "type": "int8", + "unit": "%", + "values": [ + { + "name": "0", + "value": 30 + } + ] + }, + { + "name": "VbarPiroComp", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "VbarMaxAngle", + "type": "uint8", + "unit": "deg", + "values": [ + { + "name": "0", + "value": 10 + } + ] + }, + { + "name": "DerivativeCutoff", + "type": "uint8", + "unit": "Hz", + "values": [ + { + "name": "0", + "value": 20 + } + ] + }, + { + "name": "MaxAxisLock", + "type": "uint8", + "unit": "deg", + "values": [ + { + "name": "0", + "value": 30 + } + ] + }, + { + "name": "MaxAxisLockRate", + "type": "uint8", + "unit": "deg/s", + "values": [ + { + "name": "0", + "value": 2 + } + ] + }, + { + "name": "MaxWeakLevelingRate", + "type": "uint8", + "unit": "deg/s", + "values": [ + { + "name": "0", + "value": 5 + } + ] + }, + { + "name": "RattitudeModeTransition", + "type": "uint8", + "unit": "%", + "values": [ + { + "name": "0", + "value": 80 + } + ] + }, + { + "name": "CruiseControlMinThrust", + "type": "int8", + "unit": "%", + "values": [ + { + "name": "0", + "value": 5 + } + ] + }, + { + "name": "CruiseControlMaxThrust", + "type": "uint8", + "unit": "%", + "values": [ + { + "name": "0", + "value": 90 + } + ] + }, + { + "name": "CruiseControlMaxAngle", + "type": "uint8", + "unit": "deg", + "values": [ + { + "name": "0", + "value": 105 + } + ] + }, + { + "name": "CruiseControlFlightModeSwitchPosEnable", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + }, + { + "name": "1", + "value": "FALSE" + }, + { + "name": "2", + "value": "FALSE" + }, + { + "name": "3", + "value": "FALSE" + }, + { + "name": "4", + "value": "FALSE" + }, + { + "name": "5", + "value": "FALSE" + } + ] + }, + { + "name": "CruiseControlInvertedThrustReversing", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Unreversed" + } + ] + }, + { + "name": "CruiseControlInvertedPowerOutput", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Zero" + } + ] + }, + { + "name": "LowThrottleZeroIntegral", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "TRUE" + } + ] + }, + { + "name": "FlightModeAssistMap", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "None" + }, + { + "name": "1", + "value": "None" + }, + { + "name": "2", + "value": "None" + }, + { + "name": "3", + "value": "None" + }, + { + "name": "4", + "value": "None" + }, + { + "name": "5", + "value": "None" + } + ] + } + ], + "id": "73603180", + "instance": 0, + "name": "StabilizationSettings", + "setting": true + }, + { + "fields": [ + { + "name": "ManualRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 300 + }, + { + "name": "Pitch", + "value": 300 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "MaximumRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 300 + }, + { + "name": "Pitch", + "value": 300 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "RollRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0019499999471008778 + }, + { + "name": "Ki", + "value": 0.0048400000669062138 + }, + { + "name": "Kd", + "value": 2.4999999368446879e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "PitchRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.003229999914765358 + }, + { + "name": "Ki", + "value": 0.0091899996623396873 + }, + { + "name": "Kd", + "value": 3.5000000934815034e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "YawRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0069400002248585224 + }, + { + "name": "Ki", + "value": 0.0086000002920627594 + }, + { + "name": "Kd", + "value": 3.9999998989515007e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "RollPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.0999999046325684 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "PitchPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5999999046325684 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "YawPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "AcroInsanityFactor", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.40000000596046448 + } + ] + }, + { + "name": "ThrustPIDScaleCurve", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": -1.427447386959102e-05 + }, + { + "name": "25", + "value": -0.0085789738222956657 + }, + { + "name": "50", + "value": -0.038573265075683594 + }, + { + "name": "75", + "value": -0.15000000596046448 + }, + { + "name": "100", + "value": -0.30000001192092896 + } + ] + }, + { + "name": "RollMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "PitchMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "YawMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 35 + } + ] + }, + { + "name": "StickExpo", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "EnablePiroComp", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "EnableThrustPIDScaling", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "TRUE" + } + ] + }, + { + "name": "ThrustPIDScaleSource", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "ActuatorDesiredThrust" + } + ] + }, + { + "name": "ThrustPIDScaleTarget", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "PD" + } + ] + }, + { + "name": "ThrustPIDScaleAxes", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Roll Pitch" + } + ] + } + ], + "id": "E8EBBD48", + "instance": 0, + "name": "StabilizationSettingsBank1", + "setting": true + }, + { + "fields": [ + { + "name": "ManualRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 400 + }, + { + "name": "Pitch", + "value": 400 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "MaximumRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 400 + }, + { + "name": "Pitch", + "value": 400 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "RollRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0019499999471008778 + }, + { + "name": "Ki", + "value": 0.0048400000669062138 + }, + { + "name": "Kd", + "value": 2.4999999368446879e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "PitchRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.003229999914765358 + }, + { + "name": "Ki", + "value": 0.0091899996623396873 + }, + { + "name": "Kd", + "value": 3.5000000934815034e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "YawRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0069400002248585224 + }, + { + "name": "Ki", + "value": 0.0086000002920627594 + }, + { + "name": "Kd", + "value": 3.9999998989515007e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "RollPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.0999999046325684 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "PitchPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5999999046325684 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "YawPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "AcroInsanityFactor", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.40000000596046448 + } + ] + }, + { + "name": "ThrustPIDScaleCurve", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": -1.427447386959102e-05 + }, + { + "name": "25", + "value": -0.0085789738222956657 + }, + { + "name": "50", + "value": -0.038573265075683594 + }, + { + "name": "75", + "value": -0.15000000596046448 + }, + { + "name": "100", + "value": -0.30000001192092896 + } + ] + }, + { + "name": "RollMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "PitchMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "YawMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 35 + } + ] + }, + { + "name": "StickExpo", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "EnablePiroComp", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "EnableThrustPIDScaling", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "TRUE" + } + ] + }, + { + "name": "ThrustPIDScaleSource", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "ActuatorDesiredThrust" + } + ] + }, + { + "name": "ThrustPIDScaleTarget", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "PD" + } + ] + }, + { + "name": "ThrustPIDScaleAxes", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Roll Pitch" + } + ] + } + ], + "id": "70E9539A", + "instance": 0, + "name": "StabilizationSettingsBank2", + "setting": true + }, + { + "fields": [ + { + "name": "ManualRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 220 + }, + { + "name": "Pitch", + "value": 220 + }, + { + "name": "Yaw", + "value": 220 + } + ] + }, + { + "name": "MaximumRate", + "type": "float32", + "unit": "degrees/sec", + "values": [ + { + "name": "Roll", + "value": 300 + }, + { + "name": "Pitch", + "value": 300 + }, + { + "name": "Yaw", + "value": 300 + } + ] + }, + { + "name": "RollRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0030000000260770321 + }, + { + "name": "Ki", + "value": 0.0065000001341104507 + }, + { + "name": "Kd", + "value": 3.3000000257743523e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "PitchRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0030000000260770321 + }, + { + "name": "Ki", + "value": 0.0065000001341104507 + }, + { + "name": "Kd", + "value": 3.3000000257743523e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "YawRatePID", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 0.0062000001780688763 + }, + { + "name": "Ki", + "value": 0.0099999997764825821 + }, + { + "name": "Kd", + "value": 4.9999998736893758e-05 + }, + { + "name": "ILimit", + "value": 0.30000001192092896 + } + ] + }, + { + "name": "RollPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "PitchPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "YawPI", + "type": "float32", + "unit": "", + "values": [ + { + "name": "Kp", + "value": 2.5 + }, + { + "name": "Ki", + "value": 0 + }, + { + "name": "ILimit", + "value": 50 + } + ] + }, + { + "name": "AcroInsanityFactor", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.40000000596046448 + } + ] + }, + { + "name": "ThrustPIDScaleCurve", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0.30000001192092896 + }, + { + "name": "25", + "value": 0.15000000596046448 + }, + { + "name": "50", + "value": 0 + }, + { + "name": "75", + "value": -0.15000000596046448 + }, + { + "name": "100", + "value": -0.30000001192092896 + } + ] + }, + { + "name": "RollMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "PitchMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 55 + } + ] + }, + { + "name": "YawMax", + "type": "uint8", + "unit": "degrees", + "values": [ + { + "name": "0", + "value": 35 + } + ] + }, + { + "name": "StickExpo", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "EnablePiroComp", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "TRUE" + } + ] + }, + { + "name": "EnableThrustPIDScaling", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "FALSE" + } + ] + }, + { + "name": "ThrustPIDScaleSource", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "ActuatorDesiredThrust" + } + ] + }, + { + "name": "ThrustPIDScaleTarget", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "PID" + } + ] + }, + { + "name": "ThrustPIDScaleAxes", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Roll Pitch" + } + ] + } + ], + "id": "C02DAA6A", + "instance": 0, + "name": "StabilizationSettingsBank3", + "setting": true + }, + { + "fields": [ + { + "name": "MaxAccel", + "type": "float32", + "unit": "units/sec", + "values": [ + { + "name": "0", + "value": 1000 + } + ] + }, + { + "name": "FeedForward", + "type": "float32", + "unit": "", + "values": [ + { + "name": "0", + "value": 0 + } + ] + }, + { + "name": "AccelTime", + "type": "float32", + "unit": "ms", + "values": [ + { + "name": "0", + "value": 0 + } + ] + }, + { + "name": "DecelTime", + "type": "float32", + "unit": "ms", + "values": [ + { + "name": "0", + "value": 0 + } + ] + }, + { + "name": "ThrottleCurve1", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0 + }, + { + "name": "25", + "value": 0.22499999403953552 + }, + { + "name": "50", + "value": 0.44999998807907104 + }, + { + "name": "75", + "value": 0.67499995231628418 + }, + { + "name": "100", + "value": 0.89999997615814209 + } + ] + }, + { + "name": "ThrottleCurve2", + "type": "float32", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 0 + }, + { + "name": "25", + "value": 0.22499999403953552 + }, + { + "name": "50", + "value": 0.44999998807907104 + }, + { + "name": "75", + "value": 0.67499995231628418 + }, + { + "name": "100", + "value": 0.89999997615814209 + } + ] + }, + { + "name": "MixerValueRoll", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 50 + } + ] + }, + { + "name": "MixerValuePitch", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 50 + } + ] + }, + { + "name": "MixerValueYaw", + "type": "int8", + "unit": "percent", + "values": [ + { + "name": "0", + "value": 50 + } + ] + }, + { + "name": "Curve2Source", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Throttle" + } + ] + }, + { + "name": "Mixer1Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Motor" + } + ] + }, + { + "name": "Mixer1Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 127 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 64 + }, + { + "name": "Pitch", + "value": 64 + }, + { + "name": "Yaw", + "value": -64 + } + ] + }, + { + "name": "Mixer2Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Motor" + } + ] + }, + { + "name": "Mixer2Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 127 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": -64 + }, + { + "name": "Pitch", + "value": 64 + }, + { + "name": "Yaw", + "value": 64 + } + ] + }, + { + "name": "Mixer3Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Motor" + } + ] + }, + { + "name": "Mixer3Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 127 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": -64 + }, + { + "name": "Pitch", + "value": -64 + }, + { + "name": "Yaw", + "value": -64 + } + ] + }, + { + "name": "Mixer4Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Motor" + } + ] + }, + { + "name": "Mixer4Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 127 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 64 + }, + { + "name": "Pitch", + "value": -64 + }, + { + "name": "Yaw", + "value": 64 + } + ] + }, + { + "name": "Mixer5Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer5Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer6Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer6Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer7Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer7Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer8Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer8Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer9Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer9Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer10Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer10Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer11Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer11Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + }, + { + "name": "Mixer12Type", + "type": "enum", + "unit": "", + "values": [ + { + "name": "0", + "value": "Disabled" + } + ] + }, + { + "name": "Mixer12Vector", + "type": "int8", + "unit": "", + "values": [ + { + "name": "ThrottleCurve1", + "value": 0 + }, + { + "name": "ThrottleCurve2", + "value": 0 + }, + { + "name": "Roll", + "value": 0 + }, + { + "name": "Pitch", + "value": 0 + }, + { + "name": "Yaw", + "value": 0 + } + ] + } + ], + "id": "7BF2CFA8", + "instance": 0, + "name": "MixerSettings", + "setting": true + }, + { + "fields": [ + { + "name": "P", + "type": "float32", + "unit": "1^2", + "values": [ + { + "name": "PositionNorth", + "value": 10 + }, + { + "name": "PositionEast", + "value": 10 + }, + { + "name": "PositionDown", + "value": 10 + }, + { + "name": "VelocityNorth", + "value": 1 + }, + { + "name": "VelocityEast", + "value": 1 + }, + { + "name": "VelocityDown", + "value": 1 + }, + { + "name": "AttitudeQ1", + "value": 0.0070000002160668373 + }, + { + "name": "AttitudeQ2", + "value": 0.0070000002160668373 + }, + { + "name": "AttitudeQ3", + "value": 0.0070000002160668373 + }, + { + "name": "AttitudeQ4", + "value": 0.0070000002160668373 + }, + { + "name": "GyroDriftX", + "value": 9.9999999747524271e-07 + }, + { + "name": "GyroDriftY", + "value": 9.9999999747524271e-07 + }, + { + "name": "GyroDriftZ", + "value": 9.9999999747524271e-07 + } + ] + }, + { + "name": "Q", + "type": "float32", + "unit": "1^2", + "values": [ + { + "name": "GyroX", + "value": 0.0099999997764825821 + }, + { + "name": "GyroY", + "value": 0.0099999997764825821 + }, + { + "name": "GyroZ", + "value": 0.0099999997764825821 + }, + { + "name": "AccelX", + "value": 0.0099999997764825821 + }, + { + "name": "AccelY", + "value": 0.0099999997764825821 + }, + { + "name": "AccelZ", + "value": 0.0099999997764825821 + }, + { + "name": "GyroDriftX", + "value": 9.9999999747524271e-07 + }, + { + "name": "GyroDriftY", + "value": 9.9999999747524271e-07 + }, + { + "name": "GyroDriftZ", + "value": 9.9999999747524271e-07 + } + ] + }, + { + "name": "R", + "type": "float32", + "unit": "1^2", + "values": [ + { + "name": "GPSPosNorth", + "value": 1 + }, + { + "name": "GPSPosEast", + "value": 1 + }, + { + "name": "GPSPosDown", + "value": 1000000 + }, + { + "name": "GPSVelNorth", + "value": 0.0010000000474974513 + }, + { + "name": "GPSVelEast", + "value": 0.0010000000474974513 + }, + { + "name": "GPSVelDown", + "value": 0.0010000000474974513 + }, + { + "name": "MagX", + "value": 10 + }, + { + "name": "MagY", + "value": 10 + }, + { + "name": "MagZ", + "value": 10 + }, + { + "name": "BaroZ", + "value": 0.0099999997764825821 + } + ] + }, + { + "name": "FakeR", + "type": "float32", + "unit": "1^2", + "values": [ + { + "name": "FakeGPSPosIndoor", + "value": 10 + }, + { + "name": "FakeGPSVelIndoor", + "value": 1 + }, + { + "name": "FakeGPSVelAirspeed", + "value": 1000 + } + ] + } + ], + "id": "5E91213C", + "instance": 0, + "name": "EKFConfiguration", + "setting": true + } + ], + "owner": "Jim", + "photo": "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", + "propeller": "5x3 Carbon", + "servo": "", + "size": "250", + "subtype": 2, + "type": 1, + "uuid": "{2177947e-c1b1-4724-9b76-db91ae8ac277}", + "weight": "410" +} diff --git a/ground/openpilotgcs/share/openpilotgcs/diagrams/default/system-health.svg b/ground/openpilotgcs/share/openpilotgcs/diagrams/default/system-health.svg index 42fdf22ac..8ebee3cc8 100644 --- a/ground/openpilotgcs/share/openpilotgcs/diagrams/default/system-health.svg +++ b/ground/openpilotgcs/share/openpilotgcs/diagrams/default/system-health.svg @@ -30,7 +30,7 @@ inkscape:zoom="6.5977991" inkscape:cx="55.083588" inkscape:cy="24.071773" - inkscape:current-layer="layer45" + inkscape:current-layer="layer46" id="namedview3608" showgrid="true" inkscape:window-width="1280" @@ -1685,6 +1685,20 @@ ry="0.98050147" inkscape:label="#rect4550-8-1-4-21-1" /> + + + Do not translate ! + + + haslimits:yes + Do not translate ! + + MixerCurve @@ -6754,7 +6760,7 @@ Applique et Enregistre tous les paramètres sur la SD <html><head/><body><p>Setup output mode. Use PWM or PWMSync with Standard ESCs.<br/>Several other ESCs like BLHeli 13+ can use the more advanced OneShot125.<br/>When using OneShot125 all values set in min/max and idle are divided by <br/>eight before being sent to esc (i.e. 1000 = 125, 2000 = 250).</p></body></html> - <html><head/><body><p>Configuration du mode de sortie. Utilisez PWM ou PWMSync avec des ESC Standard.<br/>D'autres contrôleurs comme les BLHeli 13+ peuvent utiliser le mode avancé OneShot125.<br/>Lorsque vous utilisez OneShot125 toutes les valeurs min/max et neutre sont divisées par <br/>huit avant d'être envoyées vers le contrôleur (ex. 1000 = 125, 2000 = 250).</p></body></html> + <html><head/><body><p>Configuration du mode de sortie. Utilisez PWM ou PWMSync avec des ESC Standard.<br/>D'autres contrôleurs comme les BLHeli 13+ peuvent utiliser le mode avancé OneShot125.<br/>Lorsque vous utilisez OneShot125 toutes les valeurs min/max et neutre sont divisées par <br/>huit avant d'être envoyées vers le contrôleur (ex. 1000 = 125, 2000 = 250).</p></body></html> @@ -7157,7 +7163,7 @@ p, li { white-space: pre-wrap; } </style></head><body style=" font-family:'MS Shell Dlg 2'; font-size:10pt; font-weight:400; font-style:normal;"> <p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-weight:600;"><br /></p></body></html> Blank text ? - + @@ -9123,7 +9129,7 @@ les données en cache Diagramme de Connexion - + Save File Enregistrer Fichier @@ -9606,31 +9612,31 @@ Veuillez sélectionner le type de multirotor désiré pour la configuration ci-d - + Start Démarrer - + - + Output value : <b>%1</b> µs Valeur de sortie : <b>%1</b> µs - + <html><head/><body><p><span style=" font-size:10pt;">To find </span><span style=" font-size:10pt; font-weight:600;">the neutral rate for this reversable motor</span><span style=" font-size:10pt;">, press the Start button below and slide the slider to the right or left until you find the value where the motor doesn't start. <br/><br/>When done press button again to stop.</span></p></body></html> <html><head/><body><p><span style=" font-size:10pt;">Pour trouver </span><span style=" font-size:10pt; font-weight:600;">la valeur de neutre de ce moteur inversable</span><span style=" font-size:10pt;">, appuyez sur le bouton Démarrer et bouger le curseur à gauche ou à droite jusqu'à trouver la position centrale où le moteur ne démarre pas. <br/><br/>Lorsque c'est terminé, appuyer à nouveau sur le bouton pour arrêter.</span></p></body></html> - + Stop Arrêter - + The actuator module is in an error state. Please make sure the correct firmware version is used then restart the wizard and try again. If the problem persists please consult the openpilot.org support forum. @@ -9911,7 +9917,7 @@ Veuillez sélectionner le type de véhicule terrestre dont vous voulez créer la This setup currently expects a motorcyle setup, using one motor and one servo for steering. - Cette configuration correspond à une moto utilisant un moteur et un servo pour la direction. + Cette configuration correspond à une moto utilisant un moteur et un servo pour la direction. @@ -10691,7 +10697,7 @@ Voulez-vous toujours continuer ? Vous devrez reconfigurer manuellement les paramètres d'armement lorsque l'assistant sera terminé. Après la dernière étape de l'assistant, vous serez redirigé vers l'écran des Paramètres d'Armement. - + Next Suivant @@ -10882,7 +10888,7 @@ Bougez le manche %1. Arrêter Calibration Manuelle - + <p>Arming Settings are now set to 'Always Disarmed' for your safety.</p><p>Be sure your receiver is powered with an external source and Transmitter is on.</p><p align='center'><b>Stop Manual Calibration</b> when done</p> <p>Pour des raisons de sécurité les Paramètres d'Armement ont été modifiés à 'Toujours Désarmé'.</p><p>Veuillez vérifier que votre récepteur est alimenté avec une source externe et que la radio Rx est allumée. <p align='center'><b>Arrêter Calibration Manuelle</b> à la fin</p> @@ -10892,10 +10898,20 @@ Bougez le manche %1. Vous devrez reconfigurer les paramètres d'armement manuellement lorsque la calibration manuelle sera terminée. - + Start Manual Calibration Démarrer Calibration Manuelle + + + Warning + Attention + + + + <p>There is something wrong with Throttle range. Please redo calibration and move <b>ALL sticks</b>, Throttle stick included.</p> + <p>Quelque chose ne va pas avec la plage du manche de Gaz. Veuillez relancer la calibration Tx et bouger <b>TOUS les manches</b>, manche des gaz inclus</p> + You will have to reconfigure the arming settings manually when the wizard is finished. Vous devrez reconfigurer les paramètres d'armement manuellement lorsque l'assistant sera terminé. @@ -11249,14 +11265,14 @@ Double clic sur la légende ou le tracé pour afficher/cacher la légende. - + Unknown Inconnu - + Vehicle type: Type de véhicule : @@ -11416,6 +11432,11 @@ Double clic sur la légende ou le tracé pour afficher/cacher la légende.Rapid ESC (%1 Hz) Contrôleur Rapide (%1 Hz) + + + Synched ESC + Contrôleur Synchronisé + Oneshot ESC @@ -11510,7 +11531,7 @@ Double clic sur la légende ou le tracé pour afficher/cacher la légende.Échoué ! - + Writing External Mag sensor settings Écriture paramètres Compas Externe @@ -11530,7 +11551,7 @@ Double clic sur la légende ou le tracé pour afficher/cacher la légende.Écriture paramètres matériels - + Writing actuator settings @@ -12365,6 +12386,11 @@ La carte sera redémarrée et tous les paramètres effacés. - - + + + Prev + Précédent + CustomConfigWidget @@ -13590,8 +13616,12 @@ p, li { white-space: pre-wrap; } + OneShot and PWMSync output only works with Receiver Port settings marked with '+OneShot'<br>When using Receiver Port setting 'PPM_PIN8+OneShot' <b><font color='%1'>Bank %2</font></b> must be set to PWM + OneShot et PWMSync fonctionnent uniquement avec les ports récepteur marqués avec '+OneShot'<br>Lors de l'utilisation de la configuration 'PPM_PIN8+OneShot' <b><font color='%1'>la Banque %2</font></b> doit être réglée sur PWM + + OneShot only works with Receiver Port settings marked with '+OneShot'<br>When using Receiver Port setting 'PPM_PIN8+OneShot' <b><font color='%1'>Bank %2</font></b> must be set to PWM - OneShot fonctionne uniquement avec les ports récepteur marqués avec '+OneShot'<br>Lors de l'utilisation de la configuration 'PPM_PIN8+OneShot' <b><font color='%1'>la Banque %2</font></b> doit être réglée sur PWM + OneShot fonctionne uniquement avec les ports récepteur marqués avec '+OneShot'<br>Lors de l'utilisation de la configuration 'PPM_PIN8+OneShot' <b><font color='%1'>la Banque %2</font></b> doit être réglée sur PWM OneShot only works with MainPort settings marked with "+OneShot" @@ -14640,7 +14670,7 @@ pas seulement les champs visibles à l'écran. RT - + @@ -14729,7 +14759,7 @@ et même conduire au crash. A utiliser avec prudence. Text - Texte + @@ -15141,7 +15171,7 @@ It is suggested that if this is a first time configuration of your controller, r Il est suggéré que si cela est une première configuration de votre contrôleur, plutôt que d'utiliser cette option, sélectionnez à la place un ensemble de réglages qui correspond le mieux à votre propre appareil dans la liste ci-dessus. Si vous n'êtes pas en mesure d'en choisir un, sélectionnez l'élément générique de la liste. - + Current Tuning Réglages Actuels @@ -15546,7 +15576,7 @@ p, li { white-space: pre-wrap; } OPTemplates - + @@ -15721,7 +15751,7 @@ A noter : Pour le GPS OpenPilot v8, veuillez choisir l'option GPS U-Blox. - + @@ -16070,4 +16100,72 @@ IMPORTANT : Ces nouveaux paramètres ne sont pas encore enregistrés sur la cart Annuler + + ConfigCcpmWidget + + + <h1>Swashplate Leveling Routine</h1> + + + + + <b>You are about to start the Swashplate levelling routine.</b><p>This process will start by downloading the current configuration from the GCS to the OP hardware and will adjust your configuration at various stages.<p>The final state of your system should match the current configuration in the GCS config gadget.</p><p>Please ensure all ccpm settings in the GCS are correct before continuing.</p><p>If this process is interrupted, then the state of your OP board may not match the GCS configuration.</p><p><i>After completing this process, please check all settings before attempting to fly.</i></p><p><font color=red><b>Please disconnect your motor to ensure it will not spin up.</b></font><p><hr><i>Do you wish to proceed?</i></p> + + + + + <h2>Neutral levelling</h2><p>Using adjustment of:<ul><li>Servo horns,</li><li>Link lengths,</li><li>Neutral triming spinboxes to the right</li></ul><br>Ensure that the swashplate is in the center of desired travel range and is level. + + + + + <h2>Max levelling</h2><p>Using adjustment of:<ul><li>Max triming spinboxes to the right ONLY</li></ul><br>Ensure that the swashplate is at the top of desired travel range and is level. + + + + + <h2>Min levelling</h2><p>Using adjustment of:<ul><li>Min triming spinboxes to the right ONLY</li></ul><br>Ensure that the swashplate is at the bottom of desired travel range and is level. + + + + + <h2>Levelling verification</h2><p>Adjust the slider to the right over it's full range and observe the swashplate motion. It should remain level over the entire range of travel.</p> + + + + + <h2>Levelling complete</h2><p>Press the Finish button to save these settings to the SD card</p><p>Press the cancel button to return to the pre-levelling settings</p> + + + + + <h2>Levelling Cancelled</h2><p>Previous settings have been restored. + + + + + <h2>Levelling Completed</h2><p>New settings have been saved to the SD card + + + + + <font color=red><h1>Warning!!!</h2></font> + + + + + <h2>This code has many configurations.</h2><p>Please double check all settings before attempting flight! + + + + + <h2>The CCPM mixer code needs more testing!</h2><p><font color=red>Use it at your own risk!</font><p>Do you wish to continue? + + + + + <h2>The CCPM swashplate levelling code is NOT complete!</h2><p><font color=red>DO NOT use it for flight!</font> + + + diff --git a/ground/openpilotgcs/src/plugins/config/airframe_ccpm.ui b/ground/openpilotgcs/src/plugins/config/airframe_ccpm.ui index 87503edc9..8b7e8bfe7 100644 --- a/ground/openpilotgcs/src/plugins/config/airframe_ccpm.ui +++ b/ground/openpilotgcs/src/plugins/config/airframe_ccpm.ui @@ -116,7 +116,7 @@ QGroupBox::title { QTabWidget::Rounded - 1 + 0 false diff --git a/ground/openpilotgcs/src/plugins/config/camerastabilization.ui b/ground/openpilotgcs/src/plugins/config/camerastabilization.ui index 168346c81..808bef209 100644 --- a/ground/openpilotgcs/src/plugins/config/camerastabilization.ui +++ b/ground/openpilotgcs/src/plugins/config/camerastabilization.ui @@ -57,7 +57,7 @@ - + 0 0 @@ -72,9 +72,9 @@ 0 - 0 - 750 - 729 + -103 + 748 + 811 @@ -95,24 +95,6 @@ - - - 0 - 0 - - - - - 0 - 0 - - - - - 16777215 - 16777215 - - Module Control @@ -139,24 +121,6 @@ - - - 0 - 0 - - - - - 0 - 110 - - - - - 16777215 - 16777215 - - Basic Settings (Stabilization) @@ -381,24 +345,6 @@ font:bold; - - - 0 - 0 - - - - - 0 - 187 - - - - - 16777215 - 16777215 - - Advanced Settings (Control) @@ -863,12 +809,6 @@ value. - - - 0 - 187 - - Expert Settings (Attitude Filter and Feed Forward) @@ -1324,18 +1264,6 @@ The same value is used for all axes. - - - 0 - 50 - - - - - 16777215 - 16777215 - - Messages diff --git a/ground/openpilotgcs/src/plugins/config/cfg_vehicletypes/configfixedwingwidget.cpp b/ground/openpilotgcs/src/plugins/config/cfg_vehicletypes/configfixedwingwidget.cpp index 84378e342..0640c639b 100644 --- a/ground/openpilotgcs/src/plugins/config/cfg_vehicletypes/configfixedwingwidget.cpp +++ b/ground/openpilotgcs/src/plugins/config/cfg_vehicletypes/configfixedwingwidget.cpp @@ -358,7 +358,7 @@ bool ConfigFixedWingWidget::setupFrameFixedWing(QString airframeType) // rudder channel = m_aircraft->fwRudder1ChannelBox->currentIndex() - 1; setMixerType(mixer, channel, VehicleConfig::MIXERTYPE_SERVO); - setMixerVectorValue(mixer, channel, VehicleConfig::MIXERVECTOR_YAW, 127); + setMixerVectorValue(mixer, channel, VehicleConfig::MIXERVECTOR_YAW, -127); // ailerons channel = m_aircraft->fwAileron1ChannelBox->currentIndex() - 1; @@ -542,13 +542,13 @@ bool ConfigFixedWingWidget::setupFrameVtail(QString airframeType) // First Vtail servo setMixerType(mixer, channel, VehicleConfig::MIXERTYPE_SERVO); setMixerVectorValue(mixer, channel, VehicleConfig::MIXERVECTOR_PITCH, -pitch); - setMixerVectorValue(mixer, channel, VehicleConfig::MIXERVECTOR_YAW, yaw); + setMixerVectorValue(mixer, channel, VehicleConfig::MIXERVECTOR_YAW, -yaw); // Second Vtail servo channel = m_aircraft->fwElevator2ChannelBox->currentIndex() - 1; setMixerType(mixer, channel, VehicleConfig::MIXERTYPE_SERVO); setMixerVectorValue(mixer, channel, VehicleConfig::MIXERVECTOR_PITCH, pitch); - setMixerVectorValue(mixer, channel, VehicleConfig::MIXERVECTOR_YAW, yaw); + setMixerVectorValue(mixer, channel, VehicleConfig::MIXERVECTOR_YAW, -yaw); } m_aircraft->fwStatusLabel->setText("Mixer generated"); diff --git a/ground/openpilotgcs/src/plugins/config/cfg_vehicletypes/configgroundvehiclewidget.cpp b/ground/openpilotgcs/src/plugins/config/cfg_vehicletypes/configgroundvehiclewidget.cpp index 338dcc874..b82d27e33 100644 --- a/ground/openpilotgcs/src/plugins/config/cfg_vehicletypes/configgroundvehiclewidget.cpp +++ b/ground/openpilotgcs/src/plugins/config/cfg_vehicletypes/configgroundvehiclewidget.cpp @@ -116,7 +116,6 @@ void ConfigGroundVehicleWidget::setupUI(QString frameType) m_aircraft->gvThrottleCurve1GroupBox->setEnabled(true); m_aircraft->gvThrottleCurve2GroupBox->setEnabled(true); - // Default Curve2 range -1 -> +1, allow forward/reverse (Car and Tank) m_aircraft->groundVehicleThrottle1->setMixerType(MixerCurve::MIXERCURVE_THROTTLE); m_aircraft->groundVehicleThrottle2->setMixerType(MixerCurve::MIXERCURVE_PITCH); @@ -145,8 +144,8 @@ void ConfigGroundVehicleWidget::setupUI(QString frameType) m_aircraft->differentialSteeringSlider1->setEnabled(true); m_aircraft->differentialSteeringSlider2->setEnabled(true); - m_aircraft->gvThrottleCurve1GroupBox->setTitle(""); - m_aircraft->gvThrottleCurve2GroupBox->setTitle("Throttle curve"); + m_aircraft->gvThrottleCurve1GroupBox->setTitle("Throttle curve1"); + m_aircraft->gvThrottleCurve2GroupBox->setTitle("Throttle curve2 "); m_aircraft->groundVehicleThrottle2->setMixerType(MixerCurve::MIXERCURVE_PITCH); m_aircraft->groundVehicleThrottle1->setMixerType(MixerCurve::MIXERCURVE_THROTTLE); @@ -154,13 +153,11 @@ void ConfigGroundVehicleWidget::setupUI(QString frameType) initMixerCurves(frameType); // If new setup, set sliders to defaults and set curves values - // Allow forward/reverse 0.8 / -0.8 for Throttle, keep some room - // to allow rotate at full throttle and heading stabilization if (frameTypeSaved->getValue().toString() != "GroundVehicleDifferential") { m_aircraft->differentialSteeringSlider1->setValue(100); m_aircraft->differentialSteeringSlider2->setValue(100); - m_aircraft->groundVehicleThrottle1->initLinearCurve(5, 1.0); - m_aircraft->groundVehicleThrottle2->initLinearCurve(5, 0.8, -0.8); + m_aircraft->groundVehicleThrottle1->initLinearCurve(5, 1.0, 0.0); + m_aircraft->groundVehicleThrottle2->initLinearCurve(5, 1.0, 0.0); } } else if (frameType == "GroundVehicleMotorcycle" || frameType == "Motorcycle") { // Motorcycle @@ -179,12 +176,11 @@ void ConfigGroundVehicleWidget::setupUI(QString frameType) m_aircraft->gvSteering2Label->setText("Balancing"); // Curve1 for Motorcyle - m_aircraft->gvThrottleCurve1GroupBox->setTitle("Rear throttle curve"); + m_aircraft->gvThrottleCurve1GroupBox->setTitle("Throttle curve1"); m_aircraft->gvThrottleCurve1GroupBox->setEnabled(true); - m_aircraft->gvThrottleCurve2GroupBox->setTitle(""); - m_aircraft->gvThrottleCurve2GroupBox->setEnabled(false); + m_aircraft->gvThrottleCurve2GroupBox->setTitle("Throttle curve2"); + m_aircraft->gvThrottleCurve2GroupBox->setEnabled(true); - // Curve range 0 -> +1 (no reverse) m_aircraft->groundVehicleThrottle2->setMixerType(MixerCurve::MIXERCURVE_THROTTLE); m_aircraft->groundVehicleThrottle1->setMixerType(MixerCurve::MIXERCURVE_THROTTLE); @@ -192,8 +188,8 @@ void ConfigGroundVehicleWidget::setupUI(QString frameType) // If new setup, set curves values if (frameTypeSaved->getValue().toString() != "GroundVehicleMotorCycle") { - m_aircraft->groundVehicleThrottle2->initLinearCurve(5, 1.0); - m_aircraft->groundVehicleThrottle1->initLinearCurve(5, 1.0); + m_aircraft->groundVehicleThrottle2->initLinearCurve(5, 1.0, 0.0); + m_aircraft->groundVehicleThrottle1->initLinearCurve(5, 1.0, 0.0); } } else { // Car @@ -212,11 +208,10 @@ void ConfigGroundVehicleWidget::setupUI(QString frameType) m_aircraft->gvSteering1Label->setText("Front steering"); m_aircraft->gvSteering2Label->setText("Rear steering"); - // Curve2 for Car - m_aircraft->gvThrottleCurve2GroupBox->setTitle("Throttle curve"); + m_aircraft->gvThrottleCurve2GroupBox->setTitle("Throttle curve2"); m_aircraft->gvThrottleCurve2GroupBox->setEnabled(true); - m_aircraft->gvThrottleCurve1GroupBox->setTitle(""); - m_aircraft->gvThrottleCurve1GroupBox->setEnabled(false); + m_aircraft->gvThrottleCurve1GroupBox->setTitle("Throttle curve1"); + m_aircraft->gvThrottleCurve1GroupBox->setEnabled(true); m_aircraft->groundVehicleThrottle2->setMixerType(MixerCurve::MIXERCURVE_PITCH); m_aircraft->groundVehicleThrottle1->setMixerType(MixerCurve::MIXERCURVE_THROTTLE); @@ -225,11 +220,8 @@ void ConfigGroundVehicleWidget::setupUI(QString frameType) // If new setup, set curves values if (frameTypeSaved->getValue().toString() != "GroundVehicleCar") { - m_aircraft->groundVehicleThrottle1->initLinearCurve(5, 1.0); - // Set curve2 range from -0.926 to 1 (forward / reverse) - // Take in account 4% offset in Throttle input after calibration - // 0.5 / 0.54 = 0.926 - m_aircraft->groundVehicleThrottle2->initLinearCurve(5, 1.0, -0.926); + m_aircraft->groundVehicleThrottle1->initLinearCurve(5, 1.0, 0.0); + m_aircraft->groundVehicleThrottle2->initLinearCurve(5, 1.0, 0.0); } } @@ -325,7 +317,13 @@ void ConfigGroundVehicleWidget::initMixerCurves(QString frameType) m_aircraft->groundVehicleThrottle1->initCurve(&curveValues); } else { // no, init a straight curve - m_aircraft->groundVehicleThrottle1->initLinearCurve(curveValues.count(), 1.0); + if (frameType == "GroundVehicleDifferential") { + m_aircraft->groundVehicleThrottle1->initLinearCurve(curveValues.count(), 0.8, 0.0); + } else if (frameType == "GroundVehicleCar") { + m_aircraft->groundVehicleThrottle1->initLinearCurve(curveValues.count(), 1.0, 0.0); + } else { + m_aircraft->groundVehicleThrottle1->initLinearCurve(curveValues.count(), 1.0, 0.0); + } } // Setup all Throttle2 curves for all types of airframes @@ -336,11 +334,11 @@ void ConfigGroundVehicleWidget::initMixerCurves(QString frameType) } else { // no, init a straight curve if (frameType == "GroundVehicleDifferential") { - m_aircraft->groundVehicleThrottle2->initLinearCurve(curveValues.count(), 0.8, -0.8); + m_aircraft->groundVehicleThrottle2->initLinearCurve(curveValues.count(), 0.8, 0.0); } else if (frameType == "GroundVehicleCar") { - m_aircraft->groundVehicleThrottle2->initLinearCurve(curveValues.count(), 1.0, -1.0); + m_aircraft->groundVehicleThrottle2->initLinearCurve(curveValues.count(), 1.0, 0.0); } else { - m_aircraft->groundVehicleThrottle2->initLinearCurve(curveValues.count(), 1.0); + m_aircraft->groundVehicleThrottle2->initLinearCurve(curveValues.count(), 1.0, 0.0); } } } @@ -513,11 +511,11 @@ bool ConfigGroundVehicleWidget::setupGroundVehicleCar(QString airframeType) channel = m_aircraft->gvMotor1ChannelBox->currentIndex() - 1; setMixerType(mixer, channel, VehicleConfig::MIXERTYPE_REVERSABLEMOTOR); - setMixerVectorValue(mixer, channel, VehicleConfig::MIXERVECTOR_THROTTLECURVE2, 127); + setMixerVectorValue(mixer, channel, VehicleConfig::MIXERVECTOR_THROTTLECURVE1, 127); channel = m_aircraft->gvMotor2ChannelBox->currentIndex() - 1; setMixerType(mixer, channel, VehicleConfig::MIXERTYPE_REVERSABLEMOTOR); - setMixerVectorValue(mixer, channel, VehicleConfig::MIXERVECTOR_THROTTLECURVE2, 127); + setMixerVectorValue(mixer, channel, VehicleConfig::MIXERVECTOR_THROTTLECURVE1, 127); // Output success message m_aircraft->gvStatusLabel->setText("Mixer generated"); diff --git a/ground/openpilotgcs/src/plugins/config/configinputwidget.cpp b/ground/openpilotgcs/src/plugins/config/configinputwidget.cpp index 52d2f598e..83de7fad6 100644 --- a/ground/openpilotgcs/src/plugins/config/configinputwidget.cpp +++ b/ground/openpilotgcs/src/plugins/config/configinputwidget.cpp @@ -549,6 +549,8 @@ void ConfigInputWidget::wzNext() // Force flight mode neutral to middle and Throttle neutral at 4% adjustSpecialNeutrals(); + throttleError = false; + checkThrottleRange(); manualSettingsObj->setData(manualSettingsData); // move to Arming Settings tab @@ -1593,6 +1595,7 @@ void ConfigInputWidget::simpleCalibration(bool enable) ui->saveRCInputToRAM->setEnabled(false); ui->saveRCInputToSD->setEnabled(false); ui->runCalibration->setText(tr("Stop Manual Calibration")); + throttleError = false; QMessageBox msgBox; msgBox.setText(tr("

Arming Settings are now set to 'Always Disarmed' for your safety.

" @@ -1628,11 +1631,6 @@ void ConfigInputWidget::simpleCalibration(bool enable) connect(manualCommandObj, SIGNAL(objectUnpacked(UAVObject *)), this, SLOT(updateCalibration())); } else { - ui->configurationWizard->setEnabled(true); - ui->saveRCInputToRAM->setEnabled(true); - ui->saveRCInputToSD->setEnabled(true); - ui->runCalibration->setText(tr("Start Manual Calibration")); - manualCommandData = manualCommandObj->getData(); manualSettingsData = manualSettingsObj->getData(); @@ -1641,16 +1639,21 @@ void ConfigInputWidget::simpleCalibration(bool enable) for (unsigned int i = 0; i < ManualControlCommand::CHANNEL_NUMELEM; i++) { if ((i == ManualControlSettings::CHANNELNUMBER_FLIGHTMODE) || (i == ManualControlSettings::CHANNELNUMBER_THROTTLE)) { adjustSpecialNeutrals(); + checkThrottleRange(); } else { manualSettingsData.ChannelNeutral[i] = manualCommandData.Channel[i]; } } - manualSettingsObj->setData(manualSettingsData); // Load actuator settings back from beginning of manual calibration actuatorSettingsObj->setData(previousActuatorSettingsData); + ui->configurationWizard->setEnabled(true); + ui->saveRCInputToRAM->setEnabled(true); + ui->saveRCInputToSD->setEnabled(true); + ui->runCalibration->setText(tr("Start Manual Calibration")); + disconnect(manualCommandObj, SIGNAL(objectUnpacked(UAVObject *)), this, SLOT(updateCalibration())); } } @@ -1671,6 +1674,21 @@ void ConfigInputWidget::adjustSpecialNeutrals() manualSettingsData.ChannelMin[ManualControlSettings::CHANNELMIN_THROTTLE]) * 0.04); } +void ConfigInputWidget::checkThrottleRange() +{ + int throttleRange = abs(manualSettingsData.ChannelMax[ManualControlSettings::CHANNELMAX_THROTTLE] - + manualSettingsData.ChannelMin[ManualControlSettings::CHANNELMIN_THROTTLE]); + + if (!throttleError && (throttleRange < 300)) { + throttleError = true; + QMessageBox::warning(this, tr("Warning"), tr("

There is something wrong with Throttle range. Please redo calibration and move ALL sticks, Throttle stick included.

"), QMessageBox::Ok); + + // Set Throttle neutral to max value so Throttle can't be positive + manualSettingsData.ChannelNeutral[ManualControlSettings::CHANNELNEUTRAL_THROTTLE] = + manualSettingsData.ChannelMax[ManualControlSettings::CHANNELMAX_THROTTLE]; + } +} + bool ConfigInputWidget::shouldObjectBeSaved(UAVObject *object) { // ManualControlCommand no need to be saved diff --git a/ground/openpilotgcs/src/plugins/config/configinputwidget.h b/ground/openpilotgcs/src/plugins/config/configinputwidget.h index eac10856c..3c2a138d2 100644 --- a/ground/openpilotgcs/src/plugins/config/configinputwidget.h +++ b/ground/openpilotgcs/src/plugins/config/configinputwidget.h @@ -71,6 +71,7 @@ public: bool shouldObjectBeSaved(UAVObject *object); private: + bool throttleError; bool growing; bool reverse[ManualControlSettings::CHANNELNEUTRAL_NUMELEM]; txMovements currentMovement; @@ -199,6 +200,7 @@ private slots: void invertControls(); void simpleCalibration(bool state); void adjustSpecialNeutrals(); + void checkThrottleRange(); void updateCalibration(); void resetChannelSettings(); void resetActuatorSettings(); diff --git a/ground/openpilotgcs/src/plugins/config/input.ui b/ground/openpilotgcs/src/plugins/config/input.ui index 0ea3f9f39..5eb3285f6 100644 --- a/ground/openpilotgcs/src/plugins/config/input.ui +++ b/ground/openpilotgcs/src/plugins/config/input.ui @@ -117,7 +117,7 @@ 0 0 1228 - 669 + 661 @@ -722,13 +722,13 @@ font:bold; - 106 + 90 0 - 105 + 90 16777215 @@ -1126,13 +1126,13 @@ font:bold; 0 - 230 + 275 16777215 - 230 + 275 @@ -1348,7 +1348,7 @@ font:bold; 16777215 - 150 + 200 @@ -1758,6 +1758,12 @@ font:bold; + + + 16777215 + 29 + + Number of positions your FlightMode switch has. diff --git a/ground/openpilotgcs/src/plugins/config/stabilization.ui b/ground/openpilotgcs/src/plugins/config/stabilization.ui index ed649696e..a2a157089 100644 --- a/ground/openpilotgcs/src/plugins/config/stabilization.ui +++ b/ground/openpilotgcs/src/plugins/config/stabilization.ui @@ -136,8 +136,8 @@ 0 0 - 950 - 780 + 939 + 776 @@ -2900,7 +2900,7 @@ border-radius: 5; 16777215 - 160 + 16777215 @@ -5626,7 +5626,7 @@ Then lower the value by 5 or so. 16777215 - 135 + 16777215 @@ -8244,8 +8244,8 @@ border-radius: 5; 0 0 - 950 - 780 + 952 + 763 @@ -18236,8 +18236,8 @@ border-radius: 5; 0 0 - 950 - 780 + 952 + 763 @@ -24082,8 +24082,8 @@ font:bold; 0 0 - 950 - 780 + 952 + 763 diff --git a/ground/openpilotgcs/src/plugins/setupwizard/outputcalibrationutil.cpp b/ground/openpilotgcs/src/plugins/setupwizard/outputcalibrationutil.cpp index 5369bf845..8cdd16883 100644 --- a/ground/openpilotgcs/src/plugins/setupwizard/outputcalibrationutil.cpp +++ b/ground/openpilotgcs/src/plugins/setupwizard/outputcalibrationutil.cpp @@ -100,7 +100,7 @@ void OutputCalibrationUtil::startChannelOutput(quint16 channel, quint16 safeValu startChannelOutput(channels, safeValue); } -void OutputCalibrationUtil::startChannelOutput(QList channels, quint16 safeValue) +void OutputCalibrationUtil::startChannelOutput(QList &channels, quint16 safeValue) { if (c_prepared) { m_outputChannels = channels; diff --git a/ground/openpilotgcs/src/plugins/setupwizard/outputcalibrationutil.h b/ground/openpilotgcs/src/plugins/setupwizard/outputcalibrationutil.h index 45e800bc6..6f6e722a8 100644 --- a/ground/openpilotgcs/src/plugins/setupwizard/outputcalibrationutil.h +++ b/ground/openpilotgcs/src/plugins/setupwizard/outputcalibrationutil.h @@ -44,7 +44,7 @@ public: public slots: void startChannelOutput(quint16 channel, quint16 safeValue); - void startChannelOutput(QList channels, quint16 safeValue); + void startChannelOutput(QList &channels, quint16 safeValue); void stopChannelOutput(); void setChannelOutputValue(quint16 value); diff --git a/ground/openpilotgcs/src/plugins/setupwizard/pages/outputcalibrationpage.cpp b/ground/openpilotgcs/src/plugins/setupwizard/pages/outputcalibrationpage.cpp index 2d6b7e2f6..7b90c8d0c 100644 --- a/ground/openpilotgcs/src/plugins/setupwizard/pages/outputcalibrationpage.cpp +++ b/ground/openpilotgcs/src/plugins/setupwizard/pages/outputcalibrationpage.cpp @@ -112,6 +112,7 @@ void OutputCalibrationPage::setupVehicle() m_actuatorSettings = getWizard()->getActuatorSettings(); m_wizardIndexes.clear(); m_vehicleElementIds.clear(); + m_vehicleElementTypes.clear(); m_vehicleHighlightElementIndexes.clear(); m_channelIndex.clear(); m_currentWizardIndex = 0; @@ -131,6 +132,9 @@ void OutputCalibrationPage::setupVehicle() // All element ids to load from the svg file and manage. m_vehicleElementIds << "tri" << "tri-frame" << "tri-m1" << "tri-m2" << "tri-m3" << "tri-s1"; + // The type of each element. + m_vehicleElementTypes << FULL << FRAME << MOTOR << MOTOR << MOTOR << SERVO; + // The index of the elementId to highlight ( not dim ) for each step // this is the index in the m_vehicleElementIds - 1. m_vehicleHighlightElementIndexes << 0 << 1 << 2 << 3 << 4; @@ -146,6 +150,7 @@ void OutputCalibrationPage::setupVehicle() loadSVGFile(MULTI_SVG_FILE); m_wizardIndexes << 0 << 1 << 1 << 1 << 1; m_vehicleElementIds << "quad-x" << "quad-x-frame" << "quad-x-m1" << "quad-x-m2" << "quad-x-m3" << "quad-x-m4"; + m_vehicleElementTypes << FULL << FRAME << MOTOR << MOTOR << MOTOR << MOTOR; m_vehicleHighlightElementIndexes << 0 << 1 << 2 << 3 << 4; m_channelIndex << 0 << 0 << 1 << 2 << 3; setupActuatorMinMaxAndNeutral(0, 3, 4); @@ -154,6 +159,7 @@ void OutputCalibrationPage::setupVehicle() loadSVGFile(MULTI_SVG_FILE); m_wizardIndexes << 0 << 1 << 1 << 1 << 1; m_vehicleElementIds << "quad-p" << "quad-p-frame" << "quad-p-m1" << "quad-p-m2" << "quad-p-m3" << "quad-p-m4"; + m_vehicleElementTypes << FULL << FRAME << MOTOR << MOTOR << MOTOR << MOTOR; m_vehicleHighlightElementIndexes << 0 << 1 << 2 << 3 << 4; m_channelIndex << 0 << 0 << 1 << 2 << 3; setupActuatorMinMaxAndNeutral(0, 3, 4); @@ -162,6 +168,7 @@ void OutputCalibrationPage::setupVehicle() loadSVGFile(MULTI_SVG_FILE); m_wizardIndexes << 0 << 1 << 1 << 1 << 1 << 1 << 1; m_vehicleElementIds << "hexa" << "hexa-frame" << "hexa-m1" << "hexa-m2" << "hexa-m3" << "hexa-m4" << "hexa-m5" << "hexa-m6"; + m_vehicleElementTypes << FULL << FRAME << MOTOR << MOTOR << MOTOR << MOTOR << MOTOR << MOTOR; m_vehicleHighlightElementIndexes << 0 << 1 << 2 << 3 << 4 << 5 << 6; m_channelIndex << 0 << 0 << 1 << 2 << 3 << 4 << 5; setupActuatorMinMaxAndNeutral(0, 5, 6); @@ -170,6 +177,7 @@ void OutputCalibrationPage::setupVehicle() loadSVGFile(MULTI_SVG_FILE); m_wizardIndexes << 0 << 1 << 1 << 1 << 1 << 1 << 1; m_vehicleElementIds << "hexa-y6" << "hexa-y6-frame" << "hexa-y6-m2" << "hexa-y6-m1" << "hexa-y6-m4" << "hexa-y6-m3" << "hexa-y6-m6" << "hexa-y6-m5"; + m_vehicleElementTypes << FULL << FRAME << MOTOR << MOTOR << MOTOR << MOTOR << MOTOR << MOTOR; m_vehicleHighlightElementIndexes << 0 << 2 << 1 << 4 << 3 << 6 << 5; m_channelIndex << 0 << 0 << 1 << 2 << 3 << 4 << 5; setupActuatorMinMaxAndNeutral(0, 5, 6); @@ -178,6 +186,7 @@ void OutputCalibrationPage::setupVehicle() loadSVGFile(MULTI_SVG_FILE); m_wizardIndexes << 0 << 1 << 1 << 1 << 1 << 1 << 1; m_vehicleElementIds << "hexa-h" << "hexa-h-frame" << "hexa-h-m1" << "hexa-h-m2" << "hexa-h-m3" << "hexa-h-m4" << "hexa-h-m5" << "hexa-h-m6"; + m_vehicleElementTypes << FULL << FRAME << MOTOR << MOTOR << MOTOR << MOTOR << MOTOR << MOTOR; m_vehicleHighlightElementIndexes << 0 << 1 << 2 << 3 << 4 << 5 << 6; m_channelIndex << 0 << 0 << 1 << 2 << 3 << 4 << 5; setupActuatorMinMaxAndNeutral(0, 5, 6); @@ -186,6 +195,7 @@ void OutputCalibrationPage::setupVehicle() loadSVGFile(MULTI_SVG_FILE); m_wizardIndexes << 0 << 1 << 1 << 1 << 1 << 1 << 1; m_vehicleElementIds << "hexa-x" << "hexa-x-frame" << "hexa-x-m1" << "hexa-x-m2" << "hexa-x-m3" << "hexa-x-m4" << "hexa-x-m5" << "hexa-x-m6"; + m_vehicleElementTypes << FULL << FRAME << MOTOR << MOTOR << MOTOR << MOTOR << MOTOR << MOTOR; m_vehicleHighlightElementIndexes << 0 << 1 << 2 << 3 << 4 << 5 << 6; m_channelIndex << 0 << 0 << 1 << 2 << 3 << 4 << 5; setupActuatorMinMaxAndNeutral(0, 5, 6); @@ -195,6 +205,7 @@ void OutputCalibrationPage::setupVehicle() loadSVGFile(FIXEDWING_SVG_FILE); m_wizardIndexes << 0 << 1 << 2 << 2 << 2 << 2; m_vehicleElementIds << "aileron" << "aileron-frame" << "aileron-motor" << "aileron-ail-left" << "aileron-ail-right" << "aileron-elevator" << "aileron-rudder"; + m_vehicleElementTypes << FULL << FRAME << MOTOR << SERVO << SERVO << SERVO << SERVO; m_vehicleHighlightElementIndexes << 0 << 1 << 2 << 3 << 4 << 5; m_channelIndex << 0 << 2 << 0 << 5 << 1 << 3; @@ -205,7 +216,8 @@ void OutputCalibrationPage::setupVehicle() case SetupWizard::FIXED_WING_AILERON: loadSVGFile(FIXEDWING_SVG_FILE); m_wizardIndexes << 0 << 1 << 2 << 2 << 2; - m_vehicleElementIds << "aileron-single" << "ail2-frame" << "ail2-motor" << "ail2-aileron" << "ail2-elevator" << "ail2-rudder"; + m_vehicleElementIds << "singleaileron" << "singleaileron-frame" << "singleaileron-motor" << "singleaileron-aileron" << "singleaileron-elevator" << "singleaileron-rudder"; + m_vehicleElementTypes << FULL << FRAME << MOTOR << SERVO << SERVO << SERVO; m_vehicleHighlightElementIndexes << 0 << 1 << 2 << 3 << 4; m_channelIndex << 0 << 2 << 0 << 1 << 3; @@ -217,6 +229,7 @@ void OutputCalibrationPage::setupVehicle() loadSVGFile(FIXEDWING_SVG_FILE); m_wizardIndexes << 0 << 1 << 2 << 2; m_vehicleElementIds << "elevon" << "elevon-frame" << "elevon-motor" << "elevon-left" << "elevon-right"; + m_vehicleElementTypes << FULL << FRAME << MOTOR << SERVO << SERVO; m_vehicleHighlightElementIndexes << 0 << 1 << 2 << 3; m_channelIndex << 0 << 2 << 0 << 1; @@ -228,6 +241,7 @@ void OutputCalibrationPage::setupVehicle() loadSVGFile(FIXEDWING_SVG_FILE); m_wizardIndexes << 0 << 1 << 2 << 2 << 2 << 2; m_vehicleElementIds << "vtail" << "vtail-frame" << "vtail-motor" << "vtail-ail-left" << "vtail-ail-right" << "vtail-rudder-left" << "vtail-rudder-right"; + m_vehicleElementTypes << FULL << FRAME << MOTOR << SERVO << SERVO << SERVO << SERVO; m_vehicleHighlightElementIndexes << 0 << 1 << 2 << 3 << 4 << 5; m_channelIndex << 0 << 2 << 0 << 5 << 3 << 1; @@ -241,6 +255,7 @@ void OutputCalibrationPage::setupVehicle() loadSVGFile(GROUND_SVG_FILE); m_wizardIndexes << 0 << 1 << 2; m_vehicleElementIds << "car" << "car-frame" << "car-motor" << "car-steering"; + m_vehicleElementTypes << FULL << FRAME << MOTOR << SERVO; m_vehicleHighlightElementIndexes << 0 << 1 << 2; m_channelIndex << 0 << 1 << 0; @@ -252,6 +267,7 @@ void OutputCalibrationPage::setupVehicle() loadSVGFile(GROUND_SVG_FILE); m_wizardIndexes << 0 << 1 << 1; m_vehicleElementIds << "tank" << "tank-frame" << "tank-left-motor" << "tank-right-motor"; + m_vehicleElementTypes << FULL << FRAME << MOTOR << MOTOR; m_vehicleHighlightElementIndexes << 0 << 1 << 2; m_channelIndex << 0 << 0 << 1; @@ -263,6 +279,7 @@ void OutputCalibrationPage::setupVehicle() loadSVGFile(GROUND_SVG_FILE); m_wizardIndexes << 0 << 1 << 2; m_vehicleElementIds << "motorbike" << "motorbike-frame" << "motorbike-motor" << "motorbike-steering"; + m_vehicleElementTypes << FULL << FRAME << MOTOR << SERVO; m_vehicleHighlightElementIndexes << 0 << 1 << 2; m_channelIndex << 0 << 1 << 0; @@ -281,6 +298,7 @@ void OutputCalibrationPage::setupVehicle() void OutputCalibrationPage::setupVehicleItems() { m_vehicleItems.clear(); + m_arrowsItems.clear(); m_vehicleBoundsItem = new QGraphicsSvgItem(); m_vehicleBoundsItem->setSharedRenderer(m_vehicleRenderer); m_vehicleBoundsItem->setElementId(m_vehicleElementIds[0]); @@ -302,12 +320,53 @@ void OutputCalibrationPage::setupVehicleItems() m_vehicleScene->addItem(item); m_vehicleItems << item; + + bool addArrows = false; + + if ((m_vehicleElementIds[i].contains("left")) || (m_vehicleElementIds[i].contains("right")) + || (m_vehicleElementIds[i].contains("elevator")) || (m_vehicleElementIds[i].contains("rudder")) + || (m_vehicleElementIds[i].contains("steering")) || (m_vehicleElementIds[i] == "singleaileron-aileron")) { + addArrows = true; + } + + if (addArrows) { + QString arrowUp = "-up"; // right if rudder / steering + QString arrowDown = "-down"; // left + + QGraphicsSvgItem *itemUp = new QGraphicsSvgItem(); + + itemUp->setSharedRenderer(m_vehicleRenderer); + QString elementUp = m_vehicleElementIds[i] + arrowUp; + itemUp->setElementId(elementUp); + itemUp->setZValue(i + 10); + itemUp->setOpacity(0); + + QRectF itemBounds = m_vehicleRenderer->boundsOnElement(elementUp); + itemUp->setPos(itemBounds.x() - parentBounds.x(), itemBounds.y() - parentBounds.y()); + m_vehicleScene->addItem(itemUp); + + m_arrowsItems << itemUp; + + QGraphicsSvgItem *itemDown = new QGraphicsSvgItem(); + itemDown->setSharedRenderer(m_vehicleRenderer); + QString elementDown = m_vehicleElementIds[i] + arrowDown; + itemDown->setElementId(elementDown); + itemDown->setZValue(i + 10); + itemDown->setOpacity(0); + + itemBounds = m_vehicleRenderer->boundsOnElement(elementDown); + itemDown->setPos(itemBounds.x() - parentBounds.x(), itemBounds.y() - parentBounds.y()); + m_vehicleScene->addItem(itemDown); + + m_arrowsItems << itemDown; + } } } void OutputCalibrationPage::startWizard() { ui->calibrationStack->setCurrentIndex(m_wizardIndexes[0]); + enableAllMotorsCheckBox(true); setupVehicleHighlightedPart(); } @@ -319,7 +378,29 @@ void OutputCalibrationPage::setupVehicleHighlightedPart() for (int i = 0; i < m_vehicleItems.size(); i++) { QGraphicsSvgItem *item = m_vehicleItems[i]; - item->setOpacity((highlightedIndex == i) ? highlightOpaque : dimOpaque); + if (highlightedIndex == i || (ui->calibrateAllMotors->isChecked() && m_vehicleElementTypes[i + 1] == MOTOR)) { + item->setOpacity(highlightOpaque); + } else { + item->setOpacity(dimOpaque); + } + } +} + +void OutputCalibrationPage::showElementMovement(bool isUp, qreal value) +{ + QString highlightedItemName = m_vehicleItems[m_currentWizardIndex]->elementId(); + + for (int i = 0; i < m_arrowsItems.size(); i++) { + QString upItemName = highlightedItemName + "-up"; + QString downItemName = highlightedItemName + "-down"; + if (m_arrowsItems[i]->elementId() == upItemName) { + QGraphicsSvgItem *itemUp = m_arrowsItems[i]; + itemUp->setOpacity(isUp ? value : 0); + } + if (m_arrowsItems[i]->elementId() == downItemName) { + QGraphicsSvgItem *itemDown = m_arrowsItems[i]; + itemDown->setOpacity(isUp ? 0 : value); + } } } @@ -333,7 +414,9 @@ void OutputCalibrationPage::setWizardPage() qDebug() << "Current page: " << currentPageIndex; ui->calibrationStack->setCurrentIndex(currentPageIndex); - int currentChannel = getCurrentChannel(); + QList currentChannels; + getCurrentChannels(currentChannels); + int currentChannel = currentChannels[0]; qDebug() << "Current channel: " << currentChannel + 1; if (currentChannel >= 0) { if (currentPageIndex == 1) { @@ -366,6 +449,9 @@ void OutputCalibrationPage::setWizardPage() } } setupVehicleHighlightedPart(); + // Hide arrows + showElementMovement(true, 0); + showElementMovement(false, 0); } void OutputCalibrationPage::initializePage() @@ -378,11 +464,21 @@ void OutputCalibrationPage::initializePage() bool OutputCalibrationPage::validatePage() { + if (!isFinished()) { + m_currentWizardIndex++; + if (ui->calibrateAllMotors->isChecked() && + m_currentWizardIndex > 0 && + m_wizardIndexes[m_currentWizardIndex - 1] == 1) { + while (!isFinished() && m_wizardIndexes[m_currentWizardIndex] == 1) { + m_currentWizardIndex++; + } + } + } + if (isFinished()) { getWizard()->setActuatorSettings(m_actuatorSettings); return true; } else { - m_currentWizardIndex++; setWizardPage(); return false; } @@ -408,17 +504,46 @@ void OutputCalibrationPage::resizeEvent(QResizeEvent *event) void OutputCalibrationPage::customBackClicked() { - if (m_currentWizardIndex > 0) { + if (m_currentWizardIndex >= 0) { m_currentWizardIndex--; + if (ui->calibrateAllMotors->isChecked()) { + while (m_currentWizardIndex > 0 && + m_wizardIndexes[m_currentWizardIndex] == 1 && + m_wizardIndexes[m_currentWizardIndex - 1] == 1) { + m_currentWizardIndex--; + } + } + } + + if (m_currentWizardIndex >= 0) { setWizardPage(); } else { getWizard()->back(); } } -quint16 OutputCalibrationPage::getCurrentChannel() +void OutputCalibrationPage::getCurrentChannels(QList &channels) { - return m_channelIndex[m_currentWizardIndex]; + if (ui->calibrateAllMotors->isChecked()) { + for (int i = 1; i < m_channelIndex.size(); i++) { + if (m_vehicleElementTypes[i + 1] == MOTOR) { + channels << m_channelIndex[i]; + } + } + } else { + channels << m_channelIndex[m_currentWizardIndex]; + } +} + +void OutputCalibrationPage::enableAllMotorsCheckBox(bool enable) +{ + if (getWizard()->getVehicleType() == SetupWizard::VEHICLE_MULTI) { + ui->calibrateAllMotors->setVisible(true); + ui->calibrateAllMotors->setEnabled(enable); + } else { + ui->calibrateAllMotors->setChecked(false); + ui->calibrateAllMotors->setVisible(false); + } } void OutputCalibrationPage::enableButtons(bool enable) @@ -427,6 +552,7 @@ void OutputCalibrationPage::enableButtons(bool enable) getWizard()->button(QWizard::CustomButton1)->setEnabled(enable); getWizard()->button(QWizard::CancelButton)->setEnabled(enable); getWizard()->button(QWizard::BackButton)->setEnabled(enable); + enableAllMotorsCheckBox(enable); QApplication::processEvents(); } @@ -434,35 +560,43 @@ void OutputCalibrationPage::on_motorNeutralButton_toggled(bool checked) { ui->motorNeutralButton->setText(checked ? tr("Stop") : tr("Start")); ui->motorNeutralSlider->setEnabled(checked); - quint16 channel = getCurrentChannel(); - quint16 safeValue = m_actuatorSettings[channel].channelMin; - if (m_actuatorSettings[channel].isReversableMotor) { - safeValue = m_actuatorSettings[channel].channelNeutral; + QList currentChannels; + getCurrentChannels(currentChannels); + quint16 currentChannel = currentChannels[0]; + + quint16 safeValue = m_actuatorSettings[currentChannel].channelMin; + + if (m_actuatorSettings[currentChannel].isReversableMotor) { + safeValue = m_actuatorSettings[currentChannel].channelNeutral; } - onStartButtonToggle(ui->motorNeutralButton, channel, m_actuatorSettings[channel].channelNeutral, safeValue, ui->motorNeutralSlider); + onStartButtonToggle(ui->motorNeutralButton, currentChannels, m_actuatorSettings[currentChannel].channelNeutral, safeValue, ui->motorNeutralSlider); } -void OutputCalibrationPage::onStartButtonToggle(QAbstractButton *button, quint16 channel, quint16 value, quint16 safeValue, QSlider *slider) +void OutputCalibrationPage::onStartButtonToggle(QAbstractButton *button, QList &channels, + quint16 value, quint16 safeValue, QSlider *slider) { if (button->isChecked()) { + // Start calibration if (checkAlarms()) { enableButtons(false); enableServoSliders(true); - m_calibrationUtil->startChannelOutput(channel, safeValue); + m_calibrationUtil->startChannelOutput(channels, safeValue); slider->setValue(value); m_calibrationUtil->setChannelOutputValue(value); } else { button->setChecked(false); } } else { - // Servos and ReversableMotors - m_calibrationUtil->startChannelOutput(channel, m_actuatorSettings[channel].channelNeutral); - - // Normal motor + // Stop calibration + quint16 channel = channels[0]; if ((button == ui->motorNeutralButton) && !m_actuatorSettings[channel].isReversableMotor) { - m_calibrationUtil->startChannelOutput(channel, m_actuatorSettings[channel].channelMin); + // Normal motor + m_calibrationUtil->startChannelOutput(channels, m_actuatorSettings[channel].channelMin); + } else { + // Servos and ReversableMotors + m_calibrationUtil->startChannelOutput(channels, m_actuatorSettings[channel].channelNeutral); } m_calibrationUtil->stopChannelOutput(); @@ -479,6 +613,9 @@ void OutputCalibrationPage::enableServoSliders(bool enabled) ui->servoMinAngleSlider->setEnabled(enabled); ui->servoMaxAngleSlider->setEnabled(enabled); ui->reverseCheckbox->setEnabled(!enabled); + // Hide arrows + showElementMovement(true, 0); + showElementMovement(false, 0); } bool OutputCalibrationPage::checkAlarms() @@ -514,11 +651,13 @@ bool OutputCalibrationPage::checkAlarms() void OutputCalibrationPage::debugLogChannelValues() { - quint16 channel = getCurrentChannel(); + QList currentChannels; + getCurrentChannels(currentChannels); + quint16 currentChannel = currentChannels[0]; - qDebug() << "ChannelMin : " << m_actuatorSettings[channel].channelMin; - qDebug() << "ChannelNeutral: " << m_actuatorSettings[channel].channelNeutral; - qDebug() << "ChannelMax : " << m_actuatorSettings[channel].channelMax; + qDebug() << "ChannelMin : " << m_actuatorSettings[currentChannel].channelMin; + qDebug() << "ChannelNeutral: " << m_actuatorSettings[currentChannel].channelNeutral; + qDebug() << "ChannelMax : " << m_actuatorSettings[currentChannel].channelMax; } int OutputCalibrationPage::getHighOutputRate() @@ -538,7 +677,12 @@ void OutputCalibrationPage::on_motorNeutralSlider_valueChanged(int value) if (ui->motorNeutralButton->isChecked()) { quint16 value = ui->motorNeutralSlider->value(); m_calibrationUtil->setChannelOutputValue(value); - m_actuatorSettings[getCurrentChannel()].channelNeutral = value; + + QList currentChannels; + getCurrentChannels(currentChannels); + foreach(quint16 channel, currentChannels) { + m_actuatorSettings[channel].channelNeutral = value; + } debugLogChannelValues(); } } @@ -546,36 +690,65 @@ void OutputCalibrationPage::on_motorNeutralSlider_valueChanged(int value) void OutputCalibrationPage::on_servoButton_toggled(bool checked) { ui->servoButton->setText(checked ? tr("Stop") : tr("Start")); - quint16 channel = getCurrentChannel(); - quint16 safeValue = m_actuatorSettings[channel].channelNeutral; - onStartButtonToggle(ui->servoButton, channel, safeValue, safeValue, ui->servoCenterAngleSlider); + + QList currentChannels; + getCurrentChannels(currentChannels); + quint16 currentChannel = currentChannels[0]; + + quint16 safeValue = m_actuatorSettings[currentChannel].channelNeutral; + onStartButtonToggle(ui->servoButton, currentChannels, safeValue, safeValue, ui->servoCenterAngleSlider); } void OutputCalibrationPage::on_servoCenterAngleSlider_valueChanged(int position) { Q_UNUSED(position); - quint16 value = ui->servoCenterAngleSlider->value(); + quint16 value = ui->servoCenterAngleSlider->value(); m_calibrationUtil->setChannelOutputValue(value); - quint16 channel = getCurrentChannel(); - m_actuatorSettings[channel].channelNeutral = value; + + QList currentChannels; + getCurrentChannels(currentChannels); + quint16 currentChannel = currentChannels[0]; + + m_actuatorSettings[currentChannel].channelNeutral = value; ui->servoPWMValue->setText(tr("Output value : %1 µs").arg(value)); // Adjust min and max if (ui->reverseCheckbox->isChecked()) { - if (value >= m_actuatorSettings[channel].channelMin) { + if (value >= m_actuatorSettings[currentChannel].channelMin) { ui->servoMinAngleSlider->setValue(value); } - if (value <= m_actuatorSettings[channel].channelMax) { + if (value <= m_actuatorSettings[currentChannel].channelMax) { ui->servoMaxAngleSlider->setValue(value); } } else { - if (value <= m_actuatorSettings[channel].channelMin) { + if (value <= m_actuatorSettings[currentChannel].channelMin) { ui->servoMinAngleSlider->setValue(value); } - if (value >= m_actuatorSettings[channel].channelMax) { + if (value >= m_actuatorSettings[currentChannel].channelMax) { ui->servoMaxAngleSlider->setValue(value); } } + + quint16 minValue = (ui->reverseCheckbox->isChecked()) ? ui->servoMaxAngleSlider->value() : ui->servoMinAngleSlider->value(); + quint16 maxValue = (ui->reverseCheckbox->isChecked()) ? ui->servoMinAngleSlider->value() : ui->servoMaxAngleSlider->value(); + quint16 range = maxValue - minValue; + // Reset arows + showElementMovement(true, 0); + showElementMovement(false, 0); + + // 30% "Dead band" : no arrow display + quint16 limitLow = minValue + (range * 0.35); + quint16 limitHigh = maxValue - (range * 0.35); + quint16 middle = minValue + (range / 2); + qreal arrowOpacity = 0; + if (value < limitLow) { + arrowOpacity = (qreal)(middle - value) / (qreal)(middle - minValue); + showElementMovement(ui->reverseCheckbox->isChecked(), arrowOpacity); + } else if (value > limitHigh) { + arrowOpacity = (qreal)(value - middle) / (qreal)(maxValue - middle); + showElementMovement(!ui->reverseCheckbox->isChecked(), arrowOpacity); + } + debugLogChannelValues(); } @@ -584,21 +757,26 @@ void OutputCalibrationPage::on_servoMinAngleSlider_valueChanged(int position) Q_UNUSED(position); quint16 value = ui->servoMinAngleSlider->value(); m_calibrationUtil->setChannelOutputValue(value); - m_actuatorSettings[getCurrentChannel()].channelMin = value; + + QList currentChannels; + getCurrentChannels(currentChannels); + quint16 currentChannel = currentChannels[0]; + m_actuatorSettings[currentChannel].channelMin = value; + ui->servoPWMValue->setText(tr("Output value : %1 µs (Min)").arg(value)); // Adjust neutral and max if (ui->reverseCheckbox->isChecked()) { - if (value <= m_actuatorSettings[getCurrentChannel()].channelNeutral) { + if (value <= m_actuatorSettings[currentChannel].channelNeutral) { ui->servoCenterAngleSlider->setValue(value); } - if (value <= m_actuatorSettings[getCurrentChannel()].channelMax) { + if (value <= m_actuatorSettings[currentChannel].channelMax) { ui->servoMaxAngleSlider->setValue(value); } } else { - if (value >= m_actuatorSettings[getCurrentChannel()].channelNeutral) { + if (value >= m_actuatorSettings[currentChannel].channelNeutral) { ui->servoCenterAngleSlider->setValue(value); } - if (value >= m_actuatorSettings[getCurrentChannel()].channelMax) { + if (value >= m_actuatorSettings[currentChannel].channelMax) { ui->servoMaxAngleSlider->setValue(value); } } @@ -610,21 +788,26 @@ void OutputCalibrationPage::on_servoMaxAngleSlider_valueChanged(int position) Q_UNUSED(position); quint16 value = ui->servoMaxAngleSlider->value(); m_calibrationUtil->setChannelOutputValue(value); - m_actuatorSettings[getCurrentChannel()].channelMax = value; + + QList currentChannels; + getCurrentChannels(currentChannels); + quint16 currentChannel = currentChannels[0]; + m_actuatorSettings[currentChannel].channelMax = value; + ui->servoPWMValue->setText(tr("Output value : %1 µs (Max)").arg(value)); // Adjust neutral and min if (ui->reverseCheckbox->isChecked()) { - if (value >= m_actuatorSettings[getCurrentChannel()].channelNeutral) { + if (value >= m_actuatorSettings[currentChannel].channelNeutral) { ui->servoCenterAngleSlider->setValue(value); } - if (value >= m_actuatorSettings[getCurrentChannel()].channelMin) { + if (value >= m_actuatorSettings[currentChannel].channelMin) { ui->servoMinAngleSlider->setValue(value); } } else { - if (value <= m_actuatorSettings[getCurrentChannel()].channelNeutral) { + if (value <= m_actuatorSettings[currentChannel].channelNeutral) { ui->servoCenterAngleSlider->setValue(value); } - if (value <= m_actuatorSettings[getCurrentChannel()].channelMin) { + if (value <= m_actuatorSettings[currentChannel].channelMin) { ui->servoMinAngleSlider->setValue(value); } } @@ -633,14 +816,18 @@ void OutputCalibrationPage::on_servoMaxAngleSlider_valueChanged(int position) void OutputCalibrationPage::on_reverseCheckbox_toggled(bool checked) { - if (checked && m_actuatorSettings[getCurrentChannel()].channelMax > m_actuatorSettings[getCurrentChannel()].channelMin) { - quint16 oldMax = m_actuatorSettings[getCurrentChannel()].channelMax; - m_actuatorSettings[getCurrentChannel()].channelMax = m_actuatorSettings[getCurrentChannel()].channelMin; - m_actuatorSettings[getCurrentChannel()].channelMin = oldMax; - } else if (!checked && m_actuatorSettings[getCurrentChannel()].channelMax < m_actuatorSettings[getCurrentChannel()].channelMin) { - quint16 oldMax = m_actuatorSettings[getCurrentChannel()].channelMax; - m_actuatorSettings[getCurrentChannel()].channelMax = m_actuatorSettings[getCurrentChannel()].channelMin; - m_actuatorSettings[getCurrentChannel()].channelMin = oldMax; + QList currentChannels; + getCurrentChannels(currentChannels); + quint16 currentChannel = currentChannels[0]; + + if (checked && m_actuatorSettings[currentChannel].channelMax > m_actuatorSettings[currentChannel].channelMin) { + quint16 oldMax = m_actuatorSettings[currentChannel].channelMax; + m_actuatorSettings[currentChannel].channelMax = m_actuatorSettings[currentChannel].channelMin; + m_actuatorSettings[currentChannel].channelMin = oldMax; + } else if (!checked && m_actuatorSettings[currentChannel].channelMax < m_actuatorSettings[currentChannel].channelMin) { + quint16 oldMax = m_actuatorSettings[currentChannel].channelMax; + m_actuatorSettings[currentChannel].channelMax = m_actuatorSettings[currentChannel].channelMin; + m_actuatorSettings[currentChannel].channelMin = oldMax; } ui->servoCenterAngleSlider->setInvertedAppearance(checked); ui->servoCenterAngleSlider->setInvertedControls(checked); @@ -650,16 +837,22 @@ void OutputCalibrationPage::on_reverseCheckbox_toggled(bool checked) ui->servoMaxAngleSlider->setInvertedControls(checked); if (ui->reverseCheckbox->isChecked()) { - ui->servoMaxAngleSlider->setValue(m_actuatorSettings[getCurrentChannel()].channelMax); - ui->servoCenterAngleSlider->setValue(m_actuatorSettings[getCurrentChannel()].channelNeutral); - ui->servoMinAngleSlider->setValue(m_actuatorSettings[getCurrentChannel()].channelMin); + ui->servoMaxAngleSlider->setValue(m_actuatorSettings[currentChannel].channelMax); + ui->servoCenterAngleSlider->setValue(m_actuatorSettings[currentChannel].channelNeutral); + ui->servoMinAngleSlider->setValue(m_actuatorSettings[currentChannel].channelMin); } else { - ui->servoMinAngleSlider->setValue(m_actuatorSettings[getCurrentChannel()].channelMin); - ui->servoCenterAngleSlider->setValue(m_actuatorSettings[getCurrentChannel()].channelNeutral); - ui->servoMaxAngleSlider->setValue(m_actuatorSettings[getCurrentChannel()].channelMax); + ui->servoMinAngleSlider->setValue(m_actuatorSettings[currentChannel].channelMin); + ui->servoCenterAngleSlider->setValue(m_actuatorSettings[currentChannel].channelNeutral); + ui->servoMaxAngleSlider->setValue(m_actuatorSettings[currentChannel].channelMax); } } +void OutputCalibrationPage::on_calibrateAllMotors_toggled(bool checked) +{ + Q_UNUSED(checked); + setupVehicleHighlightedPart(); +} + void OutputCalibrationPage::resetOutputCalibrationUtil() { if (m_calibrationUtil) { diff --git a/ground/openpilotgcs/src/plugins/setupwizard/pages/outputcalibrationpage.h b/ground/openpilotgcs/src/plugins/setupwizard/pages/outputcalibrationpage.h index 3324caccd..e48748177 100644 --- a/ground/openpilotgcs/src/plugins/setupwizard/pages/outputcalibrationpage.h +++ b/ground/openpilotgcs/src/plugins/setupwizard/pages/outputcalibrationpage.h @@ -49,7 +49,7 @@ public: bool isFinished() { - return m_currentWizardIndex >= m_wizardIndexes.size() - 1; + return m_currentWizardIndex >= m_wizardIndexes.size(); } void loadSVGFile(QString file); @@ -70,22 +70,30 @@ private slots: void on_servoMinAngleSlider_valueChanged(int position); void on_servoMaxAngleSlider_valueChanged(int position); void on_reverseCheckbox_toggled(bool checked); + void on_calibrateAllMotors_toggled(bool checked); private: - static const int LOW_OUTPUT_RATE_MILLISECONDS = 1000; - static const int NEUTRAL_OUTPUT_RATE_MILLISECONDS = 1500; + enum ElementType { FULL, FRAME, MOTOR, SERVO }; + static const int LOW_OUTPUT_RATE_MILLISECONDS = 1000; + static const int NEUTRAL_OUTPUT_RATE_MILLISECONDS = 1500; static const int HIGH_OUTPUT_RATE_MILLISECONDS_PWM = 1900; static const int HIGH_OUTPUT_RATE_MILLISECONDS_ONESHOT125 = 2000; + void setupVehicle(); void startWizard(); void setupVehicleItems(); void setupVehicleHighlightedPart(); + void showElementMovement(bool isUp, qreal value); void setWizardPage(); void enableButtons(bool enable); void enableServoSliders(bool enabled); - void onStartButtonToggle(QAbstractButton *button, quint16 channel, quint16 value, quint16 safeValue, QSlider *slider); + void onStartButtonToggle(QAbstractButton *button, QList &channels, + quint16 value, quint16 safeValue, QSlider *slider); bool checkAlarms(); void debugLogChannelValues(); + + void getCurrentChannels(QList &channels); + void enableAllMotorsCheckBox(bool enable); int getHighOutputRate(); quint16 getCurrentChannel(); @@ -97,7 +105,9 @@ private: qint16 m_currentWizardIndex; QList m_vehicleElementIds; + QList m_vehicleElementTypes; QList m_vehicleItems; + QList m_arrowsItems; QList m_vehicleHighlightElementIndexes; QList m_channelIndex; QList m_wizardIndexes; diff --git a/ground/openpilotgcs/src/plugins/setupwizard/pages/outputcalibrationpage.ui b/ground/openpilotgcs/src/plugins/setupwizard/pages/outputcalibrationpage.ui index 202b766a2..f8bb50966 100644 --- a/ground/openpilotgcs/src/plugins/setupwizard/pages/outputcalibrationpage.ui +++ b/ground/openpilotgcs/src/plugins/setupwizard/pages/outputcalibrationpage.ui @@ -53,7 +53,7 @@ - 2 + 1 @@ -123,6 +123,26 @@ p, li { white-space: pre-wrap; } + + + + Calibrate all motor outputs at the same time + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + diff --git a/ground/openpilotgcs/src/plugins/setupwizard/resources/fixedwing-shapes-wizard.svg b/ground/openpilotgcs/src/plugins/setupwizard/resources/fixedwing-shapes-wizard.svg index c75382518..eada74c14 100644 --- a/ground/openpilotgcs/src/plugins/setupwizard/resources/fixedwing-shapes-wizard.svg +++ b/ground/openpilotgcs/src/plugins/setupwizard/resources/fixedwing-shapes-wizard.svg @@ -23,7 +23,7 @@ sodipodi:docname="fixedwing-shapes-wizard.svg">image/svg+xml6 +6 -4 - - - - -4 -4 + x="239.17444" + y="352.68146">4 \ No newline at end of file + style="fill:#414042" /> + + + +4 + \ No newline at end of file diff --git a/ground/openpilotgcs/src/plugins/setupwizard/resources/ground-shapes-wizard.svg b/ground/openpilotgcs/src/plugins/setupwizard/resources/ground-shapes-wizard.svg index 0c8b13289..907718a25 100644 --- a/ground/openpilotgcs/src/plugins/setupwizard/resources/ground-shapes-wizard.svg +++ b/ground/openpilotgcs/src/plugins/setupwizard/resources/ground-shapes-wizard.svg @@ -26,7 +26,7 @@ inkscape:export-ydpi="70.479134">image/svg+xml(currentPage())->customBackClicked(); } else { back(); + if (currentId() == PAGE_OUTPUT_CALIBRATION) { + static_cast(currentPage())->customBackClicked(); + } } } diff --git a/ground/openpilotgcs/src/plugins/setupwizard/vehicleconfigurationhelper.cpp b/ground/openpilotgcs/src/plugins/setupwizard/vehicleconfigurationhelper.cpp index 1491b4af7..f87689b32 100644 --- a/ground/openpilotgcs/src/plugins/setupwizard/vehicleconfigurationhelper.cpp +++ b/ground/openpilotgcs/src/plugins/setupwizard/vehicleconfigurationhelper.cpp @@ -779,17 +779,15 @@ void VehicleConfigurationHelper::applyMixerConfiguration(mixerChannelSettings ch mSettings->setMixerValueRoll(100); mSettings->setMixerValuePitch(100); mSettings->setMixerValueYaw(100); - // Set curve2 range from -0.926 to 1 : take in account 4% offset in Throttle input - // 0.5 / 0.54 = 0.926 maxThrottle = 1; - minThrottle = -0.926; + minThrottle = 0; break; case VehicleConfigurationSource::GROUNDVEHICLE_DIFFERENTIAL: mSettings->setMixerValueRoll(100); mSettings->setMixerValuePitch(100); mSettings->setMixerValueYaw(100); maxThrottle = 0.8; - minThrottle = -0.8; + minThrottle = 0; break; default: break; @@ -1927,7 +1925,7 @@ void VehicleConfigurationHelper::setupDualAileron() channels[3].throttle2 = 0; channels[3].roll = 0; channels[3].pitch = 0; - channels[3].yaw = 100; + channels[3].yaw = -100; guiSettings.fixedwing.FixedWingThrottle = 3; guiSettings.fixedwing.FixedWingRoll1 = 1; @@ -1979,7 +1977,7 @@ void VehicleConfigurationHelper::setupAileron() channels[3].throttle2 = 0; channels[3].roll = 0; channels[3].pitch = 0; - channels[3].yaw = 100; + channels[3].yaw = -100; guiSettings.fixedwing.FixedWingThrottle = 3; guiSettings.fixedwing.FixedWingRoll1 = 1; @@ -2030,7 +2028,7 @@ void VehicleConfigurationHelper::setupVtail() channels[1].throttle2 = 0; channels[1].roll = 0; channels[1].pitch = 100; - channels[1].yaw = 100; + channels[1].yaw = -100; // Left Vtail Servo (Chan 4) channels[3].type = MIXER_TYPE_SERVO; @@ -2038,7 +2036,7 @@ void VehicleConfigurationHelper::setupVtail() channels[3].throttle2 = 0; channels[3].roll = 0; channels[3].pitch = -100; - channels[3].yaw = 100; + channels[3].yaw = -100; guiSettings.fixedwing.FixedWingThrottle = 3; guiSettings.fixedwing.FixedWingRoll1 = 1; @@ -2076,8 +2074,8 @@ void VehicleConfigurationHelper::setupCar() // Motor (Chan 2) channels[1].type = MIXER_TYPE_REVERSABLEMOTOR; - channels[1].throttle1 = 0; - channels[1].throttle2 = 100; + channels[1].throttle1 = 100; + channels[1].throttle2 = 0; channels[1].roll = 0; channels[1].pitch = 0; channels[1].yaw = 0; @@ -2101,16 +2099,16 @@ void VehicleConfigurationHelper::setupTank() // Left Motor (Chan 1) channels[0].type = MIXER_TYPE_REVERSABLEMOTOR; - channels[0].throttle1 = 0; - channels[0].throttle2 = 100; + channels[0].throttle1 = 100; + channels[0].throttle2 = 0; channels[0].roll = 0; channels[0].pitch = 0; channels[0].yaw = 100; // Right Motor (Chan 2) channels[1].type = MIXER_TYPE_REVERSABLEMOTOR; - channels[1].throttle1 = 0; - channels[1].throttle2 = 100; + channels[1].throttle1 = 100; + channels[1].throttle2 = 0; channels[1].roll = 0; channels[1].pitch = 0; channels[1].yaw = -100; @@ -2140,7 +2138,7 @@ void VehicleConfigurationHelper::setupMotorcycle() channels[0].pitch = 0; channels[0].yaw = 100; - // Motor (Chan 2) : Curve1, no reverse + // Motor (Chan 2) channels[1].type = MIXER_TYPE_MOTOR; channels[1].throttle1 = 100; channels[1].throttle2 = 0; diff --git a/ground/openpilotgcs/src/plugins/systemhealth/html/SystemConfiguration-BadThrottleOrCollectiveInputRange.html b/ground/openpilotgcs/src/plugins/systemhealth/html/SystemConfiguration-BadThrottleOrCollectiveInputRange.html new file mode 100644 index 000000000..62bb0c4d8 --- /dev/null +++ b/ground/openpilotgcs/src/plugins/systemhealth/html/SystemConfiguration-BadThrottleOrCollectiveInputRange.html @@ -0,0 +1,17 @@ + + + + + + + +

System Configuration : BadThrottleOrCollectiveInputRange

+

+ There is a problem with throttle/collective channel configuration : +

    +
  • Redo your input calibration.
    • +
  • The range for the channel between min and max must be more than 300µs.
    • +
+

+ + diff --git a/ground/openpilotgcs/src/plugins/systemhealth/html/fr/SystemConfiguration-BadThrottleOrCollectiveInputRange.html b/ground/openpilotgcs/src/plugins/systemhealth/html/fr/SystemConfiguration-BadThrottleOrCollectiveInputRange.html new file mode 100644 index 000000000..4bd3738ed --- /dev/null +++ b/ground/openpilotgcs/src/plugins/systemhealth/html/fr/SystemConfiguration-BadThrottleOrCollectiveInputRange.html @@ -0,0 +1,17 @@ + + + + + + + +

Configuration Système : BadThrottleOrCollectiveInputRange

+

+ Il y a un problème avec la configuration du canal throttle/collective : +

    +
  • Relancez la calibration des entrées.
    • +
  • La différence entre la valeur mini et maxi doit faire au moins 300µs.
    • +
+

+ + diff --git a/ground/openpilotgcs/src/plugins/systemhealth/systemhealth.qrc b/ground/openpilotgcs/src/plugins/systemhealth/systemhealth.qrc index cd71d368d..64f21cdd2 100644 --- a/ground/openpilotgcs/src/plugins/systemhealth/systemhealth.qrc +++ b/ground/openpilotgcs/src/plugins/systemhealth/systemhealth.qrc @@ -33,6 +33,7 @@ html/Stabilization-Critical.html html/SystemConfiguration-UnsupportedConfig_OneShot.html html/SystemConfiguration-FlightMode.html + html/SystemConfiguration-BadThrottleOrCollectiveInputRange.html html/BootFault-RebootRequired.html @@ -69,6 +70,7 @@ html/fr/Stabilization-Critical.html html/fr/SystemConfiguration-UnsupportedConfig_OneShot.html html/fr/SystemConfiguration-FlightMode.html + html/fr/SystemConfiguration-BadThrottleOrCollectiveInputRange.html html/fr/BootFault-RebootRequired.html diff --git a/hardware/Production/OpenPilot Atom/Assembly.OutJob b/hardware/Production/OpenPilot Atom/Assembly.OutJob new file mode 100644 index 000000000..11b7f13c3 --- /dev/null +++ b/hardware/Production/OpenPilot Atom/Assembly.OutJob @@ -0,0 +1,176 @@ +[OutputJobFile] +Version=1.0 + +[OutputGroup1] +Name=Assembly.OutJob +Description= +TargetOutputMedium=PDF +VariantName=[No Variations] +VariantScope=1 +CurrentConfigurationName= +TargetPrinter=Brother HL-2170W +PrinterOptions=Record=PrinterOptions|Copies=1|Duplex=1|TrueTypeOptions=3|Collate=1|PrintWhat=1 +OutputMedium1=Print Job +OutputMedium1_Type=Printer +OutputMedium1_Printer= +OutputMedium1_PrinterOptions=Record=PrinterOptions|Copies=1|Duplex=1|TrueTypeOptions=3|Collate=1|PrintWhat=1 +OutputMedium2=PDF +OutputMedium2_Type=Publish +OutputMedium3=Folder Structure +OutputMedium3_Type=GeneratedFiles +OutputMedium4=Video +OutputMedium4_Type=Multimedia +OutputType1=Assembly +OutputName1=Assembly Drawings +OutputCategory1=Assembly +OutputDocumentPath1= +OutputVariantName1= +OutputEnabled1=1 +OutputEnabled1_OutputMedium1=0 +OutputEnabled1_OutputMedium2=1 +OutputEnabled1_OutputMedium3=0 +OutputEnabled1_OutputMedium4=0 +OutputDefault1=0 +PageOptions1=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=9.24|XCorrection=1.00|YCorrection=1.00|PrintKind=0|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PaperKind=A4|PrintScaleMode=1 +Configuration1_Name1=OutputConfigurationParameter1 +Configuration1_Item1=DesignatorDisplayMode=Physical|PrintArea=DesignExtent|PrintAreaLowerLeftCornerX=0|PrintAreaLowerLeftCornerY=0|PrintAreaUpperRightCornerX=0|PrintAreaUpperRightCornerY=0|Record=PcbPrintView +Configuration1_Name2=OutputConfigurationParameter2 +Configuration1_Item2=IncludeBottomLayerComponents=False|IncludeMultiLayerComponents=True|IncludeTopLayerComponents=True|Index=0|Mirror=False|Name=Top Assembly Drawing|PadNumberFontSize=14|Record=PcbPrintOut|ShowHoles=False|ShowPadNets=False|ShowPadNumbers=False|SubstituteFonts=True +Configuration1_Name3=OutputConfigurationParameter3 +Configuration1_Item3=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical6|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration1_Name4=OutputConfigurationParameter4 +Configuration1_Item4=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Hidden|FFill=Hidden|FPad=Hidden|FRegion=Hidden|FText=Hidden|FTrack=Hidden|FVia=Hidden|Layer=TopLayer|Polygon=Hidden|PrintOutIndex=0|Record=PcbPrintLayer +Configuration1_Name5=OutputConfigurationParameter5 +Configuration1_Item5=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=TopOverlay|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration1_Name6=OutputConfigurationParameter6 +Configuration1_Item6=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Hidden|Layer=MultiLayer|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration1_Name7=OutputConfigurationParameter7 +Configuration1_Item7=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical1|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration1_Name8=OutputConfigurationParameter8 +Configuration1_Item8=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical5|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration1_Name9=OutputConfigurationParameter9 +Configuration1_Item9=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical13|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration1_Name10=OutputConfigurationParameter10 +Configuration1_Item10=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical14|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration1_Name11=OutputConfigurationParameter11 +Configuration1_Item11=IncludeBottomLayerComponents=True|IncludeMultiLayerComponents=True|IncludeTopLayerComponents=False|Index=1|Mirror=True|Name=Bottom Assembly Drawing|PadNumberFontSize=14|Record=PcbPrintOut|ShowHoles=False|ShowPadNets=False|ShowPadNumbers=False|SubstituteFonts=True +Configuration1_Name12=OutputConfigurationParameter12 +Configuration1_Item12=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical7|Polygon=Full|PrintOutIndex=1|Record=PcbPrintLayer +Configuration1_Name13=OutputConfigurationParameter13 +Configuration1_Item13=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Hidden|FFill=Hidden|FPad=Hidden|FRegion=Hidden|FText=Hidden|FTrack=Hidden|FVia=Hidden|Layer=BottomLayer|Polygon=Hidden|PrintOutIndex=1|Record=PcbPrintLayer +Configuration1_Name14=OutputConfigurationParameter14 +Configuration1_Item14=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=BottomOverlay|Polygon=Full|PrintOutIndex=1|Record=PcbPrintLayer +Configuration1_Name15=OutputConfigurationParameter15 +Configuration1_Item15=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Hidden|Layer=MultiLayer|Polygon=Full|PrintOutIndex=1|Record=PcbPrintLayer +Configuration1_Name16=OutputConfigurationParameter16 +Configuration1_Item16=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical1|Polygon=Full|PrintOutIndex=1|Record=PcbPrintLayer +Configuration1_Name17=OutputConfigurationParameter17 +Configuration1_Item17=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical5|Polygon=Full|PrintOutIndex=1|Record=PcbPrintLayer +Configuration1_Name18=OutputConfigurationParameter18 +Configuration1_Item18=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical13|Polygon=Full|PrintOutIndex=1|Record=PcbPrintLayer +Configuration1_Name19=OutputConfigurationParameter19 +Configuration1_Item19=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical14|Polygon=Full|PrintOutIndex=1|Record=PcbPrintLayer +Configuration1_Name20=OutputConfigurationParameter20 +Configuration1_Item20=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical16|Polygon=Full|PrintOutIndex=1|Record=PcbPrintLayer +OutputType2=PCB 3D Print +OutputName2=PCB 3D Top +OutputCategory2=Documentation +OutputDocumentPath2= +OutputVariantName2= +OutputEnabled2=1 +OutputEnabled2_OutputMedium1=0 +OutputEnabled2_OutputMedium2=2 +OutputEnabled2_OutputMedium3=0 +OutputEnabled2_OutputMedium4=0 +OutputDefault2=0 +PageOptions2=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=9.57|XCorrection=1.00|YCorrection=1.00|PrintKind=0|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PaperKind=A4|PrintScaleMode=1 +Configuration2_Name1=OutputConfigurationParameter1 +Configuration2_Item1=Record=Pcb3DPrintView|ResX=300|ResY=300|ViewX=14173229|ViewY=14173230|LookAtX=31403926|LookAtY=26533924|LookAtZ=-1000|QuatX=0|QuatY=0|QuatZ=0|QuatW=1|Zoom=4.90361053902321E-5|UnitsPercent=True|UnitsDPI=True|LockResAspect=True|ViewConfigType=.config_3d|CustomCamera=False|ViewFromTop=True|ViewConfig=RECORD\3Board\2CFGALL.CONFIGURATIONKIND\33\2CFGALL.CONFIGURATIONDESC\3Altium%203D%20NB%20Black%20Configuration\2CFG3D.POSITIVETOPSOLDERMASK\3TRUE\2CFG3D.POSITIVEBOTTOMSOLDERMASK\3TRUE\2CFG3D.SHOWCOMPONENTBODIES\3SYSTEM\2CFG3D.SHOWCOMPONENTSTEPMODELS\3SYSTEM\2CFG3D.COMPONENTMODELPREFERENCE\30\2CFG3D.SHOWCOMPONENTSNAPMARKERS\3TRUE\2CFG3D.SHOWCOMPONENTAXES\3TRUE\2CFG3D.SHOWBOARDCORE\3TRUE\2CFG3D.SHOWBOARDPREPREG\3TRUE\2CFG3D.SHOWTOPSILKSCREEN\3TRUE\2CFG3D.SHOWBOTSILKSCREEN\3TRUE\2CFG3D.SHOWORIGINMARKER\3TRUE\2CFG3D.EYEDIST\32000\2CFG3D.SHOWCUTOUTS\3TRUE\2CFG3D.SHOWROUTETOOLPATH\3TRUE\2CFG3D.SHOWROOMS3D\3FALSE\2CFG3D.USESYSCOLORSFOR3D\3FALSE\2CFG3D.WORKSPACECOLOR\311840160\2CFG3D.BOARDCORECOLOR\313491161\2CFG3D.BOARDPREPREGCOLOR\30\2CFG3D.TOPSOLDERMASKCOLOR\30\2CFG3D.BOTSOLDERMASKCOLOR\30\2CFG3D.COPPERCOLOR\33323360\2CFG3D.TOPSILKSCREENCOLOR\315461355\2CFG3D.BOTSILKSCREENCOLOR\315461355\2CFG3D.WORKSPACELUMINANCEVARIATION\330\2CFG3D.WORKSPACECOLOROPACITY\31.000000\2CFG3D.BOARDCORECOLOROPACITY\30.820000\2CFG3D.BOARDPREPREGCOLOROPACITY\30.500000\2CFG3D.TOPSOLDERMASKCOLOROPACITY\30.900000\2CFG3D.BOTSOLDERMASKCOLOROPACITY\30.900000\2CFG3D.COPPERCOLOROPACITY\31.000000\2CFG3D.TOPSILKSCREENCOLOROPACITY\31.000000\2CFG3D.BOTSILKSCREENCOLOROPACITY\31.000000\2CFG3D.BOARDTHICKNESSSCALING\31.000000\2CFG3D.SHOWMECHANICALLAYERS\3FALSE\2CFG3D.MECHANICALLAYERSOPACITY\31.000000 +OutputType3=PCB 3D Print +OutputName3=PCB 3D Bottom +OutputCategory3=Documentation +OutputDocumentPath3= +OutputVariantName3= +OutputEnabled3=1 +OutputEnabled3_OutputMedium1=0 +OutputEnabled3_OutputMedium2=3 +OutputEnabled3_OutputMedium3=0 +OutputEnabled3_OutputMedium4=0 +OutputDefault3=0 +PageOptions3=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=9.57|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PaperKind=A4|PrintScaleMode=1 +Configuration3_Name1=OutputConfigurationParameter1 +Configuration3_Item1=Record=Pcb3DPrintView|ResX=300|ResY=300|ViewX=14173229|ViewY=14173230|LookAtX=31403926|LookAtY=26533924|LookAtZ=-1000|QuatX=0|QuatY=0|QuatZ=0|QuatW=1|Zoom=4.90361053902321E-5|UnitsPercent=True|UnitsDPI=True|LockResAspect=True|ViewConfigType=.config_3d|CustomCamera=False|ViewFromTop=False|ViewConfig=RECORD\3Board\2CFGALL.CONFIGURATIONKIND\33\2CFGALL.CONFIGURATIONDESC\3Altium%203D%20NB%20Black%20Configuration\2CFG3D.POSITIVETOPSOLDERMASK\3TRUE\2CFG3D.POSITIVEBOTTOMSOLDERMASK\3TRUE\2CFG3D.SHOWCOMPONENTBODIES\3SYSTEM\2CFG3D.SHOWCOMPONENTSTEPMODELS\3SYSTEM\2CFG3D.COMPONENTMODELPREFERENCE\30\2CFG3D.SHOWCOMPONENTSNAPMARKERS\3TRUE\2CFG3D.SHOWCOMPONENTAXES\3TRUE\2CFG3D.SHOWBOARDCORE\3TRUE\2CFG3D.SHOWBOARDPREPREG\3TRUE\2CFG3D.SHOWTOPSILKSCREEN\3TRUE\2CFG3D.SHOWBOTSILKSCREEN\3TRUE\2CFG3D.SHOWORIGINMARKER\3TRUE\2CFG3D.EYEDIST\32000\2CFG3D.SHOWCUTOUTS\3TRUE\2CFG3D.SHOWROUTETOOLPATH\3TRUE\2CFG3D.SHOWROOMS3D\3FALSE\2CFG3D.USESYSCOLORSFOR3D\3FALSE\2CFG3D.WORKSPACECOLOR\311840160\2CFG3D.BOARDCORECOLOR\313491161\2CFG3D.BOARDPREPREGCOLOR\30\2CFG3D.TOPSOLDERMASKCOLOR\30\2CFG3D.BOTSOLDERMASKCOLOR\30\2CFG3D.COPPERCOLOR\33323360\2CFG3D.TOPSILKSCREENCOLOR\315461355\2CFG3D.BOTSILKSCREENCOLOR\315461355\2CFG3D.WORKSPACELUMINANCEVARIATION\330\2CFG3D.WORKSPACECOLOROPACITY\31.000000\2CFG3D.BOARDCORECOLOROPACITY\30.820000\2CFG3D.BOARDPREPREGCOLOROPACITY\30.500000\2CFG3D.TOPSOLDERMASKCOLOROPACITY\30.900000\2CFG3D.BOTSOLDERMASKCOLOROPACITY\30.900000\2CFG3D.COPPERCOLOROPACITY\31.000000\2CFG3D.TOPSILKSCREENCOLOROPACITY\31.000000\2CFG3D.BOTSILKSCREENCOLOROPACITY\31.000000\2CFG3D.BOARDTHICKNESSSCALING\31.000000\2CFG3D.SHOWMECHANICALLAYERS\3FALSE\2CFG3D.MECHANICALLAYERSOPACITY\31.000000 + +[PublishSettings] +OutputFilePath2=C:\Users\David\Documents\OP-WIP\trunk\hardware\production\OpenPilot Atom\Project Outputs for OpenPilot Atom\..\Assembly\OpenPilot Atom Assembly.PDF +ReleaseManaged2=1 +OutputBasePath2=Project Outputs for OpenPilot Atom +OutputPathMedia2=..\Assembly +OutputPathOutputer2=[Output Type] +OutputFileName2=OpenPilot Atom Assembly.PDF +OpenOutput2=1 +PromptOverwrite2=1 +PublishMethod2=0 +ZoomLevel2=50 +FitSCHPrintSizeToDoc2=1 +FitPCBPrintSizeToDoc2=1 +GenerateNetsInfo2=1 +MarkPins2=1 +MarkNetLabels2=1 +MarkPortsId2=1 +GenerateTOC=1 +OutputFilePath3=C:\Users\David\Documents\OP-WIP\trunk\hardware\production\OpenPilot Atom\Project Outputs for OpenPilot Atom\ +ReleaseManaged3=1 +OutputBasePath3=Project Outputs for OpenPilot Atom +OutputPathMedia3= +OutputPathOutputer3=[Output Type] +OutputFileName3= +OpenOutput3=1 +OutputFilePath4=C:\Users\David\Documents\OP-WIP\trunk\hardware\production\OpenPilot Atom\Project Outputs for OpenPilot Atom\ +ReleaseManaged4=1 +OutputBasePath4=Project Outputs for OpenPilot Atom +OutputPathMedia4= +OutputPathOutputer4=[Output Type] +OutputFileName4= +OpenOutput4=1 +PromptOverwrite4=1 +PublishMethod4=5 +ZoomLevel4=50 +FitSCHPrintSizeToDoc4=1 +FitPCBPrintSizeToDoc4=1 +GenerateNetsInfo4=1 +MarkPins4=1 +MarkNetLabels4=1 +MarkPortsId4=1 +MediaFormat4=Windows Media file (*.wmv,*.wma,*.asf) +FixedDimensions4=1 +Width4=352 +Height4=288 +MultiFile4=0 +FramesPerSecond4=25 +FramesPerSecondDenom4=1 +AviPixelFormat4=7 +AviCompression4=MP42 MS-MPEG4 V2 +AviQuality4=100 +FFmpegVideoCodecId4=13 +FFmpegPixelFormat4=0 +FFmpegQuality4=80 +WmvVideoCodecName4=Windows Media Video V7 +WmvQuality4=80 + +[GeneratedFilesSettings] +RelativeOutputPath2=C:\Users\David\Documents\OP-WIP\trunk\hardware\production\OpenPilot Atom\Project Outputs for OpenPilot Atom\..\Assembly\OpenPilot Atom Assembly.PDF +OpenOutputs2=1 +RelativeOutputPath3=C:\Users\David\Documents\OP-WIP\trunk\hardware\production\OpenPilot Atom\Project Outputs for OpenPilot Atom\ +OpenOutputs3=1 +AddToProject3=1 +TimestampFolder3=0 +UseOutputName3=0 +OpenODBOutput3=0 +OpenGerberOutput3=0 +OpenNCDrillOutput3=0 +OpenIPCOutput3=0 +EnableReload3=0 +RelativeOutputPath4=C:\Users\David\Documents\OP-WIP\trunk\hardware\production\OpenPilot Atom\Project Outputs for OpenPilot Atom\ +OpenOutputs4=1 + diff --git a/hardware/Production/OpenPilot Atom/Assembly/OpenPilot Atom Assembly.PDF b/hardware/Production/OpenPilot Atom/Assembly/OpenPilot Atom Assembly.PDF new file mode 100644 index 000000000..ed281f084 Binary files /dev/null and b/hardware/Production/OpenPilot Atom/Assembly/OpenPilot Atom Assembly.PDF differ diff --git a/hardware/Production/OpenPilot Atom/Assembly/OpenPilot Atom Step.zip b/hardware/Production/OpenPilot Atom/Assembly/OpenPilot Atom Step.zip new file mode 100644 index 000000000..ebcfbc2e0 Binary files /dev/null and b/hardware/Production/OpenPilot Atom/Assembly/OpenPilot Atom Step.zip differ diff --git a/hardware/Production/OpenPilot Atom/Assembly/OpenPilot Atom Texture.PDF b/hardware/Production/OpenPilot Atom/Assembly/OpenPilot Atom Texture.PDF new file mode 100644 index 000000000..30f12df43 Binary files /dev/null and b/hardware/Production/OpenPilot Atom/Assembly/OpenPilot Atom Texture.PDF differ diff --git a/hardware/Production/OpenPilot Atom/BOM/OpenPilot Atom.xls b/hardware/Production/OpenPilot Atom/BOM/OpenPilot Atom.xls new file mode 100644 index 000000000..2e8e8a8cd Binary files /dev/null and b/hardware/Production/OpenPilot Atom/BOM/OpenPilot Atom.xls differ diff --git a/hardware/Production/OpenPilot Atom/Gerbers/OpenPilot Atom Gerbers.zip b/hardware/Production/OpenPilot Atom/Gerbers/OpenPilot Atom Gerbers.zip new file mode 100644 index 000000000..f14679d59 Binary files /dev/null and b/hardware/Production/OpenPilot Atom/Gerbers/OpenPilot Atom Gerbers.zip differ diff --git a/hardware/Production/OpenPilot Atom/OpenPilot Atom.PcbDoc b/hardware/Production/OpenPilot Atom/OpenPilot Atom.PcbDoc new file mode 100644 index 000000000..6e82b11ed Binary files /dev/null and b/hardware/Production/OpenPilot Atom/OpenPilot Atom.PcbDoc differ diff --git a/hardware/Production/OpenPilot Atom/OpenPilot Atom.PrjPCB b/hardware/Production/OpenPilot Atom/OpenPilot Atom.PrjPCB new file mode 100644 index 000000000..6b5920089 --- /dev/null +++ b/hardware/Production/OpenPilot Atom/OpenPilot Atom.PrjPCB @@ -0,0 +1,1160 @@ +[Design] +Version=1.0 +HierarchyMode=0 +ChannelRoomNamingStyle=0 +ReleasesFolder= +ReleaseVaultGUID= +ReleaseVaultName= +ChannelDesignatorFormatString=$Component_$RoomName +ChannelRoomLevelSeperator=_ +OpenOutputs=1 +ArchiveProject=0 +TimestampOutput=0 +SeparateFolders=0 +TemplateLocationPath= +PinSwapBy_Netlabel=1 +PinSwapBy_Pin=1 +AllowPortNetNames=0 +AllowSheetEntryNetNames=1 +AppendSheetNumberToLocalNets=0 +NetlistSinglePinNets=0 +DefaultConfiguration=Default Configuration +UserID=0xFFFFFFFF +DefaultPcbProtel=1 +DefaultPcbPcad=0 +ReorderDocumentsOnCompile=1 +NameNetsHierarchically=0 +PowerPortNamesTakePriority=0 +PushECOToAnnotationFile=1 +DItemRevisionGUID= +ReportSuppressedErrorsInMessages=0 +OutputPath= +LogFolderPath= +ManagedProjectGUID= + +[Preferences] +PrefsVaultGUID= +PrefsRevisionGUID= + +[Document1] +DocumentPath=OpenPilot Atom.SchDoc +AnnotationEnabled=1 +AnnotateStartValue=1 +AnnotationIndexControlEnabled=0 +AnnotateSuffix= +AnnotateScope=All +AnnotateOrder=0 +DoLibraryUpdate=1 +DoDatabaseUpdate=1 +ClassGenCCAutoEnabled=1 +ClassGenCCAutoRoomEnabled=0 +ClassGenNCAutoScope=None +DItemRevisionGUID= +GenerateClassCluster=0 +DocumentUniqueId=FWUXSAGW + +[Document2] +DocumentPath=OpenPilot Atom.PcbDoc +AnnotationEnabled=1 +AnnotateStartValue=1 +AnnotationIndexControlEnabled=0 +AnnotateSuffix= +AnnotateScope=All +AnnotateOrder=-1 +DoLibraryUpdate=1 +DoDatabaseUpdate=1 +ClassGenCCAutoEnabled=1 +ClassGenCCAutoRoomEnabled=1 +ClassGenNCAutoScope=None +DItemRevisionGUID= +GenerateClassCluster=0 +DocumentUniqueId=CPDAMJJA + +[Document3] +DocumentPath=Assembly.OutJob +AnnotationEnabled=1 +AnnotateStartValue=1 +AnnotationIndexControlEnabled=0 +AnnotateSuffix= +AnnotateScope=All +AnnotateOrder=-1 +DoLibraryUpdate=1 +DoDatabaseUpdate=1 +ClassGenCCAutoEnabled=1 +ClassGenCCAutoRoomEnabled=1 +ClassGenNCAutoScope=None +DItemRevisionGUID= +GenerateClassCluster=0 +DocumentUniqueId= + +[SearchPath1] +Path=..\..\..\..\Program Files (x86)\Altium Designer Summer 09\Library\*.* +IncludeSubFolders=1 + +[Configuration1] +Name=Default Configuration +ParameterCount=0 +ConstraintFileCount=0 +ReleaseItemId= +CurrentRevision= +Variant=[No Variations] +GenerateBOM=0 +OutputJobsCount=0 + +[Generic_SmartPDF] +AutoOpenFile=-1 +AutoOpenOutJob=-1 + +[Generic_SmartPDFSettings] +ProjectMode=0 +ZoomPrecision=50 +AddNetsInformation=-1 +AddNetPins=-1 +AddNetNetLabels=-1 +AddNetPorts=-1 +ExportBOM=0 +TemplateFilename= +TemplateStoreRelative=-1 +PCB_PrintColor=0 +SCH_PrintColor=0 +SCH_ShowNoErc=0 +SCH_ShowParameter=0 +SCH_ShowProbes=0 +SCH_ShowBlankets=0 +OutputFileName=CopterControl.SchDoc=C:\Users\David\Documents\SVN\WIP\trunk\hardware\production\CopterControl\CopterControl Schematic.pdf +SCH_ExpandLogicalToPhysical=0 +SCH_VariantName=[No Variations] +SCH_ExpandComponentDesignators=-1 +SCH_ExpandNetlabels=0 +SCH_ExpandPorts=0 +SCH_ExpandSheetNumber=0 +SCH_ExpandDocumentNumber=0 +SCH_HasExpandLogicalToPhysicalSheets=-1 +SaveSettingsToOutJob=0 +SCH_NoERCSymbolsToShow="Thin Cross","Thick Cross","Small Cross",Checkbox,Triangle +SCH_ShowNote=-1 +SCH_ShowNoteCollapsed=-1 + +[Generic_EDE] +OutputDir= + +[OutputGroup1] +Name=Netlist Outputs +Description= +TargetPrinter=Microsoft XPS Document Writer +PrinterOptions=Record=PrinterOptions|Copies=1|Duplex=1|TrueTypeOptions=3|Collate=1|PrintJobKind=1|PrintWhat=1 +OutputType1=SIMetrixNetlist +OutputName1=SIMetrix +OutputDocumentPath1= +OutputVariantName1= +OutputDefault1=0 +OutputType2=SIMPLISNetlist +OutputName2=SIMPLIS +OutputDocumentPath2= +OutputVariantName2= +OutputDefault2=0 +OutputType3=XSpiceNetlist +OutputName3=XSpice Netlist +OutputDocumentPath3= +OutputVariantName3= +OutputDefault3=0 +OutputType4=PCADNetlist +OutputName4=PCAD Netlist +OutputDocumentPath4= +OutputVariantName4= +OutputDefault4=0 +OutputType5=Verilog +OutputName5=Verilog File +OutputDocumentPath5= +OutputVariantName5= +OutputDefault5=0 +OutputType6=VHDL +OutputName6=VHDL File +OutputDocumentPath6= +OutputVariantName6= +OutputDefault6=0 + +[OutputGroup2] +Name=Simulator Outputs +Description= +TargetPrinter=Microsoft XPS Document Writer +PrinterOptions=Record=PrinterOptions|Copies=1|Duplex=1|TrueTypeOptions=3|Collate=1|PrintJobKind=1|PrintWhat=1 +OutputType1=AdvSimNetlist +OutputName1=Mixed Sim +OutputDocumentPath1= +OutputVariantName1= +OutputDefault1=0 +OutputType2=SIMetrixSimulation +OutputName2=SIMetrix +OutputDocumentPath2= +OutputVariantName2= +OutputDefault2=0 +OutputType3=SIMPLISSimulation +OutputName3=SIMPLIS +OutputDocumentPath3= +OutputVariantName3= +OutputDefault3=0 + +[OutputGroup3] +Name=Documentation Outputs +Description= +TargetPrinter=Virtual Printer +PrinterOptions=Record=PrinterOptions|Copies=1|Duplex=1|TrueTypeOptions=3|Collate=1|PrintJobKind=1|PrintWhat=1 +OutputType1=Composite +OutputName1=Composite Drawing +OutputDocumentPath1=C:\Users\David\Documents\SVN\OP-WIP\trunk\hardware\production\CopterControl\CopterControl.PcbDoc +OutputVariantName1= +OutputDefault1=0 +PageOptions1=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=0|PaperKind=A4 +Configuration1_Name1=OutputConfigurationParameter1 +Configuration1_Item1=PrintArea=DesignExtent|PrintAreaLowerLeftCornerX=0|PrintAreaLowerLeftCornerY=0|PrintAreaUpperRightCornerX=0|PrintAreaUpperRightCornerY=0|Record=PcbPrintView +Configuration1_Name2=OutputConfigurationParameter2 +Configuration1_Item2=IncludeBottomLayerComponents=True|IncludeMultiLayerComponents=True|IncludeTopLayerComponents=True|Index=0|Mirror=False|Name=Multilayer Composite Print|PadNumberFontSize=14|Record=PcbPrintOut|ShowHoles=False|ShowPadNets=False|ShowPadNumbers=False|SubstituteFonts=False +Configuration1_Name3=OutputConfigurationParameter3 +Configuration1_Item3=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=TopOverlay|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration1_Name4=OutputConfigurationParameter4 +Configuration1_Item4=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=BottomOverlay|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration1_Name5=OutputConfigurationParameter5 +Configuration1_Item5=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=TopLayer|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration1_Name6=OutputConfigurationParameter6 +Configuration1_Item6=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=MidLayer1|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration1_Name7=OutputConfigurationParameter7 +Configuration1_Item7=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=BottomLayer|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration1_Name8=OutputConfigurationParameter8 +Configuration1_Item8=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical1|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration1_Name9=OutputConfigurationParameter9 +Configuration1_Item9=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical5|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration1_Name10=OutputConfigurationParameter10 +Configuration1_Item10=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical6|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration1_Name11=OutputConfigurationParameter11 +Configuration1_Item11=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical7|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration1_Name12=OutputConfigurationParameter12 +Configuration1_Item12=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical13|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration1_Name13=OutputConfigurationParameter13 +Configuration1_Item13=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical15|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration1_Name14=OutputConfigurationParameter14 +Configuration1_Item14=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=MultiLayer|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +OutputType2=PCB 3D Print +OutputName2=PCB 3D Prints +OutputDocumentPath2= +OutputVariantName2=[No Variations] +OutputDefault2=0 +PageOptions2=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +OutputType3=PCB Print +OutputName3=PCB Prints +OutputDocumentPath3= +OutputVariantName3= +OutputDefault3=0 +PageOptions3=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +OutputType4=Schematic Print +OutputName4=Schematic Prints +OutputDocumentPath4= +OutputVariantName4= +OutputDefault4=0 +PageOptions4=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +OutputType5=SimView Print +OutputName5=SimView Prints +OutputDocumentPath5= +OutputVariantName5= +OutputDefault5=0 +PageOptions5=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +OutputType6=Wave Print +OutputName6=Wave Prints +OutputDocumentPath6= +OutputVariantName6= +OutputDefault6=0 +PageOptions6=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +OutputType7=WaveSim Print +OutputName7=WaveSim Prints +OutputDocumentPath7= +OutputVariantName7= +OutputDefault7=0 +PageOptions7=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +OutputType8=PCB 3D Video +OutputName8=PCB 3D Video +OutputDocumentPath8= +OutputVariantName8=[No Variations] +OutputDefault8=0 +PageOptions8=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +OutputType9=Report Print +OutputName9=Report Prints +OutputDocumentPath9= +OutputVariantName9= +OutputDefault9=0 +PageOptions9=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +OutputType10=PCBLIB Print +OutputName10=PCBLIB Prints +OutputDocumentPath10= +OutputVariantName10= +OutputDefault10=0 +PageOptions10=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +OutputType11=Assembler Source Print +OutputName11=Assembler Source Prints +OutputDocumentPath11= +OutputVariantName11= +OutputDefault11=0 +PageOptions11=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType12=C Source Print +OutputName12=C Source Prints +OutputDocumentPath12= +OutputVariantName12= +OutputDefault12=0 +PageOptions12=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType13=C/C++ Header Print +OutputName13=C/C++ Header Prints +OutputDocumentPath13= +OutputVariantName13= +OutputDefault13=0 +PageOptions13=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType14=C++ Source Print +OutputName14=C++ Source Prints +OutputDocumentPath14= +OutputVariantName14= +OutputDefault14=0 +PageOptions14=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType15=FSM Print +OutputName15=FSM Prints +OutputDocumentPath15= +OutputVariantName15= +OutputDefault15=0 +PageOptions15=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType16=OpenBus Print +OutputName16=OpenBus Prints +OutputDocumentPath16= +OutputVariantName16= +OutputDefault16=0 +PageOptions16=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType17=VHDL Print +OutputName17=VHDL Prints +OutputDocumentPath17= +OutputVariantName17= +OutputDefault17=0 +PageOptions17=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 + +[OutputGroup4] +Name=Assembly Outputs +Description= +TargetPrinter=Microsoft XPS Document Writer +PrinterOptions=Record=PrinterOptions|Copies=1|Duplex=1|TrueTypeOptions=3|Collate=1|PrintJobKind=1|PrintWhat=1 +OutputType1=Test Points For Assembly +OutputName1=Test Point Report +OutputDocumentPath1= +OutputVariantName1=[No Variations] +OutputDefault1=0 +OutputType2=Pick Place +OutputName2=Generates pick and place files +OutputDocumentPath2= +OutputVariantName2=[No Variations] +OutputDefault2=0 +Configuration2_Name1=OutputConfigurationParameter1 +Configuration2_Item1=Record=PickPlaceView|Units=Imperial|GenerateCSVFormat=True|GenerateTextFormat=False +OutputType3=Assembly +OutputName3=Assembly Drawings +OutputDocumentPath3= +OutputVariantName3=[No Variations] +OutputDefault3=0 +PageOptions3=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 + +[OutputGroup5] +Name=Fabrication Outputs +Description= +TargetPrinter=Microsoft XPS Document Writer +PrinterOptions=Record=PrinterOptions|Copies=1|Duplex=1|TrueTypeOptions=3|Collate=1|PrintJobKind=1|PrintWhat=1 +OutputType1=ODB +OutputName1=ODB++ Files +OutputDocumentPath1= +OutputVariantName1=[No Variations] +OutputDefault1=0 +OutputType2=NC Drill +OutputName2=NC Drill Files +OutputDocumentPath2= +OutputVariantName2= +OutputDefault2=0 +Configuration2_Name1=OutputConfigurationParameter1 +Configuration2_Item1=BoardEdgeRoutToolDia=2000000|GenerateBoardEdgeRout=False|GenerateDrilledSlotsG85=False|GenerateEIADrillFile=False|GenerateSeparatePlatedNonPlatedFiles=False|NumberOfDecimals=5|NumberOfUnits=2|OptimizeChangeLocationCommands=True|OriginPosition=Relative|Record=DrillView|Units=Imperial|ZeroesMode=SuppressTrailingZeroes +OutputType3=Plane +OutputName3=Power-Plane Prints +OutputDocumentPath3= +OutputVariantName3= +OutputDefault3=0 +PageOptions3=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +OutputType4=Mask +OutputName4=Solder/Paste Mask Prints +OutputDocumentPath4= +OutputVariantName4= +OutputDefault4=0 +PageOptions4=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +OutputType5=Drill +OutputName5=Drill Drawing/Guides +OutputDocumentPath5= +OutputVariantName5= +OutputDefault5=0 +PageOptions5=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=9.20|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +Configuration5_Name1=OutputConfigurationParameter1 +Configuration5_Item1=PrintArea=DesignExtent|PrintAreaLowerLeftCornerX=0|PrintAreaLowerLeftCornerY=0|PrintAreaUpperRightCornerX=0|PrintAreaUpperRightCornerY=0|Record=PcbPrintView +Configuration5_Name2=OutputConfigurationParameter2 +Configuration5_Item2=IncludeBottomLayerComponents=True|IncludeMultiLayerComponents=True|IncludeTopLayerComponents=True|Index=0|Mirror=False|Name=Drill Drawing For (Bottom Layer,Top Layer)|PadNumberFontSize=14|Record=PcbPrintOut|ShowHoles=False|ShowPadNets=False|ShowPadNumbers=False|SubstituteFonts=False +Configuration5_Name3=OutputConfigurationParameter3 +Configuration5_Item3=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=BottomLayer|DLayer2=TopLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=DrillDrawing|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration5_Name4=OutputConfigurationParameter4 +Configuration5_Item4=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical1|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration5_Name5=OutputConfigurationParameter5 +Configuration5_Item5=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical5|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration5_Name6=OutputConfigurationParameter6 +Configuration5_Item6=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical6|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration5_Name7=OutputConfigurationParameter7 +Configuration5_Item7=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical7|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration5_Name8=OutputConfigurationParameter8 +Configuration5_Item8=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical13|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration5_Name9=OutputConfigurationParameter9 +Configuration5_Item9=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical15|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration5_Name10=OutputConfigurationParameter10 +Configuration5_Item10=IncludeBottomLayerComponents=True|IncludeMultiLayerComponents=True|IncludeTopLayerComponents=True|Index=1|Mirror=False|Name=Drill Guide For (Bottom Layer,Top Layer)|PadNumberFontSize=14|Record=PcbPrintOut|ShowHoles=False|ShowPadNets=False|ShowPadNumbers=False|SubstituteFonts=False +Configuration5_Name11=OutputConfigurationParameter11 +Configuration5_Item11=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=BottomLayer|DLayer2=TopLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=DrillGuide|Polygon=Full|PrintOutIndex=1|Record=PcbPrintLayer +Configuration5_Name12=OutputConfigurationParameter12 +Configuration5_Item12=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical1|Polygon=Full|PrintOutIndex=1|Record=PcbPrintLayer +Configuration5_Name13=OutputConfigurationParameter13 +Configuration5_Item13=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical5|Polygon=Full|PrintOutIndex=1|Record=PcbPrintLayer +Configuration5_Name14=OutputConfigurationParameter14 +Configuration5_Item14=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical6|Polygon=Full|PrintOutIndex=1|Record=PcbPrintLayer +Configuration5_Name15=OutputConfigurationParameter15 +Configuration5_Item15=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical7|Polygon=Full|PrintOutIndex=1|Record=PcbPrintLayer +Configuration5_Name16=OutputConfigurationParameter16 +Configuration5_Item16=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical13|Polygon=Full|PrintOutIndex=1|Record=PcbPrintLayer +Configuration5_Name17=OutputConfigurationParameter17 +Configuration5_Item17=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical15|Polygon=Full|PrintOutIndex=1|Record=PcbPrintLayer +OutputType6=CompositeDrill +OutputName6=Composite Drill Drawing +OutputDocumentPath6= +OutputVariantName6= +OutputDefault6=0 +PageOptions6=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +OutputType7=Final +OutputName7=Final Artwork Prints +OutputDocumentPath7= +OutputVariantName7=[No Variations] +OutputDefault7=0 +PageOptions7=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +OutputType8=Test Points +OutputName8=Test Point Report +OutputDocumentPath8= +OutputVariantName8= +OutputDefault8=0 +OutputType9=Gerber +OutputName9=Gerber Files +OutputDocumentPath9= +OutputVariantName9=[No Variations] +OutputDefault9=0 +Configuration9_Name1=OutputConfigurationParameter1 +Configuration9_Item1=AddToAllPlots.Set=SerializeLayerHash.Version~2,ClassName~TLayerToBoolean|CentrePlots=False|DrillDrawingSymbol=GraphicsSymbol|DrillDrawingSymbolSize=500000|EmbeddedApertures=True|FilmBorderSize=10000000|FilmXSize=200000000|FilmYSize=160000000|FlashAllFills=False|FlashPadShapes=True|G54OnApertureChange=False|GenerateDRCRulesFile=True|GenerateReliefShapes=True|GerberUnit=Imperial|IncludeUnconnectedMidLayerPads=False|LeadingAndTrailingZeroesMode=SuppressLeadingZeroes|MaxApertureSize=2500000|MinusApertureTolerance=50|Mirror.Set=SerializeLayerHash.Version~2,ClassName~TLayerToBoolean|MirrorDrillDrawingPlots=False|MirrorDrillGuidePlots=False|NumberOfDecimals=5|OptimizeChangeLocationCommands=True|OriginPosition=Relative|Panelize=False|Plot.Set=SerializeLayerHash.Version~2,ClassName~TLayerToBoolean,16973830~1,16973832~1,16973834~1,16777217~1,16777218~1,16777219~1,16842751~1,16973835~1,16973833~1,16973831~1,16908294~1,16908295~1,16973837~1,16973848~1,16973849~1|PlotPositivePlaneLayers=False|PlotUsedDrillDrawingLayerPairs=True|PlotUsedDrillGuideLayerPairs=True|PlusApertureTolerance=50|Record=GerberView|SoftwareArcs=False|Sorted=False +OutputType10=Board Stack Report +OutputName10=Report Board Stack +OutputDocumentPath10= +OutputVariantName10= +OutputDefault10=0 +PageOptions10=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType11=Gerber X2 +OutputName11=Gerber X2 Files +OutputDocumentPath11= +OutputVariantName11= +OutputDefault11=0 +OutputType12=IPC2581 +OutputName12=IPC-2581 Files +OutputDocumentPath12= +OutputVariantName12= +OutputDefault12=0 + +[OutputGroup6] +Name=Report Outputs +Description= +TargetPrinter=Microsoft XPS Document Writer +PrinterOptions=Record=PrinterOptions|Copies=1|Duplex=1|TrueTypeOptions=3|Collate=1|PrintJobKind=1|PrintWhat=1 +OutputType1=ComponentCrossReference +OutputName1=Component Cross Reference Report +OutputDocumentPath1= +OutputVariantName1=[No Variations] +OutputDefault1=0 +OutputType2=ReportHierarchy +OutputName2=Report Project Hierarchy +OutputDocumentPath2= +OutputVariantName2=[No Variations] +OutputDefault2=0 +OutputType3=SinglePinNetReporter +OutputName3=Report Single Pin Nets +OutputDocumentPath3= +OutputVariantName3=[No Variations] +OutputDefault3=0 +OutputType4=SimpleBOM +OutputName4=Simple BOM +OutputDocumentPath4= +OutputVariantName4=[No Variations] +OutputDefault4=0 +OutputType5=Script +OutputName5=Script Output +OutputDocumentPath5= +OutputVariantName5=[No Variations] +OutputDefault5=0 +OutputType6=BOM_PartType +OutputName6=Bill of Materials +OutputDocumentPath6= +OutputVariantName6=[No Variations] +OutputDefault6=0 +PageOptions6=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +Configuration6_Name1=Filter +Configuration6_Item1=545046300E5446696C74657257726170706572000D46696C7465722E416374697665090F46696C7465722E43726974657269610A04000000000000000000 +Configuration6_Name2=General +Configuration6_Item2=OpenExported=True|AddToProject=False|ForceFit=False|NotFitted=False|Database=False|IncludePCBData=False|IncludeVaultData=False|ShowExportOptions=True|TemplateFilename=..\Altium\BOM OpenPilot.xlt|BatchMode=5|FormWidth=1401|FormHeight=754|SupplierProdQty=1|SupplierAutoQty=True|SupplierUseCachedPricing=True|SupplierCurrency= +Configuration6_Name3=GroupOrder +Configuration6_Item3=Supplier Part Number 1=True +Configuration6_Name4=OutputConfigurationParameter1 +Configuration6_Item4=Record=BOMPrintView|ShowNoERC=True|ShowParamSet=True|ShowProbe=True|ShowBlanket=True|ExpandDesignator=True|ExpandNetLabel=False|ExpandPort=False|ExpandSheetNum=False|ExpandDocNum=False +Configuration6_Name5=PCBDocument +Configuration6_Item5= +Configuration6_Name6=SortOrder +Configuration6_Item6=Description=Up +Configuration6_Name7=VisibleOrder +Configuration6_Item7=Description=113|Comment=77|Footprint=59|Value=40|Designator=56|Quantity=37|Supplier Part Number 1=174|Supplier Order Qty 1=30|Supplier Stock 1=38|Supplier Unit Price 1=29|Supplier Subtotal 1=30|Supplier 1=23|Manufacturer 1=32|Manufacturer Part Number 1=20 + +[OutputGroup7] +Name=Other Outputs +Description= +TargetPrinter=Microsoft XPS Document Writer +PrinterOptions=Record=PrinterOptions|Copies=1|Duplex=1|TrueTypeOptions=3|Collate=1|PrintJobKind=1|PrintWhat=1 +OutputType1=Text Print +OutputName1=Text Print +OutputDocumentPath1= +OutputVariantName1= +OutputDefault1=0 +PageOptions1=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +OutputType2=Text Print +OutputName2=Text Print +OutputDocumentPath2= +OutputVariantName2= +OutputDefault2=0 +PageOptions2=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType3=Text Print +OutputName3=Text Print +OutputDocumentPath3= +OutputVariantName3= +OutputDefault3=0 +PageOptions3=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType4=Text Print +OutputName4=Text Print +OutputDocumentPath4= +OutputVariantName4= +OutputDefault4=0 +PageOptions4=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType5=Text Print +OutputName5=Text Print +OutputDocumentPath5= +OutputVariantName5= +OutputDefault5=0 +PageOptions5=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType6=Text Print +OutputName6=Text Print +OutputDocumentPath6= +OutputVariantName6= +OutputDefault6=0 +PageOptions6=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType7=Text Print +OutputName7=Text Print +OutputDocumentPath7= +OutputVariantName7= +OutputDefault7=0 +PageOptions7=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType8=Text Print +OutputName8=Text Print +OutputDocumentPath8= +OutputVariantName8= +OutputDefault8=0 +PageOptions8=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType9=Text Print +OutputName9=Text Print +OutputDocumentPath9= +OutputVariantName9= +OutputDefault9=0 +PageOptions9=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType10=Text Print +OutputName10=Text Print +OutputDocumentPath10= +OutputVariantName10= +OutputDefault10=0 +PageOptions10=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType11=Text Print +OutputName11=Text Print +OutputDocumentPath11= +OutputVariantName11= +OutputDefault11=0 +PageOptions11=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType12=Text Print +OutputName12=Text Print +OutputDocumentPath12= +OutputVariantName12= +OutputDefault12=0 +PageOptions12=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType13=Text Print +OutputName13=Text Print +OutputDocumentPath13= +OutputVariantName13= +OutputDefault13=0 +PageOptions13=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType14=Text Print +OutputName14=Text Print +OutputDocumentPath14= +OutputVariantName14= +OutputDefault14=0 +PageOptions14=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType15=Text Print +OutputName15=Text Print +OutputDocumentPath15= +OutputVariantName15= +OutputDefault15=0 +PageOptions15=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType16=Text Print +OutputName16=Text Print +OutputDocumentPath16= +OutputVariantName16= +OutputDefault16=0 +PageOptions16=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType17=Text Print +OutputName17=Text Print +OutputDocumentPath17= +OutputVariantName17= +OutputDefault17=0 +PageOptions17=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType18=Text Print +OutputName18=Text Print +OutputDocumentPath18= +OutputVariantName18= +OutputDefault18=0 +PageOptions18=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType19=Text Print +OutputName19=Text Print +OutputDocumentPath19= +OutputVariantName19= +OutputDefault19=0 +PageOptions19=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType20=Text Print +OutputName20=Text Print +OutputDocumentPath20= +OutputVariantName20= +OutputDefault20=0 +PageOptions20=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType21=Text Print +OutputName21=Text Print +OutputDocumentPath21= +OutputVariantName21= +OutputDefault21=0 +PageOptions21=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType22=Text Print +OutputName22=Text Print +OutputDocumentPath22= +OutputVariantName22= +OutputDefault22=0 +PageOptions22=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType23=Text Print +OutputName23=Text Print +OutputDocumentPath23= +OutputVariantName23= +OutputDefault23=0 +PageOptions23=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType24=Text Print +OutputName24=Text Print +OutputDocumentPath24= +OutputVariantName24= +OutputDefault24=0 +PageOptions24=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType25=Text Print +OutputName25=Text Print +OutputDocumentPath25= +OutputVariantName25= +OutputDefault25=0 +PageOptions25=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType26=Text Print +OutputName26=Text Print +OutputDocumentPath26= +OutputVariantName26= +OutputDefault26=0 +PageOptions26=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType27=Text Print +OutputName27=Text Print +OutputDocumentPath27= +OutputVariantName27= +OutputDefault27=0 +PageOptions27=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType28=Text Print +OutputName28=Text Print +OutputDocumentPath28= +OutputVariantName28= +OutputDefault28=0 +PageOptions28=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 +OutputType29=Text Print +OutputName29=Text Print +OutputDocumentPath29= +OutputVariantName29= +OutputDefault29=0 +PageOptions29=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-3|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4|PaperIndex=9 + +[OutputGroup8] +Name=Validation Outputs +Description= +TargetPrinter=Microsoft XPS Document Writer +PrinterOptions=Record=PrinterOptions|Copies=1|Duplex=1|TrueTypeOptions=3|Collate=1|PrintJobKind=1|PrintWhat=1 +OutputType1=Design Rules Check +OutputName1=Design Rules Check +OutputDocumentPath1= +OutputVariantName1= +OutputDefault1=0 +PageOptions1=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +OutputType2=Electrical Rules Check +OutputName2=Electrical Rules Check +OutputDocumentPath2= +OutputVariantName2= +OutputDefault2=0 +PageOptions2=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +OutputType3=Differences Report +OutputName3=Differences Report +OutputDocumentPath3= +OutputVariantName3= +OutputDefault3=0 +PageOptions3=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +OutputType4=Footprint Comparison Report +OutputName4=Footprint Comparison Report +OutputDocumentPath4= +OutputVariantName4= +OutputDefault4=0 +OutputType5=Configuration compliance +OutputName5=Environment configuration compliance check +OutputDocumentPath5= +OutputVariantName5= +OutputDefault5=0 + +[OutputGroup9] +Name=Export Outputs +Description= +TargetPrinter=Microsoft XPS Document Writer +PrinterOptions=Record=PrinterOptions|Copies=1|Duplex=1|TrueTypeOptions=3|Collate=1|PrintJobKind=1|PrintWhat=1 +OutputType1=ExportSTEP +OutputName1=Export STEP +OutputDocumentPath1= +OutputVariantName1=[No Variations] +OutputDefault1=0 +OutputType2=AutoCAD dwg/dxf PCB +OutputName2=AutoCAD dwg/dxf File PCB +OutputDocumentPath2= +OutputVariantName2= +OutputDefault2=0 +OutputType3=ExportIDF +OutputName3=Export IDF +OutputDocumentPath3= +OutputVariantName3= +OutputDefault3=0 +OutputType4=AutoCAD dwg/dxf Schematic +OutputName4=AutoCAD dwg/dxf File Schematic +OutputDocumentPath4= +OutputVariantName4= +OutputDefault4=0 + +[Modification Levels] +Type1=1 +Type2=1 +Type3=1 +Type4=1 +Type5=1 +Type6=1 +Type7=1 +Type8=1 +Type9=1 +Type10=1 +Type11=1 +Type12=1 +Type13=1 +Type14=1 +Type15=1 +Type16=1 +Type17=1 +Type18=1 +Type19=1 +Type20=1 +Type21=1 +Type22=1 +Type23=1 +Type24=1 +Type25=1 +Type26=1 +Type27=1 +Type28=1 +Type29=1 +Type30=1 +Type31=1 +Type32=1 +Type33=1 +Type34=1 +Type35=1 +Type36=1 +Type37=1 +Type38=1 +Type39=1 +Type40=1 +Type41=1 +Type42=1 +Type43=1 +Type44=1 +Type45=1 +Type46=1 +Type47=1 +Type48=1 +Type49=1 +Type50=1 +Type51=1 +Type52=1 +Type53=1 +Type54=1 +Type55=1 +Type56=1 +Type57=1 +Type58=1 +Type59=1 +Type60=1 +Type61=1 +Type62=1 +Type63=1 +Type64=1 +Type65=1 +Type66=1 +Type67=1 +Type68=1 +Type69=1 +Type70=1 +Type71=1 +Type72=1 +Type73=1 +Type74=1 +Type75=1 +Type76=1 +Type77=1 +Type78=1 + +[Difference Levels] +Type1=1 +Type2=1 +Type3=1 +Type4=1 +Type5=1 +Type6=1 +Type7=1 +Type8=1 +Type9=1 +Type10=1 +Type11=1 +Type12=1 +Type13=1 +Type14=1 +Type15=1 +Type16=1 +Type17=1 +Type18=1 +Type19=1 +Type20=1 +Type21=1 +Type22=1 +Type23=1 +Type24=1 +Type25=1 +Type26=1 +Type27=1 +Type28=1 +Type29=1 +Type30=1 +Type31=1 +Type32=1 +Type33=1 +Type34=1 +Type35=1 +Type36=1 +Type37=1 +Type38=1 +Type39=1 +Type40=1 +Type41=1 +Type42=1 +Type43=1 + +[Electrical Rules Check] +Type1=1 +Type2=1 +Type3=2 +Type4=1 +Type5=2 +Type6=2 +Type7=1 +Type8=1 +Type9=1 +Type10=1 +Type11=2 +Type12=2 +Type13=2 +Type14=1 +Type15=1 +Type16=1 +Type17=1 +Type18=1 +Type19=1 +Type20=1 +Type21=1 +Type22=1 +Type23=1 +Type24=1 +Type25=2 +Type26=2 +Type27=2 +Type28=1 +Type29=1 +Type30=1 +Type31=1 +Type32=2 +Type33=2 +Type34=2 +Type35=1 +Type36=2 +Type37=1 +Type38=2 +Type39=2 +Type40=2 +Type41=0 +Type42=2 +Type43=1 +Type44=1 +Type45=2 +Type46=1 +Type47=2 +Type48=2 +Type49=1 +Type50=2 +Type51=1 +Type52=1 +Type53=1 +Type54=1 +Type55=1 +Type56=2 +Type57=1 +Type58=1 +Type59=0 +Type60=1 +Type61=2 +Type62=2 +Type63=1 +Type64=0 +Type65=2 +Type66=3 +Type67=2 +Type68=2 +Type69=1 +Type70=2 +Type71=2 +Type72=2 +Type73=2 +Type74=1 +Type75=2 +Type76=1 +Type77=1 +Type78=1 +Type79=1 +Type80=2 +Type81=3 +Type82=3 +Type83=3 +Type84=3 +Type85=3 +Type86=2 +Type87=2 +Type88=2 +Type89=1 +Type90=1 +Type91=3 +Type92=3 +Type93=2 +Type94=2 +Type95=2 +Type96=2 +Type97=2 +Type98=0 +Type99=1 +Type100=2 +Type101=1 +Type102=2 +Type103=2 +Type104=1 +Type105=2 +Type106=2 +Type107=2 +Type108=2 +Type109=1 +Type110=0 + +[ERC Connection Matrix] +L1=NNNNNNNNNNNWNNNWW +L2=NNWNNNNWWWNWNWNWN +L3=NWEENEEEENEWNEEWN +L4=NNENNNWEENNWNENWN +L5=NNNNNNNNNNNNNNNNN +L6=NNENNNNEENNWNENWN +L7=NNEWNNWEENNWNENWN +L8=NWEENEENEEENNEENN +L9=NWEENEEEENEWNEEWW +L10=NWNNNNNENNEWNNEWN +L11=NNENNNNEEENWNENWN +L12=WWWWNWWNWWWNWWWNN +L13=NNNNNNNNNNNWNNNWW +L14=NWEENEEEENEWNEEWW +L15=NNENNNNEEENWNENWW +L16=WWWWNWWNWWWNWWWNW +L17=WNNNNNNNWNNNWWWWN + +[Annotate] +SortOrder=3 +SortLocation=0 +MatchParameter1=Comment +MatchStrictly1=1 +MatchParameter2=Library Reference +MatchStrictly2=1 +PhysicalNamingFormat=$Component_$RoomName +GlobalIndexSortOrder=3 +GlobalIndexSortLocation=0 + +[PrjClassGen] +CompClassManualEnabled=0 +CompClassManualRoomEnabled=0 +NetClassAutoBusEnabled=1 +NetClassAutoCompEnabled=0 +NetClassAutoNamedHarnessEnabled=0 +NetClassManualEnabled=1 + +[LibraryUpdateOptions] +SelectedOnly=0 +UpdateVariants=1 +PartTypes=0 +ComponentLibIdentifierKind0=Library Name And Type +ComponentLibraryIdentifier0=CopterControl.SchLib +ComponentDesignItemID0=CC-STM32F103CBT6 +ComponentSymbolReference0=CC-STM32F103CBT6 +ComponentUpdate0=1 +ComponentIsDeviceSheet0=0 +FullReplace=1 +UpdateDesignatorLock=1 +UpdatePartIDLock=1 +PreserveParameterLocations=1 +PreserveParameterVisibility=1 +DoGraphics=1 +DoParameters=1 +DoModels=1 +AddParameters=0 +RemoveParameters=0 +AddModels=1 +RemoveModels=1 +UpdateCurrentModels=1 +ParameterName0=Comment +ParameterUpdate0=1 +ParameterName1=Component Kind +ParameterUpdate1=1 +ParameterName2=ComponentLink1Description +ParameterUpdate2=1 +ParameterName3=ComponentLink1URL +ParameterUpdate3=1 +ParameterName4=ComponentLink2Description +ParameterUpdate4=1 +ParameterName5=ComponentLink2URL +ParameterUpdate5=1 +ParameterName6=DatasheetVersion +ParameterUpdate6=1 +ParameterName7=Description +ParameterUpdate7=1 +ParameterName8=Library Reference +ParameterUpdate8=1 +ParameterName9=PackageDescription +ParameterUpdate9=1 +ParameterName10=PackageReference +ParameterUpdate10=1 +ParameterName11=PackageVersion +ParameterUpdate11=1 +ParameterName12=Published +ParameterUpdate12=1 +ParameterName13=Publisher +ParameterUpdate13=1 +ParameterName14=Supplier 1 +ParameterUpdate14=1 +ParameterName15=Supplier Part Number 1 +ParameterUpdate15=1 +ModelTypeGroup0=PCBLIB +ModelTypeUpdate0=1 +ModelType0=PCBLIB +ModelName0=LQFP48_L +ModelUpdate0=1 +ModelType1=PCBLIB +ModelName1=LQFP48_M +ModelUpdate1=1 +ModelType2=PCBLIB +ModelName2=LQFP48_N +ModelUpdate2=1 + +[DatabaseUpdateOptions] +SelectedOnly=0 +UpdateVariants=1 +PartTypes=0 + +[Comparison Options] +ComparisonOptions0=Kind=Net|MinPercent=75|MinMatch=3|ShowMatch=-1|Confirm=-1|UseName=-1|InclAllRules=0 +ComparisonOptions1=Kind=Net Class|MinPercent=75|MinMatch=3|ShowMatch=-1|Confirm=-1|UseName=-1|InclAllRules=0 +ComparisonOptions2=Kind=Component Class|MinPercent=75|MinMatch=3|ShowMatch=-1|Confirm=-1|UseName=-1|InclAllRules=0 +ComparisonOptions3=Kind=Rule|MinPercent=75|MinMatch=3|ShowMatch=-1|Confirm=-1|UseName=-1|InclAllRules=0 +ComparisonOptions4=Kind=Differential Pair|MinPercent=50|MinMatch=1|ShowMatch=0|Confirm=0|UseName=0|InclAllRules=0 +ComparisonOptions5=Kind=Code Memory|MinPercent=75|MinMatch=3|ShowMatch=-1|Confirm=-1|UseName=-1|InclAllRules=0 + +[SmartPDF] +PageOptions=Record=PageOptions|CenterHorizontal=True|CenterVertical=True|PrintScale=1.00|XCorrection=1.00|YCorrection=1.00|PrintKind=1|BorderSize=5000000|LeftOffset=0|BottomOffset=0|Orientation=2|PaperLength=1000|PaperWidth=1000|Scale=100|PaperSource=7|PrintQuality=-4|MediaType=1|DitherType=10|PrintScaleMode=1|PaperKind=A4 +Configuration_Name1=OutputConfigurationParameter1 +Configuration_Item1=PrintArea=DesignExtent|PrintAreaLowerLeftCornerX=0|PrintAreaLowerLeftCornerY=0|PrintAreaUpperRightCornerX=0|PrintAreaUpperRightCornerY=0|Record=PcbPrintView +Configuration_Name2=OutputConfigurationParameter2 +Configuration_Item2=IncludeBottomLayerComponents=False|IncludeMultiLayerComponents=False|IncludeTopLayerComponents=False|Index=0|Mirror=False|Name=Panel Details|PadNumberFontSize=14|Record=PcbPrintOut|ShowHoles=False|ShowPadNets=False|ShowPadNumbers=False|SubstituteFonts=False +Configuration_Name3=OutputConfigurationParameter3 +Configuration_Item3=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical16|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration_Name4=OutputConfigurationParameter4 +Configuration_Item4=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical1|Polygon=Full|PrintOutIndex=0|Record=PcbPrintLayer +Configuration_Name5=OutputConfigurationParameter5 +Configuration_Item5=IncludeBottomLayerComponents=False|IncludeMultiLayerComponents=False|IncludeTopLayerComponents=False|Index=1|Mirror=False|Name=Top SilkScreen|PadNumberFontSize=14|Record=PcbPrintOut|ShowHoles=False|ShowPadNets=False|ShowPadNumbers=False|SubstituteFonts=False +Configuration_Name6=OutputConfigurationParameter6 +Configuration_Item6=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=TopOverlay|Polygon=Full|PrintOutIndex=1|Record=PcbPrintLayer +Configuration_Name7=OutputConfigurationParameter7 +Configuration_Item7=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical16|Polygon=Full|PrintOutIndex=1|Record=PcbPrintLayer +Configuration_Name8=OutputConfigurationParameter8 +Configuration_Item8=IncludeBottomLayerComponents=False|IncludeMultiLayerComponents=False|IncludeTopLayerComponents=False|Index=2|Mirror=False|Name=Top Copper|PadNumberFontSize=14|Record=PcbPrintOut|ShowHoles=False|ShowPadNets=False|ShowPadNumbers=False|SubstituteFonts=False +Configuration_Name9=OutputConfigurationParameter9 +Configuration_Item9=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=TopLayer|Polygon=Full|PrintOutIndex=2|Record=PcbPrintLayer +Configuration_Name10=OutputConfigurationParameter10 +Configuration_Item10=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical16|Polygon=Full|PrintOutIndex=2|Record=PcbPrintLayer +Configuration_Name11=OutputConfigurationParameter11 +Configuration_Item11=IncludeBottomLayerComponents=False|IncludeMultiLayerComponents=False|IncludeTopLayerComponents=False|Index=3|Mirror=False|Name=Groud Copper|PadNumberFontSize=14|Record=PcbPrintOut|ShowHoles=False|ShowPadNets=False|ShowPadNumbers=False|SubstituteFonts=False +Configuration_Name12=OutputConfigurationParameter12 +Configuration_Item12=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=MidLayer1|Polygon=Full|PrintOutIndex=3|Record=PcbPrintLayer +Configuration_Name13=OutputConfigurationParameter13 +Configuration_Item13=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical16|Polygon=Full|PrintOutIndex=3|Record=PcbPrintLayer +Configuration_Name14=OutputConfigurationParameter14 +Configuration_Item14=IncludeBottomLayerComponents=False|IncludeMultiLayerComponents=False|IncludeTopLayerComponents=False|Index=4|Mirror=False|Name=Power Layer|PadNumberFontSize=14|Record=PcbPrintOut|ShowHoles=False|ShowPadNets=False|ShowPadNumbers=False|SubstituteFonts=False +Configuration_Name15=OutputConfigurationParameter15 +Configuration_Item15=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=MidLayer2|Polygon=Full|PrintOutIndex=4|Record=PcbPrintLayer +Configuration_Name16=OutputConfigurationParameter16 +Configuration_Item16=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical16|Polygon=Full|PrintOutIndex=4|Record=PcbPrintLayer +Configuration_Name17=OutputConfigurationParameter17 +Configuration_Item17=IncludeBottomLayerComponents=False|IncludeMultiLayerComponents=False|IncludeTopLayerComponents=False|Index=5|Mirror=False|Name=Bottom Copper|PadNumberFontSize=14|Record=PcbPrintOut|ShowHoles=False|ShowPadNets=False|ShowPadNumbers=False|SubstituteFonts=False +Configuration_Name18=OutputConfigurationParameter18 +Configuration_Item18=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=BottomLayer|Polygon=Full|PrintOutIndex=5|Record=PcbPrintLayer +Configuration_Name19=OutputConfigurationParameter19 +Configuration_Item19=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical16|Polygon=Full|PrintOutIndex=5|Record=PcbPrintLayer +Configuration_Name20=OutputConfigurationParameter20 +Configuration_Item20=IncludeBottomLayerComponents=False|IncludeMultiLayerComponents=False|IncludeTopLayerComponents=False|Index=6|Mirror=False|Name=Bottom Silk Screen|PadNumberFontSize=14|Record=PcbPrintOut|ShowHoles=False|ShowPadNets=False|ShowPadNumbers=False|SubstituteFonts=False +Configuration_Name21=OutputConfigurationParameter21 +Configuration_Item21=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=BottomOverlay|Polygon=Full|PrintOutIndex=6|Record=PcbPrintLayer +Configuration_Name22=OutputConfigurationParameter22 +Configuration_Item22=CArc=Full|CFill=Full|Comment=Full|Coordinate=Full|CPad=Full|CRegion=Full|CText=Full|CTrack=Full|CVia=Full|DDSymbolKind=0|DDSymbolSize=500000|DDSymbolSortKind=0|Designator=Full|Dimension=Full|DLayer1=TopLayer|DLayer2=BottomLayer|FArc=Full|FFill=Full|FPad=Full|FRegion=Full|FText=Full|FTrack=Full|FVia=Full|Layer=Mechanical16|Polygon=Full|PrintOutIndex=6|Record=PcbPrintLayer + diff --git a/hardware/Production/OpenPilot Atom/OpenPilot Atom.SchDoc b/hardware/Production/OpenPilot Atom/OpenPilot Atom.SchDoc new file mode 100644 index 000000000..cf8671134 Binary files /dev/null and b/hardware/Production/OpenPilot Atom/OpenPilot Atom.SchDoc differ diff --git a/make/firmware-defs.mk b/make/firmware-defs.mk index 7bbe20c9b..5f1ed36ee 100644 --- a/make/firmware-defs.mk +++ b/make/firmware-defs.mk @@ -72,7 +72,7 @@ MSG_FLASH_IMG = $(QUOTE) FLASH_IMG $(MSG_EXTRA) $(QUOTE) toprel = $(subst $(realpath $(ROOT_DIR))/,,$(abspath $(1))) # Function to replace special characters like is done for the symbols. -replace_special_chars = $(subst ~,_,$(subst @,_,$(subst :,_,$(subst -,_,$(subst .,_,$(subst /,_,$1)))))) +replace_special_chars = $(subst +,_,$(subst ~,_,$(subst @,_,$(subst :,_,$(subst -,_,$(subst .,_,$(subst /,_,$1))))))) # Display compiler version information. .PHONY: gccversion diff --git a/make/scripts/version-info.py b/make/scripts/version-info.py index 889925700..38b8401db 100644 --- a/make/scripts/version-info.py +++ b/make/scripts/version-info.py @@ -68,12 +68,15 @@ class Repo: if self._rc == 0: self._time = self._out - def _get_tag(self): + def _get_last_tag(self): """Get and store git tag for the HEAD commit""" - self._tag = None - self._exec('describe --tags --exact-match HEAD') + self._last_tag = None + self._num_commits_past_tag = None + self._exec('describe --tags --long') if self._rc == 0: - self._tag = self._out.strip(' \t\n\r') + descriptions = self._out.rsplit('-', 2) + self._last_tag = descriptions[-3] + self._num_commits_past_tag = descriptions[-2] def _get_branch(self): """Get and store current branch containing the HEAD commit""" @@ -102,7 +105,8 @@ class Repo: self._hash = json_data['hash'] self._origin = json_data['origin'] self._time = json_data['time'] - self._tag = json_data['tag'] + self._last_tag = json_data['last_tag'] + self._num_commits_past_tag = json_data['num_commits_past_tag'] self._branch = json_data['branch'] self._dirty = json_data['dirty'] @@ -119,14 +123,15 @@ class Repo: self._hash = self._out.strip(' \t\n\r') self._get_origin() self._get_time() - self._get_tag() + self._get_last_tag() self._get_branch() self._get_dirty() else: self._hash = None self._origin = None self._time = None - self._tag = None + self._last_tag = None + self._num_commits_past_tag = None self._branch = None self._dirty = None @@ -160,10 +165,10 @@ class Repo: def tag(self, none = None): """Return git tag for the HEAD commit or given string if none""" - if self._tag == None: + if self._last_tag == None or self._num_commits_past_tag != 0: return none else: - return self._tag + return self._last_tag def branch(self, none = None): """Return git branch containing the HEAD or given string if none""" @@ -180,22 +185,22 @@ class Repo: return clean def label(self): - """Return package label (tag if defined, or date-hash if no tag)""" + """Return package label (similar to git describe)""" try: - if self._tag == None: - return ''.join([self.time('%Y%m%d'), "-", self.hash(8, 'untagged'), self.dirty()]) + if self._num_commits_past_tag == 0: + return self._last_tag + self.dirty() else: - return ''.join([self.tag(''), self.dirty()]) + return self._last_tag + "+r" + self._num_commits_past_tag + "-g" + self.hash(7, '') + self.dirty() except: return None def revision(self): """Return full revison string (tag if defined, or branch:hash date time if no tag)""" try: - if self._tag == None: - return ''.join([self.branch('no-branch'), ":", self.hash(8, 'no-hash'), self.dirty(), self.time(' %Y%m%d %H:%M')]) + if self._num_commits_past_tag == 0: + return self.tag('') + self.dirty() else: - return ''.join([self.tag(''), self.dirty()]) + return self.branch('no-branch') + ":" + self.hash(8, 'no-hash') + self.dirty() + self.time(' %Y%m%d %H:%M') except: return None @@ -220,9 +225,11 @@ class Repo: json_data['hash'] = self._hash json_data['origin'] = self._origin json_data['time'] = self._time - json_data['tag'] = self._tag + json_data['last_tag'] = self._last_tag + json_data['num_commits_past_tag'] = self._num_commits_past_tag json_data['branch'] = self._branch - json_data['dirty'] = self._dirty + # version-info.json is for use with git archive which doesn't take in dirty changes + json_data['dirty'] = False json_path = os.path.join(path, 'version-info.json') with open(json_path, 'w') as json_file: diff --git a/make/scripts/win_sdk_install.sh b/make/scripts/win_sdk_install.sh index af9c3d3c0..4d22db453 100644 --- a/make/scripts/win_sdk_install.sh +++ b/make/scripts/win_sdk_install.sh @@ -87,7 +87,7 @@ if [ ! -x "$MAKE" ]; then echo "$SCRIPT_NAME: $MAKE_NAME not found, fetching from $MAKE_URL" MAKE_DIR="`dirname \"$MAKE\"`" mkdir -p "$MAKE_DIR" - $WGET -N --content-disposition -P "$MAKE_DIR" "$MAKE_URL" + $WGET --no-check-certificate -N --content-disposition -P "$MAKE_DIR" "$MAKE_URL" if [ $? -ne 0 ]; then echo "$SCRIPT_NAME: $MAKE_NAME fetch error, hope it's in the path..." MAKE_NAME="`basename \"$MAKE\"`" @@ -100,7 +100,7 @@ if [ ! -x "$SEVENZIP" ]; then echo "$SCRIPT_NAME: $SEVENZIP_NAME not found, fetching from $SEVENZIP_URL" SEVENZIP_DIR="`dirname \"$SEVENZIP\"`" mkdir -p "$SEVENZIP_DIR" - $WGET -N --content-disposition -P "$SEVENZIP_DIR" "$SEVENZIP_URL" + $WGET --no-check-certificate -N --content-disposition -P "$SEVENZIP_DIR" "$SEVENZIP_URL" if [ $? -ne 0 ]; then echo "$SCRIPT_NAME: $SEVENZIP_NAME fetch error, hope it's in the path..." SEVENZIP_NAME="`basename \"$SEVENZIP\"`" diff --git a/package/Linux.mk b/package/Linux.mk index 458b31f77..456173131 100644 --- a/package/Linux.mk +++ b/package/Linux.mk @@ -6,26 +6,72 @@ ifndef OPENPILOT_IS_COOL $(error Top level Makefile must be used to build this target) endif -DEB_VER := $(subst RELEASE-,,$(PACKAGE_LBL))-1 -DEB_DIR := $(ROOT_DIR)/package/linux/debian -DEB_BUILD_DIR := $(ROOT_DIR)/debian +# Are we using a debian based distro? +ifneq ($(shell which dpkg 2> /dev/null),) -SED_DATE_STRG = $(shell date -R) -SED_SCRIPT = s//$(DEB_VER)/;s//$(SED_DATE_STRG)/ +DEB_DIST := unstable +# Instead of RELEASE-15.01-RC1 debian wants 15.01~RC1 +UPSTREAM_VER := $(subst -,~,$(subst RELEASE-,,$(PACKAGE_LBL))) +DEB_REV := 1 +ifeq ($(DEB_DIST), trusty) +DEB_REV := $(DEB_REV)$(DEB_DIST)1 +endif +DEB_NAME := openpilot +DEB_ORIG_SRC := $(PACKAGE_DIR)/$(DEB_NAME)_$(UPSTREAM_VER).orig.tar.gz +DEB_PACKAGE_DIR := $(PACKAGE_DIR)/$(DEB_NAME)-$(UPSTREAM_VER) +DEB_ARCH := $(shell dpkg --print-architecture) +DEB_PACKAGE_NAME := $(DEB_NAME)_$(UPSTREAM_VER)-$(DEB_REV)_$(DEB_ARCH) +DEB_DIR := package/linux/debian -DEB_ARCH := $(shell dpkg --print-architecture) -DEB_PACKAGE_NAME := openpilot_$(DEB_VER)_$(DEB_ARCH) +SED_DATE_STRG = $(shell date -R) +SED_SCRIPT = s//$(UPSTREAM_VER)-$(DEB_REV)/;s//$(SED_DATE_STRG)/;s//$(DEB_DIST)/ + +# Ubuntu 14.04 (Trusty Tahr) has different names for the qml-modules +TRUSTY_DEPS_SED := s/qml-module-qtquick-controls/qtdeclarative5-controls-plugin/g; \ + s/qml-module-qtquick-dialogs/qtdeclarative5-dialogs-plugin/g; \ + s/qml-module-qtquick-localstorage/qtdeclarative5-localstorage-plugin/g; \ + s/qml-module-qtquick-particles2/qtdeclarative5-particles-plugin/g; \ + s/qml-module-qtquick2/qtdeclarative5-qtquick2-plugin/g; \ + s/qml-module-qtquick-window2/qtdeclarative5-window-plugin/g; \ + s/qml-module-qtquick-xmllistmodel/qtdeclarative5-xmllistmodel-plugin/g; + +# Leave off Qt and ARM compiler dependencies if calling package target under the assumption that +# OP is providing them or the user already has them installed because OP is already built. +PACKAGE_DEPS_SED := s/python.*/python/;s/{misc:Depends}.*/{misc:Depends}/; .PHONY: package -package: - $(V1) echo "Building Linux package, please wait..." - $(V1) cp -rL $(DEB_DIR) $(DEB_BUILD_DIR) - $(V1) sed -i -e "$(SED_SCRIPT)" $(DEB_BUILD_DIR)/changelog +package: debian + @$(ECHO) "Building Linux package, please wait..." + # Override clean and build because OP has already performed them. + $(V1) printf "override_dh_auto_clean:\noverride_dh_auto_build:\n\t#\n" >> debian/rules + $(V1) sed -i -e "$(PACKAGE_DEPS_SED)" debian/control $(V1) dpkg-buildpackage -b -us -uc - $(V1) mv $(ROOT_DIR)/../$(DEB_PACKAGE_NAME).deb $(BUILD_DIR)/$(DEB_PACKAGE_NAME).deb - $(V1) mv $(ROOT_DIR)/../$(DEB_PACKAGE_NAME).changes $(BUILD_DIR)/$(DEB_PACKAGE_NAME).changes - $(V1) rm -rf $(DEB_BUILD_DIR) + $(V1) mv $(ROOT_DIR)/../$(DEB_PACKAGE_NAME).deb $(PACKAGE_DIR) + $(V1) mv $(ROOT_DIR)/../$(DEB_PACKAGE_NAME).changes $(PACKAGE_DIR) + $(V1) rm -r debian +.PHONY: debian +debian: $(DEB_DIR) + $(V1) rm -rf debian + $(V1) cp -rL $(DEB_DIR) debian + $(V1) sed -i -e "$(SED_SCRIPT)" debian/changelog +ifeq ($(DEB_DIST), trusty) + $(V1) sed -i -e "$(TRUSTY_DEPS_SED)" debian/control +endif + +.PHONY: package_src +package_src: $(DEB_ORIG_SRC_NAME) $(DEB_PACKAGE_DIR) + $(V1) cd $(DEB_PACKAGE_DIR) && dpkg-buildpackage -S -us -uc + +$(DEB_ORIG_SRC): $(DIST_NAME).gz | $(PACKAGE_DIR) + $(V1) cp $(DIST_NAME).gz $(DEB_ORIG_SRC) + +$(DEB_PACKAGE_DIR): $(DEB_ORIG_SRC) debian | $(PACKAGE_DIR) + $(V1) tar -xf $(DEB_ORIG_SRC) -C $(PACKAGE_DIR) + $(V1) mv debian $(PACKAGE_DIR)/$(PACKAGE_NAME) + $(V1) rm -rf $(DEB_PACKAGE_DIR) && mv $(PACKAGE_DIR)/$(PACKAGE_NAME) $(DEB_PACKAGE_DIR) + +endif # Debian based distro? ############################## # # Install OpenPilot diff --git a/package/linux/debian/changelog b/package/linux/debian/changelog index 9c205bb68..fe2d82497 100644 --- a/package/linux/debian/changelog +++ b/package/linux/debian/changelog @@ -1,4 +1,4 @@ -openpilot () unstable; urgency=low +openpilot () ; urgency=low * Release from upstream Git (testing - unstable) diff --git a/package/linux/debian/control b/package/linux/debian/control index 3ac0c681a..db02e54a7 100644 --- a/package/linux/debian/control +++ b/package/linux/debian/control @@ -1,15 +1,15 @@ Source: openpilot -Section: unknown +Section: electronics Priority: optional Maintainer: James Duley -Build-Depends: debhelper (>= 8.0.0) -Standards-Version: 3.9.4 +Build-Depends: debhelper (>= 9), libudev-dev, libusb-1.0-0-dev, libsdl1.2-dev, python, gcc-arm-none-eabi (>=4.9), qt5-default, qttools5-dev-tools, libqt5svg5-dev, qtdeclarative5-dev, qml-module-qtquick-controls, libqt5serialport5-dev, qtmultimedia5-dev, qtscript5-dev, libqt5opengl5-dev +Standards-Version: 3.9.5 Homepage: http://www.openpilot.org Vcs-Git: git://git.openpilot.org/OpenPilot.git Vcs-Browser: http://git.openpilot.org/changelog/OpenPilot Package: openpilot Architecture: any -Depends: ${shlibs:Depends}, ${misc:Depends} +Depends: ${shlibs:Depends}, ${misc:Depends}, qml-module-qtquick-controls, qml-module-qtquick-dialogs, qml-module-qtquick-xmllistmodel, qml-module-qtquick-localstorage, qml-module-qtquick-particles2, qml-module-qtquick-window2, qml-module-qtquick2 Description: OpenPilot GCS OpenPilot Ground Control Station software diff --git a/package/linux/debian/rules b/package/linux/debian/rules old mode 100644 new mode 100755 index b67ae85e6..1c0a922f0 --- a/package/linux/debian/rules +++ b/package/linux/debian/rules @@ -11,15 +11,8 @@ export DH_OPTIONS %: dh $@ -# Disabled because OpenPilot makefile cleans and builds. -override_dh_auto_clean: - # - override_dh_auto_build: - #dh_auto_build -- all - -override_dh_auto_test: - # Fails non-silently because it is run under fakeroot. + dh_auto_build -- all override_dh_auto_install: dh_auto_install -- prefix=/usr diff --git a/package/linux/debian/source/format b/package/linux/debian/source/format new file mode 100644 index 000000000..163aaf8d8 --- /dev/null +++ b/package/linux/debian/source/format @@ -0,0 +1 @@ +3.0 (quilt) diff --git a/shared/uavobjectdefinition/systemalarms.xml b/shared/uavobjectdefinition/systemalarms.xml index c242e133c..ba4cd24de 100644 --- a/shared/uavobjectdefinition/systemalarms.xml +++ b/shared/uavobjectdefinition/systemalarms.xml @@ -36,6 +36,7 @@ + diff --git a/shared/uavobjectdefinition/vtolpathfollowersettings.xml b/shared/uavobjectdefinition/vtolpathfollowersettings.xml index ec698b810..67f643473 100644 --- a/shared/uavobjectdefinition/vtolpathfollowersettings.xml +++ b/shared/uavobjectdefinition/vtolpathfollowersettings.xml @@ -1,7 +1,7 @@ Settings for the @ref VtolPathFollowerModule - +