ardupilot/ArduCopter/radio.pde

// -*- tab-width: 4; Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*-

//Function that will read the radio data, limit servos and trigger a failsafe
// ----------------------------------------------------------------------------
static int8_t failsafeCounter = 0;		// we wait a second to take over the throttle and send the plane circling


extern RC_Channel* rc_ch[NUM_CHANNELS];

static void default_dead_zones()
{
	g.rc_1.set_dead_zone(60);
	g.rc_2.set_dead_zone(60);
	#if FRAME_CONFIG == HELI_FRAME
	    g.rc_3.set_dead_zone(20);
		g.rc_4.set_dead_zone(30);
	#else
	    g.rc_3.set_dead_zone(60);
		g.rc_4.set_dead_zone(80);
	#endif
}

static void init_rc_in()
{
	// set rc channel ranges
	g.rc_1.set_angle(4500);
	g.rc_2.set_angle(4500);
	#if FRAME_CONFIG == HELI_FRAME
		// we do not want to limit the movment of the heli's swash plate
		g.rc_3.set_range(0, 1000);
	#else
		g.rc_3.set_range(g.throttle_min, g.throttle_max);
	#endif
	g.rc_4.set_angle(4500);

	// reverse: CW = left
	// normal:  CW = left???

	g.rc_1.set_type(RC_CHANNEL_ANGLE_RAW);
	g.rc_2.set_type(RC_CHANNEL_ANGLE_RAW);
	g.rc_4.set_type(RC_CHANNEL_ANGLE_RAW);

	rc_ch[CH_1] = &g.rc_1;
	rc_ch[CH_2] = &g.rc_2;
	rc_ch[CH_3] = &g.rc_3;
	rc_ch[CH_4] = &g.rc_4;
	rc_ch[CH_5] = &g.rc_5;
	rc_ch[CH_6] = &g.rc_6;
	rc_ch[CH_7] = &g.rc_7;
	rc_ch[CH_8] = &g.rc_8;

	//set auxiliary ranges
	g.rc_5.set_range(0,1000);
	g.rc_6.set_range(0,1000);
	g.rc_7.set_range(0,1000);
	g.rc_8.set_range(0,1000);

	#if MOUNT == ENABLED
	update_aux_servo_function(&g.rc_9, &g.rc_10, &g.rc_11);
	#endif
}

static void init_rc_out()
{
	APM_RC.Init( &isr_registry );		// APM Radio initialization

	#if INSTANT_PWM == 1
	motors.set_update_rate(AP_MOTORS_SPEED_INSTANT_PWM);
	#else
	motors.set_update_rate(g.rc_speed);
	#endif

	motors.set_frame_orientation(g.frame_orientation);
	motors.Init();						// motor initialisation
	motors.set_min_throttle(g.throttle_min);
	motors.set_max_throttle(g.throttle_max);

	for(byte i = 0; i < 5; i++){
		delay(20);
		read_radio();
	}

	// we want the input to be scaled correctly
	g.rc_3.set_range_out(0,1000);

    // sanity check - prevent unconfigured radios from outputting
    if(g.rc_3.radio_min >= 1300){
        g.rc_3.radio_min = g.rc_3.radio_in;
    }

	// we are full throttle
	if(g.rc_3.control_in >= (MAXIMUM_THROTTLE - 50)){
		if(g.esc_calibrate == 0){
			// we will enter esc_calibrate mode on next reboot
			g.esc_calibrate.set_and_save(1);
			// send miinimum throttle out to ESC
			motors.output_min();
			// block until we restart
			while(1){
				//Serial.println("esc");
				delay(200);
				dancing_light();
			}
		}else{
			//Serial.println("esc init");
			// clear esc flag
			g.esc_calibrate.set_and_save(0);
			// block until we restart
	        init_esc();
		}
	}else{
		// did we abort the calibration?
		if(g.esc_calibrate == 1)
			g.esc_calibrate.set_and_save(0);

		// send miinimum throttle out to ESC
		output_min();
	}

	enable_aux_servos();

	#if TOY_EDF == ENABLED
	// add access to CH8 and CH6
	APM_RC.enable_out(CH_8);
	APM_RC.enable_out(CH_6);
	#endif
}

void output_min()
{
	// enable motors
	motors.enable();
	motors.output_min();
}
static void read_radio()
{
	if (APM_RC.GetState() == 1){
		new_radio_frame = true;
		g.rc_1.set_pwm(APM_RC.InputCh(CH_1));
		g.rc_2.set_pwm(APM_RC.InputCh(CH_2));
		g.rc_3.set_pwm(APM_RC.InputCh(CH_3));
		g.rc_4.set_pwm(APM_RC.InputCh(CH_4));
		g.rc_5.set_pwm(APM_RC.InputCh(CH_5));
		g.rc_6.set_pwm(APM_RC.InputCh(CH_6));
		g.rc_7.set_pwm(APM_RC.InputCh(CH_7));
		g.rc_8.set_pwm(APM_RC.InputCh(CH_8));

		#if FRAME_CONFIG != HELI_FRAME
			// limit our input to 800 so we can still pitch and roll
			g.rc_3.control_in = min(g.rc_3.control_in, MAXIMUM_THROTTLE);
		#endif

		throttle_failsafe(g.rc_3.radio_in);
	}
}
#define FS_COUNTER 3
static void throttle_failsafe(uint16_t pwm)
{
	// Don't enter Failsafe if not enabled by user
	if(g.throttle_fs_enabled == 0)
		return;

	//check for failsafe and debounce funky reads
	// ------------------------------------------
	if (pwm < (unsigned)g.throttle_fs_value){
		// we detect a failsafe from radio
		// throttle has dropped below the mark
		failsafeCounter++;
		if (failsafeCounter == FS_COUNTER-1){
			// called right before trigger
			// do nothing
		}else if(failsafeCounter == FS_COUNTER) {
			// Don't enter Failsafe if we are not armed
			// home distance is in meters
			// This is to prevent accidental RTL
			if(motors.armed() && takeoff_complete){
				SendDebug("MSG FS ON ");
				SendDebugln(pwm, DEC);
				set_failsafe(true);
			}
		}else if (failsafeCounter > FS_COUNTER){
			failsafeCounter = FS_COUNTER+1;
		}

	}else if(failsafeCounter > 0){
		// we are no longer in failsafe condition
		// but we need to recover quickly
		failsafeCounter--;
		if (failsafeCounter > 3){
			failsafeCounter = 3;
		}
		if (failsafeCounter == 1){
			SendDebug("MSG FS OFF ");
			SendDebugln(pwm, DEC);
		}else if(failsafeCounter == 0) {
			set_failsafe(false);
		}else if (failsafeCounter <0){
			failsafeCounter = -1;
		}
	}
}

static void trim_radio()
{
	for (byte i = 0; i < 30; i++){
		read_radio();
	}

	g.rc_1.trim();	// roll
	g.rc_2.trim();	// pitch
	g.rc_4.trim();	// yaw

	g.rc_1.save_eeprom();
	g.rc_2.save_eeprom();
	g.rc_4.save_eeprom();
}