Пример #1
0
void VtolPathFollowerSettingsVerticalVelPIDSet( float *NewVerticalVelPID )
{
	UAVObjSetDataField(VtolPathFollowerSettingsHandle(), (void*)NewVerticalVelPID, offsetof( VtolPathFollowerSettingsData, VerticalVelPID), 4*sizeof(float));
}
void VtolPathFollowerSettingsThrottleControlGet( uint8_t *NewThrottleControl )
{
    UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewThrottleControl, offsetof( VtolPathFollowerSettingsData, ThrottleControl), sizeof(uint8_t));
}
void VtolPathFollowerSettingsYawModeGet( uint8_t *NewYawMode )
{
    UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewYawMode, offsetof( VtolPathFollowerSettingsData, YawMode), sizeof(uint8_t));
}
void VtolPathFollowerSettingsLoiterAttitudeFeedthroughGet( float *NewLoiterAttitudeFeedthrough )
{
    UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewLoiterAttitudeFeedthrough, offsetof( VtolPathFollowerSettingsData, LoiterAttitudeFeedthrough), sizeof(float));
}
void VtolPathFollowerSettingsHorizontalVelMaxSet( uint16_t *NewHorizontalVelMax )
{
    UAVObjSetDataField(VtolPathFollowerSettingsHandle(), (void*)NewHorizontalVelMax, offsetof( VtolPathFollowerSettingsData, HorizontalVelMax), sizeof(uint16_t));
}
void VtolPathFollowerSettingsLandingRateGet( float *NewLandingRate )
{
    UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewLandingRate, offsetof( VtolPathFollowerSettingsData, LandingRate), sizeof(float));
}
void VtolPathFollowerSettingsLoiterLookaheadTimeConstantGet( float *NewLoiterLookaheadTimeConstant )
{
    UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewLoiterLookaheadTimeConstant, offsetof( VtolPathFollowerSettingsData, LoiterLookaheadTimeConstant), sizeof(float));
}
void VtolPathFollowerSettingsHorizontalVelPIDGet( float *NewHorizontalVelPID )
{
    UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewHorizontalVelPID, offsetof( VtolPathFollowerSettingsData, HorizontalVelPID), 4*sizeof(float));
}
void VtolPathFollowerSettingsVelocityFeedforwardSet( float *NewVelocityFeedforward )
{
    UAVObjSetDataField(VtolPathFollowerSettingsHandle(), (void*)NewVelocityFeedforward, offsetof( VtolPathFollowerSettingsData, VelocityFeedforward), sizeof(float));
}
Пример #10
0
/**
 * Initialise the module, called on startup
 * \returns 0 on success or -1 if initialisation failed
 */
int32_t TxPIDInitialize(void)
{
	bool module_enabled;

#ifdef MODULE_TxPID_BUILTIN
	module_enabled = true;
#else
	uint8_t module_state[MODULESETTINGS_ADMINSTATE_NUMELEM];
	ModuleSettingsAdminStateGet(module_state);
	if (module_state[MODULESETTINGS_ADMINSTATE_TXPID] == MODULESETTINGS_ADMINSTATE_ENABLED) {
		module_enabled = true;
	} else {
		module_enabled = false;
	}
#endif

	if (module_enabled) {

		TxPIDSettingsInitialize();
		AccessoryDesiredInitialize();

		UAVObjEvent ev = {
			.obj = AccessoryDesiredHandle(),
			.instId = 0,
			.event = 0,
		};
		EventPeriodicCallbackCreate(&ev, updatePIDs, SAMPLE_PERIOD_MS);

#if (TELEMETRY_UPDATE_PERIOD_MS != 0)
		// Change StabilizationSettings update rate from OnChange to periodic
		// to prevent telemetry link flooding with frequent updates in case of
		// control channel jitter.
		// Warning: saving to flash with this code active will change the
		// StabilizationSettings update rate permanently. Use Metadata via
		// browser to reset to defaults (telemetryAcked=true, OnChange).
		UAVObjMetadata metadata;
		StabilizationSettingsInitialize();
		StabilizationSettingsGetMetadata(&metadata);
		metadata.telemetryAcked = 0;
		metadata.telemetryUpdateMode = UPDATEMODE_PERIODIC;
		metadata.telemetryUpdatePeriod = TELEMETRY_UPDATE_PERIOD_MS;
		StabilizationSettingsSetMetadata(&metadata);
#endif

		return 0;
	}

	return -1;
}

MODULE_INITCALL(TxPIDInitialize, NULL);

/**
 * Update PIDs callback function
 */
static void updatePIDs(UAVObjEvent* ev)
{
	if (ev->obj != AccessoryDesiredHandle())
		return;

	TxPIDSettingsData inst;
	TxPIDSettingsGet(&inst);

	if (inst.UpdateMode == TXPIDSETTINGS_UPDATEMODE_NEVER)
		return;

	uint8_t armed;
	FlightStatusArmedGet(&armed);
	if ((inst.UpdateMode == TXPIDSETTINGS_UPDATEMODE_WHENARMED) &&
			(armed == FLIGHTSTATUS_ARMED_DISARMED))
		return;

	StabilizationSettingsData stab;
	StabilizationSettingsGet(&stab);

#ifdef UAVOBJ_INIT_vtolpathfollowersettings
	VtolPathFollowerSettingsData vtolPathFollowerSettingsData;
	// Check to make sure the settings UAVObject has been instantiated
	if (VtolPathFollowerSettingsHandle()) {
		VtolPathFollowerSettingsGet(&vtolPathFollowerSettingsData);
	}

	bool vtolPathFollowerSettingsNeedsUpdate = false;
#endif

	AccessoryDesiredData accessory;

	bool stabilizationSettingsNeedsUpdate = false;

	// Loop through every enabled instance
	for (uint8_t i = 0; i < TXPIDSETTINGS_PIDS_NUMELEM; i++) {
		if (inst.PIDs[i] != TXPIDSETTINGS_PIDS_DISABLED) {

			float value;
			if (inst.Inputs[i] == TXPIDSETTINGS_INPUTS_THROTTLE) {
				ManualControlCommandThrottleGet(&value);
				value = scale(value,
						inst.ThrottleRange[TXPIDSETTINGS_THROTTLERANGE_MIN],
						inst.ThrottleRange[TXPIDSETTINGS_THROTTLERANGE_MAX],
						inst.MinPID[i], inst.MaxPID[i]);
			} else if (AccessoryDesiredInstGet(inst.Inputs[i] - TXPIDSETTINGS_INPUTS_ACCESSORY0, &accessory) == 0) {
				value = scale(accessory.AccessoryVal, -1.0, 1.0, inst.MinPID[i], inst.MaxPID[i]);
			} else {
				continue;
			}

			switch (inst.PIDs[i]) {
			case TXPIDSETTINGS_PIDS_ROLLRATEKP:
				stabilizationSettingsNeedsUpdate |= update(&stab.RollRatePID[STABILIZATIONSETTINGS_ROLLRATEPID_KP], value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLRATEKI:
				stabilizationSettingsNeedsUpdate |= update(&stab.RollRatePID[STABILIZATIONSETTINGS_ROLLRATEPID_KI], value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLRATEKD:
				stabilizationSettingsNeedsUpdate |= update(&stab.RollRatePID[STABILIZATIONSETTINGS_ROLLRATEPID_KD], value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLRATEILIMIT:
				stabilizationSettingsNeedsUpdate |= update(&stab.RollRatePID[STABILIZATIONSETTINGS_ROLLRATEPID_ILIMIT], value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLATTITUDEKP:
				stabilizationSettingsNeedsUpdate |= update(&stab.RollPI[STABILIZATIONSETTINGS_ROLLPI_KP], value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLATTITUDEKI:
				stabilizationSettingsNeedsUpdate |= update(&stab.RollPI[STABILIZATIONSETTINGS_ROLLPI_KI], value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLATTITUDEILIMIT:
				stabilizationSettingsNeedsUpdate |= update(&stab.RollPI[STABILIZATIONSETTINGS_ROLLPI_ILIMIT], value);
				break;
			case TXPIDSETTINGS_PIDS_PITCHRATEKP:
				stabilizationSettingsNeedsUpdate |= update(&stab.PitchRatePID[STABILIZATIONSETTINGS_PITCHRATEPID_KP], value);
				break;
			case TXPIDSETTINGS_PIDS_PITCHRATEKI:
				stabilizationSettingsNeedsUpdate |= update(&stab.PitchRatePID[STABILIZATIONSETTINGS_PITCHRATEPID_KI], value);
				break;
			case TXPIDSETTINGS_PIDS_PITCHRATEKD:
				stabilizationSettingsNeedsUpdate |= update(&stab.PitchRatePID[STABILIZATIONSETTINGS_PITCHRATEPID_KD], value);
				break;
			case TXPIDSETTINGS_PIDS_PITCHRATEILIMIT:
				stabilizationSettingsNeedsUpdate |= update(&stab.PitchRatePID[STABILIZATIONSETTINGS_PITCHRATEPID_ILIMIT], value);
				break;
			case TXPIDSETTINGS_PIDS_PITCHATTITUDEKP:
				stabilizationSettingsNeedsUpdate |= update(&stab.PitchPI[STABILIZATIONSETTINGS_PITCHPI_KP], value);
				break;
			case TXPIDSETTINGS_PIDS_PITCHATTITUDEKI:
				stabilizationSettingsNeedsUpdate |= update(&stab.PitchPI[STABILIZATIONSETTINGS_PITCHPI_KI], value);
				break;
			case TXPIDSETTINGS_PIDS_PITCHATTITUDEILIMIT:
				stabilizationSettingsNeedsUpdate |= update(&stab.PitchPI[STABILIZATIONSETTINGS_PITCHPI_ILIMIT], value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLPITCHRATEKP:
				stabilizationSettingsNeedsUpdate |= update(&stab.RollRatePID[STABILIZATIONSETTINGS_ROLLRATEPID_KP], value);
				stabilizationSettingsNeedsUpdate |= update(&stab.PitchRatePID[STABILIZATIONSETTINGS_PITCHRATEPID_KP], value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLPITCHRATEKI:
				stabilizationSettingsNeedsUpdate |= update(&stab.RollRatePID[STABILIZATIONSETTINGS_ROLLRATEPID_KI], value);
				stabilizationSettingsNeedsUpdate |= update(&stab.PitchRatePID[STABILIZATIONSETTINGS_PITCHRATEPID_KI], value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLPITCHRATEKD:
				stabilizationSettingsNeedsUpdate |= update(&stab.RollRatePID[STABILIZATIONSETTINGS_ROLLRATEPID_KD], value);
				stabilizationSettingsNeedsUpdate |= update(&stab.PitchRatePID[STABILIZATIONSETTINGS_PITCHRATEPID_KD], value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLPITCHRATEILIMIT:
				stabilizationSettingsNeedsUpdate |= update(&stab.RollRatePID[STABILIZATIONSETTINGS_ROLLRATEPID_ILIMIT], value);
				stabilizationSettingsNeedsUpdate |= update(&stab.PitchRatePID[STABILIZATIONSETTINGS_PITCHRATEPID_ILIMIT], value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLPITCHATTITUDEKP:
				stabilizationSettingsNeedsUpdate |= update(&stab.RollPI[STABILIZATIONSETTINGS_ROLLPI_KP], value);
				stabilizationSettingsNeedsUpdate |= update(&stab.PitchPI[STABILIZATIONSETTINGS_PITCHPI_KP], value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLPITCHATTITUDEKI:
				stabilizationSettingsNeedsUpdate |= update(&stab.RollPI[STABILIZATIONSETTINGS_ROLLPI_KI], value);
				stabilizationSettingsNeedsUpdate |= update(&stab.PitchPI[STABILIZATIONSETTINGS_PITCHPI_KI], value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLPITCHATTITUDEILIMIT:
				stabilizationSettingsNeedsUpdate |= update(&stab.RollPI[STABILIZATIONSETTINGS_ROLLPI_ILIMIT], value);
				stabilizationSettingsNeedsUpdate |= update(&stab.PitchPI[STABILIZATIONSETTINGS_PITCHPI_ILIMIT], value);
				break;
			case TXPIDSETTINGS_PIDS_YAWRATEKP:
				stabilizationSettingsNeedsUpdate |= update(&stab.YawRatePID[STABILIZATIONSETTINGS_YAWRATEPID_KP], value);
				break;
			case TXPIDSETTINGS_PIDS_YAWRATEKI:
				stabilizationSettingsNeedsUpdate |= update(&stab.YawRatePID[STABILIZATIONSETTINGS_YAWRATEPID_KI], value);
				break;
			case TXPIDSETTINGS_PIDS_YAWRATEKD:
				stabilizationSettingsNeedsUpdate |= update(&stab.YawRatePID[STABILIZATIONSETTINGS_YAWRATEPID_KD], value);
				break;
			case TXPIDSETTINGS_PIDS_YAWRATEILIMIT:
				stabilizationSettingsNeedsUpdate |= update(&stab.YawRatePID[STABILIZATIONSETTINGS_YAWRATEPID_ILIMIT], value);
				break;
			case TXPIDSETTINGS_PIDS_YAWATTITUDEKP:
				stabilizationSettingsNeedsUpdate |= update(&stab.YawPI[STABILIZATIONSETTINGS_YAWPI_KP], value);
				break;
			case TXPIDSETTINGS_PIDS_YAWATTITUDEKI:
				stabilizationSettingsNeedsUpdate |= update(&stab.YawPI[STABILIZATIONSETTINGS_YAWPI_KI], value);
				break;
			case TXPIDSETTINGS_PIDS_YAWATTITUDEILIMIT:
				stabilizationSettingsNeedsUpdate |= update(&stab.YawPI[STABILIZATIONSETTINGS_YAWPI_ILIMIT], value);
				break;
			case TXPIDSETTINGS_PIDS_GYROCUTOFF:
				stabilizationSettingsNeedsUpdate |= update(&stab.GyroCutoff, value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLVBARSENSITIVITY:
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarSensitivity[STABILIZATIONSETTINGS_VBARSENSITIVITY_ROLL], value);
				break;
			case TXPIDSETTINGS_PIDS_PITCHVBARSENSITIVITY:
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarSensitivity[STABILIZATIONSETTINGS_VBARSENSITIVITY_PITCH], value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLPITCHVBARSENSITIVITY:
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarSensitivity[STABILIZATIONSETTINGS_VBARSENSITIVITY_ROLL], value);
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarSensitivity[STABILIZATIONSETTINGS_VBARSENSITIVITY_PITCH], value);
				break;
			
			case TXPIDSETTINGS_PIDS_YAWVBARSENSITIVITY:
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarSensitivity[STABILIZATIONSETTINGS_VBARSENSITIVITY_YAW], value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLVBARKP:
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarRollPID[STABILIZATIONSETTINGS_VBARROLLPID_KP], value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLVBARKI:
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarRollPID[STABILIZATIONSETTINGS_VBARROLLPID_KI], value);
				break;	
			case TXPIDSETTINGS_PIDS_ROLLVBARKD:
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarRollPID[STABILIZATIONSETTINGS_VBARROLLPID_KD], value);
				break;
			case TXPIDSETTINGS_PIDS_PITCHVBARKP:
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarPitchPID[STABILIZATIONSETTINGS_VBARPITCHPID_KP], value);
				break;
			case TXPIDSETTINGS_PIDS_PITCHVBARKI:
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarPitchPID[STABILIZATIONSETTINGS_VBARPITCHPID_KI], value);
				break;
			case TXPIDSETTINGS_PIDS_PITCHVBARKD:
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarPitchPID[STABILIZATIONSETTINGS_VBARPITCHPID_KD], value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLPITCHVBARKP:
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarRollPID[STABILIZATIONSETTINGS_VBARROLLPID_KP], value);
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarPitchPID[STABILIZATIONSETTINGS_VBARPITCHPID_KP], value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLPITCHVBARKI:
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarRollPID[STABILIZATIONSETTINGS_VBARROLLPID_KI], value);
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarPitchPID[STABILIZATIONSETTINGS_VBARPITCHPID_KI], value);
				break;
			case TXPIDSETTINGS_PIDS_ROLLPITCHVBARKD:
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarRollPID[STABILIZATIONSETTINGS_VBARROLLPID_KD], value);
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarPitchPID[STABILIZATIONSETTINGS_VBARPITCHPID_KD], value);
				break;
			case TXPIDSETTINGS_PIDS_YAWVBARKP:
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarYawPID[STABILIZATIONSETTINGS_VBARYAWPID_KP], value);
				break;
			case TXPIDSETTINGS_PIDS_YAWVBARKI:
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarYawPID[STABILIZATIONSETTINGS_VBARYAWPID_KI], value);
				break;
			case TXPIDSETTINGS_PIDS_YAWVBARKD:
				stabilizationSettingsNeedsUpdate |= update(&stab.VbarYawPID[STABILIZATIONSETTINGS_VBARYAWPID_KD], value);
				break;
#ifdef UAVOBJ_INIT_vtolpathfollowersettings
			case TXPIDSETTINGS_PIDS_HORIZONTALPOSKP:
				vtolPathFollowerSettingsNeedsUpdate |= update(&vtolPathFollowerSettingsData.HorizontalPosPI[VTOLPATHFOLLOWERSETTINGS_HORIZONTALPOSPI_KP], value);
				break;
			case TXPIDSETTINGS_PIDS_HORIZONTALPOSKI:
				vtolPathFollowerSettingsNeedsUpdate |= update(&vtolPathFollowerSettingsData.HorizontalPosPI[VTOLPATHFOLLOWERSETTINGS_HORIZONTALPOSPI_KI], value);
				break;
			case TXPIDSETTINGS_PIDS_HORIZONTALPOSILIMIT:
				vtolPathFollowerSettingsNeedsUpdate |= update(&vtolPathFollowerSettingsData.HorizontalPosPI[VTOLPATHFOLLOWERSETTINGS_HORIZONTALPOSPI_ILIMIT], value);
				break;
			case TXPIDSETTINGS_PIDS_HORIZONTALVELKP:
				vtolPathFollowerSettingsNeedsUpdate |= update(&vtolPathFollowerSettingsData.HorizontalVelPID[VTOLPATHFOLLOWERSETTINGS_HORIZONTALVELPID_KP], value);
				break;
			case TXPIDSETTINGS_PIDS_HORIZONTALVELKI:
				vtolPathFollowerSettingsNeedsUpdate |= update(&vtolPathFollowerSettingsData.HorizontalVelPID[VTOLPATHFOLLOWERSETTINGS_HORIZONTALVELPID_KI], value);
				break;
			case TXPIDSETTINGS_PIDS_HORIZONTALVELKD:
				vtolPathFollowerSettingsNeedsUpdate |= update(&vtolPathFollowerSettingsData.HorizontalVelPID[VTOLPATHFOLLOWERSETTINGS_HORIZONTALVELPID_KD], value);
				break;
#endif /* UAVOBJ_INIT_vtolpathfollowersettings */
			default:
				// Previously this would assert.  But now the
				// object may be missing and it's not worth a
				// crash.
				break;
			}
		}
	}

	// Update UAVOs, if necessary
	if (stabilizationSettingsNeedsUpdate) {
		StabilizationSettingsSet(&stab);
	}

#ifdef UAVOBJ_INIT_vtolpathfollowersettings
	if (vtolPathFollowerSettingsNeedsUpdate) {
		// Check to make sure the settings UAVObject has been instantiated
		if (VtolPathFollowerSettingsHandle()) {
			VtolPathFollowerSettingsSet(&vtolPathFollowerSettingsData);
		}
	}
#endif
}

/**
 * Scales input val from [inMin..inMax] range to [outMin..outMax].
 * If val is out of input range (inMin <= inMax), it will be bound.
 * (outMin > outMax) is ok, in that case output will be decreasing.
 *
 * \returns scaled value
 */
static float scale(float val, float inMin, float inMax, float outMin, float outMax)
{
	// bound input value
	if (val > inMax) val = inMax;
	if (val < inMin) val = inMin;

	// normalize input value to [0..1]
	if (inMax <= inMin)
		val = 0.0;
	else
		val = (val - inMin) / (inMax - inMin);

	// update output bounds
	if (outMin > outMax) {
		float t = outMin;
		outMin = outMax;
		outMax = t;
		val = 1.0f - val;
	}

	return (outMax - outMin) * val + outMin;
}

/**
 * Updates var using val if needed.
 * \returns 1 if updated, 0 otherwise
 */
static bool update(float *var, float val)
{
	if (*var != val) {
		*var = val;
		return true;
	}
	return false;
}
void VtolPathFollowerSettingsHorizontalPosPIGet( float *NewHorizontalPosPI )
{
    UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewHorizontalPosPI, offsetof( VtolPathFollowerSettingsData, HorizontalPosPI), 3*sizeof(float));
}
Пример #12
0
void VtolPathFollowerSettingsPositionSourceGet( uint8_t *NewPositionSource )
{
	UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewPositionSource, offsetof( VtolPathFollowerSettingsData, PositionSource), sizeof(uint8_t));
}
Пример #13
0
void VtolPathFollowerSettingsVelocitySourceGet( uint8_t *NewVelocitySource )
{
	UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewVelocitySource, offsetof( VtolPathFollowerSettingsData, VelocitySource), sizeof(uint8_t));
}
Пример #14
0
void VtolPathFollowerSettingsGuidanceModeSet( uint8_t *NewGuidanceMode )
{
	UAVObjSetDataField(VtolPathFollowerSettingsHandle(), (void*)NewGuidanceMode, offsetof( VtolPathFollowerSettingsData, GuidanceMode), sizeof(uint8_t));
}
void VtolPathFollowerSettingsWaypointAltitudeTolGet( float *NewWaypointAltitudeTol )
{
    UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewWaypointAltitudeTol, offsetof( VtolPathFollowerSettingsData, WaypointAltitudeTol), sizeof(float));
}
void VtolPathFollowerSettingsPositionFeedforwardGet( float *NewPositionFeedforward )
{
    UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewPositionFeedforward, offsetof( VtolPathFollowerSettingsData, PositionFeedforward), sizeof(float));
}
void VtolPathFollowerSettingsUpdatePeriodGet( int32_t *NewUpdatePeriod )
{
    UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewUpdatePeriod, offsetof( VtolPathFollowerSettingsData, UpdatePeriod), sizeof(int32_t));
}
void VtolPathFollowerSettingsEndpointDeadbandWidthSet( float *NewEndpointDeadbandWidth )
{
    UAVObjSetDataField(VtolPathFollowerSettingsHandle(), (void*)NewEndpointDeadbandWidth, offsetof( VtolPathFollowerSettingsData, EndpointDeadbandWidth), sizeof(float));
}
void VtolPathFollowerSettingsLoiterErrorDecayConstantSet( float *NewLoiterErrorDecayConstant )
{
    UAVObjSetDataField(VtolPathFollowerSettingsHandle(), (void*)NewLoiterErrorDecayConstant, offsetof( VtolPathFollowerSettingsData, LoiterErrorDecayConstant), sizeof(float));
}
void VtolPathFollowerSettingsEndpointDeadbandCenterGainSet( float *NewEndpointDeadbandCenterGain )
{
    UAVObjSetDataField(VtolPathFollowerSettingsHandle(), (void*)NewEndpointDeadbandCenterGain, offsetof( VtolPathFollowerSettingsData, EndpointDeadbandCenterGain), sizeof(float));
}
void VtolPathFollowerSettingsLoiterInitialMaxVelGet( float *NewLoiterInitialMaxVel )
{
    UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewLoiterInitialMaxVel, offsetof( VtolPathFollowerSettingsData, LoiterInitialMaxVel), sizeof(float));
}
void VtolPathFollowerSettingsPathDeadbandWidthGet( float *NewPathDeadbandWidth )
{
    UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewPathDeadbandWidth, offsetof( VtolPathFollowerSettingsData, PathDeadbandWidth), sizeof(float));
}
void VtolPathFollowerSettingsReturnToHomeVelGet( float *NewReturnToHomeVel )
{
    UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewReturnToHomeVel, offsetof( VtolPathFollowerSettingsData, ReturnToHomeVel), sizeof(float));
}
void VtolPathFollowerSettingsPathDeadbandCenterGainGet( float *NewPathDeadbandCenterGain )
{
    UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewPathDeadbandCenterGain, offsetof( VtolPathFollowerSettingsData, PathDeadbandCenterGain), sizeof(float));
}
void VtolPathFollowerSettingsVerticalVelMaxGet( uint16_t *NewVerticalVelMax )
{
    UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewVerticalVelMax, offsetof( VtolPathFollowerSettingsData, VerticalVelMax), sizeof(uint16_t));
}
void VtolPathFollowerSettingsMaxRollPitchGet( float *NewMaxRollPitch )
{
    UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewMaxRollPitch, offsetof( VtolPathFollowerSettingsData, MaxRollPitch), sizeof(float));
}
void VtolPathFollowerSettingsVelocityChangePredictionGet( uint8_t *NewVelocityChangePrediction )
{
    UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewVelocityChangePrediction, offsetof( VtolPathFollowerSettingsData, VelocityChangePrediction), sizeof(uint8_t));
}
void VtolPathFollowerSettingsEndpointRadiusGet( float *NewEndpointRadius )
{
    UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewEndpointRadius, offsetof( VtolPathFollowerSettingsData, EndpointRadius), sizeof(float));
}
void VtolPathFollowerSettingsLoiterAllowAltControlGet( uint8_t *NewLoiterAllowAltControl )
{
    UAVObjGetDataField(VtolPathFollowerSettingsHandle(), (void*)NewLoiterAllowAltControl, offsetof( VtolPathFollowerSettingsData, LoiterAllowAltControl), sizeof(uint8_t));
}
Пример #30
0
void VtolPathFollowerSettingsVerticalPosPISet( float *NewVerticalPosPI )
{
	UAVObjSetDataField(VtolPathFollowerSettingsHandle(), (void*)NewVerticalPosPI, offsetof( VtolPathFollowerSettingsData, VerticalPosPI), 3*sizeof(float));
}