You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
139 lines
4.2 KiB
139 lines
4.2 KiB
// -*- tab-width: 4; Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- |
|
|
|
static void init_rc_in() |
|
{ |
|
// set rc channel ranges |
|
g.channel_steer.set_angle(SERVO_MAX); |
|
g.channel_throttle.set_angle(100); |
|
|
|
// set rc dead zones |
|
g.channel_steer.set_dead_zone(60); |
|
g.channel_throttle.set_dead_zone(6); |
|
|
|
//set auxiliary ranges |
|
update_aux_servo_function(&g.rc_2, &g.rc_4, &g.rc_5, &g.rc_6, &g.rc_7, &g.rc_8); |
|
} |
|
|
|
static void init_rc_out() |
|
{ |
|
hal.rcout->enable_ch(CH_1); |
|
hal.rcout->enable_ch(CH_2); |
|
hal.rcout->enable_ch(CH_3); |
|
hal.rcout->enable_ch(CH_4); |
|
hal.rcout->enable_ch(CH_5); |
|
hal.rcout->enable_ch(CH_6); |
|
hal.rcout->enable_ch(CH_7); |
|
hal.rcout->enable_ch(CH_8); |
|
|
|
#if HIL_MODE != HIL_MODE_ATTITUDE |
|
hal.rcout->write(CH_1, g.channel_steer.radio_trim); // Initialization of servo outputs |
|
hal.rcout->write(CH_3, g.channel_throttle.radio_trim); |
|
|
|
hal.rcout->write(CH_2, g.rc_2.radio_trim); |
|
hal.rcout->write(CH_4, g.rc_4.radio_trim); |
|
hal.rcout->write(CH_5, g.rc_5.radio_trim); |
|
hal.rcout->write(CH_6, g.rc_6.radio_trim); |
|
hal.rcout->write(CH_7, g.rc_7.radio_trim); |
|
hal.rcout->write(CH_8, g.rc_8.radio_trim); |
|
#else |
|
hal.rcout->write(CH_1, 1500); // Initialization of servo outputs |
|
hal.rcout->write(CH_2, 1500); |
|
hal.rcout->write(CH_3, 1000); |
|
hal.rcout->write(CH_4, 1500); |
|
|
|
hal.rcout->write(CH_5, 1500); |
|
hal.rcout->write(CH_6, 1500); |
|
hal.rcout->write(CH_7, 1500); |
|
hal.rcout->write(CH_8, 2000); |
|
#endif |
|
|
|
} |
|
|
|
static void read_radio() |
|
{ |
|
g.channel_steer.set_pwm(hal.rcin->read(CH_STEER)); |
|
|
|
g.channel_throttle.set_pwm(hal.rcin->read(CH_3)); |
|
|
|
g.rc_2.set_pwm(hal.rcin->read(CH_2)); |
|
g.rc_4.set_pwm(hal.rcin->read(CH_4)); |
|
g.rc_5.set_pwm(hal.rcin->read(CH_5)); |
|
g.rc_6.set_pwm(hal.rcin->read(CH_6)); |
|
g.rc_7.set_pwm(hal.rcin->read(CH_7)); |
|
g.rc_8.set_pwm(hal.rcin->read(CH_8)); |
|
|
|
control_failsafe(g.channel_throttle.radio_in); |
|
|
|
g.channel_throttle.servo_out = g.channel_throttle.control_in; |
|
|
|
if (g.channel_throttle.servo_out > 50) { |
|
throttle_nudge = (g.throttle_max - g.throttle_cruise) * ((g.channel_throttle.norm_input()-0.5) / 0.5); |
|
} else { |
|
throttle_nudge = 0; |
|
} |
|
|
|
if (g.skid_steer_in) { |
|
// convert the two radio_in values from skid steering values |
|
/* |
|
mixing rule: |
|
steering = motor1 - motor2 |
|
throttle = 0.5*(motor1 + motor2) |
|
motor1 = throttle + 0.5*steering |
|
motor2 = throttle - 0.5*steering |
|
*/ |
|
|
|
float motor1 = g.channel_steer.norm_input(); |
|
float motor2 = g.channel_throttle.norm_input(); |
|
float steering_scaled = motor1 - motor2; |
|
float throttle_scaled = 0.5f*(motor1 + motor2); |
|
int16_t steer = g.channel_steer.radio_trim; |
|
int16_t thr = g.channel_throttle.radio_trim; |
|
if (steering_scaled > 0.0f) { |
|
steer += steering_scaled*(g.channel_steer.radio_max-g.channel_steer.radio_trim); |
|
} else { |
|
steer += steering_scaled*(g.channel_steer.radio_trim-g.channel_steer.radio_min); |
|
} |
|
if (throttle_scaled > 0.0f) { |
|
thr += throttle_scaled*(g.channel_throttle.radio_max-g.channel_throttle.radio_trim); |
|
} else { |
|
thr += throttle_scaled*(g.channel_throttle.radio_trim-g.channel_throttle.radio_min); |
|
} |
|
g.channel_steer.set_pwm(steer); |
|
g.channel_throttle.set_pwm(thr); |
|
} |
|
} |
|
|
|
static void control_failsafe(uint16_t pwm) |
|
{ |
|
if (!g.fs_throttle_enabled) { |
|
// no throttle failsafe |
|
return; |
|
} |
|
|
|
// Check for failsafe condition based on loss of GCS control |
|
if (rc_override_active) { |
|
failsafe_trigger(FAILSAFE_EVENT_RC, (millis() - failsafe.rc_override_timer) > 1500); |
|
} else if (g.fs_throttle_enabled) { |
|
failsafe_trigger(FAILSAFE_EVENT_THROTTLE, pwm < (uint16_t)g.fs_throttle_value); |
|
} |
|
} |
|
|
|
static void trim_control_surfaces() |
|
{ |
|
read_radio(); |
|
// Store control surface trim values |
|
// --------------------------------- |
|
if (g.channel_steer.radio_in > 1400) { |
|
g.channel_steer.radio_trim = g.channel_steer.radio_in; |
|
// save to eeprom |
|
g.channel_steer.save_eeprom(); |
|
} |
|
} |
|
|
|
static void trim_radio() |
|
{ |
|
for (int y = 0; y < 30; y++) { |
|
read_radio(); |
|
} |
|
trim_control_surfaces(); |
|
}
|
|
|