| /branches/dongfang_FC_fixedwing/analog.c |
|---|
| 43,7 → 43,7 |
| int16_t gyro_PID[3]; |
| int16_t gyro_ATT[3]; |
| int16_t gyroD[3]; |
| int16_t gyroDWindow[2][GYRO_D_WINDOW_LENGTH]; |
| int16_t gyroDWindow[3][GYRO_D_WINDOW_LENGTH]; |
| uint8_t gyroDWindowIdx = 0; |
| //int16_t dHeight; |
| //uint32_t gyroActivity; |
| 119,21 → 119,6 |
| uint16_t simpleAirPressure; |
| uint16_t airspeedVelocity; |
| // Value of AIRPRESSURE_OVERSAMPLING samples, with range, filtered. |
| // int32_t filteredAirPressure; |
| #define MAX_AIRPRESSURE_WINDOW_LENGTH 32 |
| int16_t airPressureWindow[MAX_AIRPRESSURE_WINDOW_LENGTH]; |
| int32_t windowedAirPressure; |
| uint8_t windowPtr = 0; |
| // Partial sum of AIRPRESSURE_SUMMATION_FACTOR samples. |
| int32_t airPressureSum; |
| // The number of samples summed into airPressureSum so far. |
| uint8_t pressureMeasurementCount; |
| /* |
| * Battery voltage, in units of: 1k/11k / 3V * 1024 = 31.03 per volt. |
| * That is divided by 3 below, for a final 10.34 per volt. |
| 225,11 → 210,6 |
| //Trigger Source to Free Running Mode |
| ADCSRB &= ~((1<<ADTS2)|(1<<ADTS1)|(1<<ADTS0)); |
| for (uint8_t i=0; i<MAX_AIRPRESSURE_WINDOW_LENGTH; i++) { |
| airPressureWindow[i] = 0; |
| } |
| windowedAirPressure = 0; |
| startAnalogConversionCycle(); |
| // restore global interrupt flags |
| 322,6 → 302,7 |
| int16_t tempOffsetGyro[3], tempGyro; |
| debugOut.digital[0] &= ~DEBUG_SENSORLIMIT; |
| for (uint8_t axis=0; axis<3; axis++) { |
| tempGyro = rawGyroValue(axis); |
| /* |
| 376,6 → 357,7 |
| // dampenGyroActivity(); |
| gyro_ATT[PITCH] = tempOffsetGyro[PITCH]; |
| gyro_ATT[ROLL] = tempOffsetGyro[ROLL]; |
| gyro_ATT[YAW] = tempOffsetGyro[YAW]; |
| if (++gyroDWindowIdx >= IMUConfig.gyroDWindowLength) { |
| gyroDWindowIdx = 0; |
| 402,7 → 384,6 |
| #ifdef USE_MK3MAG |
| magneticHeading = volatileMagneticHeading; |
| #endif |
| } |
| void analog_setNeutral() { |
| 430,7 → 411,7 |
| } |
| void analog_calibrateGyros(void) { |
| #define GYRO_OFFSET_CYCLES 32 |
| #define GYRO_OFFSET_CYCLES 64 |
| uint8_t i, axis; |
| int32_t offsets[3] = { 0, 0, 0 }; |
| gyro_calibrate(); |
| /branches/dongfang_FC_fixedwing/attitude.c |
|---|
| 28,12 → 28,7 |
| * The variables are overwritten at each attitude calculation invocation - the values |
| * are not preserved or reused. |
| */ |
| int16_t rate_ATT[3]; |
| // With different (less) filtering |
| int16_t rate_PID[3]; |
| int16_t differential[3]; |
| /* |
| * Gyro integrals. These are the rotation angles of the airframe compared to the |
| * horizontal plane, yaw relative to yaw at start. |
| 86,13 → 81,8 |
| *************************************************************************/ |
| void getAnalogData(void) { |
| uint8_t axis; |
| analog_update(); |
| for (axis = PITCH; axis <= YAW; axis++) { |
| rate_PID[axis] = gyro_PID[axis]; |
| rate_ATT[axis] = gyro_ATT[axis]; |
| differential[axis] = gyroD[axis]; |
| } |
| } |
| 110,7 → 100,7 |
| */ |
| for (axis = PITCH; axis <= YAW; axis++) { |
| attitude[axis] += rate_ATT[axis]; |
| attitude[axis] += gyro_ATT[axis]; |
| if (attitude[axis] > OVER180) { |
| attitude[axis] -= OVER360; |
| } else if (attitude[axis] <= -OVER180) { |
| /branches/dongfang_FC_fixedwing/configuration.c |
|---|
| 104,7 → 104,7 |
| } |
| void configuration_setFlightParameters(uint8_t newFlightMode) { |
| updateFlightParametersToFlightMode(currentFlightMode = newFlightMode); |
| flight_updateFlightParametersToFlightMode(currentFlightMode = newFlightMode); |
| } |
| // Called after a change in configuration parameters, as a hook for modules to take over changes. |
| 136,6 → 136,10 |
| staticParams.emergencyThrottle = 35; |
| staticParams.emergencyFlightDuration = 30; |
| staticParams.stickIElevator = 80; |
| staticParams.stickIAilerons = 120; |
| staticParams.stickIRudder = 40; |
| // Outputs |
| staticParams.outputFlash[0].bitmask = 1; //0b01011111; |
| staticParams.outputFlash[0].timing = 15; |
| 165,8 → 169,10 |
| void IMUConfig_default(void) { |
| IMUConfig.gyroPIDFilterConstant = 1; |
| IMUConfig.gyroDFilterConstant = 1; |
| IMUConfig.accFilterConstant = 10; |
| IMUConfig.rateTolerance = 120; |
| IMUConfig.gyroDWindowLength = 3; |
| IMUConfig.gyroQuadrant = 0; |
| IMUConfig.imuReversedFlags = 0; |
| gyro_setDefaultParameters(); |
| } |
| /branches/dongfang_FC_fixedwing/controlMixer.c |
|---|
| 107,7 → 107,7 |
| */ |
| void controlMixer_periodicTask(void) { |
| int16_t tempPRTY[4] = { 0, 0, 0, 0 }; |
| int16_t tempPRYT[4] = { 0, 0, 0, 0 }; |
| // Decode commands. |
| uint8_t rcCommand = (RC_getSignalQuality() >= SIGNAL_OK) ? RC_getCommand() : COMMAND_NONE; |
| 139,18 → 139,18 |
| } |
| // This will init the values (not just add to them). |
| RC_periodicTaskAndPRTY(tempPRTY); |
| RC_periodicTaskAndPRYT(tempPRYT); |
| // Add external control to RC |
| EC_periodicTaskAndPRTY(tempPRTY); |
| EC_periodicTaskAndPRYT(tempPRYT); |
| FC_periodicTaskAndPRTY(tempPRTY); |
| FC_periodicTaskAndPRYT(tempPRYT); |
| // Commit results to global variable and also measure control activity. |
| controls[CONTROL_THROTTLE] = tempPRTY[CONTROL_THROTTLE]; |
| controls[CONTROL_ELEVATOR] = tempPRTY[CONTROL_ELEVATOR]; |
| controls[CONTROL_AILERONS] = tempPRTY[CONTROL_AILERONS]; |
| controls[CONTROL_RUDDER] = tempPRTY[CONTROL_RUDDER]; |
| controls[CONTROL_THROTTLE] = tempPRYT[CONTROL_THROTTLE]; |
| controls[CONTROL_ELEVATOR] = tempPRYT[CONTROL_ELEVATOR]; |
| controls[CONTROL_AILERONS] = tempPRYT[CONTROL_AILERONS]; |
| controls[CONTROL_RUDDER] = tempPRYT[CONTROL_RUDDER]; |
| // dampenControlActivity(); |
| // We can safely do this even with a bad signal - the variables will not have been updated then. |
| /branches/dongfang_FC_fixedwing/controlMixer.h |
|---|
| 23,12 → 23,12 |
| #define SIGNAL_GOOD 4 |
| /* |
| * The PRTY arrays |
| * The PRYT arrays |
| */ |
| #define CONTROL_ELEVATOR 0 |
| #define CONTROL_AILERONS 1 |
| #define CONTROL_THROTTLE 2 |
| #define CONTROL_RUDDER 3 |
| #define CONTROL_RUDDER 2 |
| #define CONTROL_THROTTLE 3 |
| /* |
| * Looping flags. |
| /branches/dongfang_FC_fixedwing/eeprom.h |
|---|
| 31,6 → 31,7 |
| void paramSet_readOrDefault(void); |
| void channelMap_readOrDefault(void); |
| void IMUConfig_readOrDefault(void); |
| void IMUConfig_writeToEEprom(void); |
| uint8_t paramSet_readFromEEProm(uint8_t setnumber); |
| void paramSet_writeToEEProm(uint8_t setnumber); |
| /branches/dongfang_FC_fixedwing/externalControl.c |
|---|
| 4,8 → 4,6 |
| ExternalControl_t externalControl; |
| uint8_t externalControlActive = 0; |
| // int16_t EC_PRTY[4]; |
| // TODO: Who is going to call this |
| void EC_setNeutral(void) { |
| // if necessary. From main.c. |
| 19,13 → 17,13 |
| externalControl.digital[0] = 0x55; |
| } |
| void EC_periodicTaskAndPRTY(int16_t* PRTY) { |
| void EC_periodicTaskAndPRYT(int16_t* PRYT) { |
| if (externalControlActive) { |
| externalControlActive--; |
| PRTY[CONTROL_ELEVATOR] += externalControl.pitch * 8; |
| PRTY[CONTROL_AILERONS] += externalControl.roll * 8; |
| PRTY[CONTROL_THROTTLE] += externalControl.throttle * 8; |
| PRTY[CONTROL_RUDDER] += externalControl.yaw * 8; |
| PRYT[CONTROL_ELEVATOR] += externalControl.pitch * 8; |
| PRYT[CONTROL_AILERONS] += externalControl.roll * 8; |
| PRYT[CONTROL_THROTTLE] += externalControl.throttle * 8; |
| PRYT[CONTROL_RUDDER] += externalControl.yaw * 8; |
| } |
| } |
| /branches/dongfang_FC_fixedwing/externalControl.h |
|---|
| 20,7 → 20,7 |
| extern ExternalControl_t externalControl; |
| extern uint8_t externalControlActive; |
| void EC_periodicTaskAndPRTY(int16_t* PRTY); |
| void EC_periodicTaskAndPRYT(int16_t* PRYT); |
| uint8_t EC_getArgument(void); |
| uint8_t EC_getCommand(void); |
| int16_t EC_getVariable(uint8_t varNum); |
| /branches/dongfang_FC_fixedwing/failsafeControl.c |
|---|
| 4,7 → 4,7 |
| #include "flight.h" |
| #include "output.h" |
| void FC_periodicTaskAndPRTY(uint16_t* PRTY) { |
| void FC_periodicTaskAndPRYT(uint16_t* PRYT) { |
| if (controlMixer_getSignalQuality() <= SIGNAL_BAD) { // the rc-frame signal is not reveived or noisy |
| if (controlMixer_didReceiveSignal) { |
| beepRCAlarm(); // Only make alarm if a control signal was received before the signal loss. |
| 12,5 → 12,5 |
| } |
| } |
| void FC_setNeutral() { |
| void FC_setNeutral(void) { |
| } |
| /branches/dongfang_FC_fixedwing/failsafeControl.h |
|---|
| 1,3 → 1,3 |
| #include <inttypes.h> |
| void FC_setNeutral(void); |
| void FC_periodicTaskAndPRTY(int16_t* PRTY); |
| void FC_periodicTaskAndPRYT(int16_t* PRYT); |
| /branches/dongfang_FC_fixedwing/flight.c |
|---|
| 8,6 → 8,7 |
| #include "uart0.h" |
| #include "timer2.h" |
| #include "analog.h" |
| #include "attitude.h" |
| #include "controlMixer.h" |
| 44,14 → 45,14 |
| } |
| // this should be followed by a call to switchToFlightMode!! |
| void updateFlightParametersToFlightMode(uint8_t flightMode) { |
| debugOut.analog[15] = flightMode; |
| void flight_updateFlightParametersToFlightMode(uint8_t flightMode) { |
| debugOut.analog[16] = flightMode; |
| reverse[CONTROL_ELEVATOR] = staticParams.controlServosReverse |
| reverse[PITCH] = staticParams.controlServosReverse |
| & CONTROL_SERVO_REVERSE_ELEVATOR; |
| reverse[CONTROL_AILERONS] = staticParams.controlServosReverse |
| reverse[ROLL] = staticParams.controlServosReverse |
| & CONTROL_SERVO_REVERSE_AILERONS; |
| reverse[CONTROL_RUDDER] = staticParams.controlServosReverse |
| reverse[YAW] = staticParams.controlServosReverse |
| & CONTROL_SERVO_REVERSE_RUDDER; |
| for (uint8_t i = 0; i < 3; i++) { |
| 76,7 → 77,7 |
| /************************************************************************/ |
| void flight_control(void) { |
| // Mixer Fractions that are combined for Motor Control |
| int16_t throttleTerm, term[3]; |
| int16_t term[4]; |
| // PID controller variables |
| int16_t PDPart[3]; |
| 92,18 → 93,18 |
| // calculateFlightAttitude(); |
| // TODO: Check modern version. |
| // controlMixer_update(); |
| throttleTerm = controls[CONTROL_THROTTLE]; |
| term[CONTROL_THROTTLE] = controls[CONTROL_THROTTLE]; |
| // These params are just left the same in all modes. In MANUAL and RATE the results are ignored anyway. |
| target[PITCH] += controls[CONTROL_ELEVATOR] * staticParams.stickIElevator; |
| target[ROLL] += controls[CONTROL_AILERONS] * staticParams.stickIAilerons; |
| target[YAW] += controls[CONTROL_RUDDER] * staticParams.stickIRudder; |
| target[PITCH] += (controls[CONTROL_ELEVATOR] * staticParams.stickIElevator) >> 6; |
| target[ROLL] += (controls[CONTROL_AILERONS] * staticParams.stickIAilerons) >> 6; |
| target[YAW] += (controls[CONTROL_RUDDER] * staticParams.stickIRudder) >> 6; |
| for (axis = PITCH; axis <= YAW; axis++) { |
| if (target[axis] > OVER180) { |
| target[axis] -= OVER360; |
| } else if (attitude[axis] <= -OVER180) { |
| attitude[axis] += OVER360; |
| } else if (target[axis] <= -OVER180) { |
| target[axis] += OVER360; |
| } |
| if (reverse[axis]) |
| 120,8 → 121,8 |
| /* Calculate control feedback from angle (gyro integral) */ |
| /* and angular velocity (gyro signal) */ |
| /************************************************************************/ |
| PDPart[axis] = (((int32_t) rate_PID[axis] * pFactor[axis]) >> 6) |
| + ((differential[axis] * (int16_t) dFactor[axis]) >> 4); |
| PDPart[axis] = (((int32_t) gyro_PID[axis] * pFactor[axis]) >> 6) |
| + ((gyroD[axis] * (int16_t) dFactor[axis]) >> 4); |
| if (reverse[axis]) |
| PDPart[axis] = -PDPart[axis]; |
| 139,8 → 140,8 |
| debugOut.analog[12] = term[PITCH]; |
| debugOut.analog[13] = term[ROLL]; |
| debugOut.analog[14] = throttleTerm; |
| debugOut.analog[15] = term[YAW]; |
| debugOut.analog[14] = term[YAW]; |
| debugOut.analog[15] = term[THROTTLE]; |
| for (uint8_t i = 0; i < MAX_CONTROL_SERVOS; i++) { |
| int16_t tmp; |
| 156,7 → 157,7 |
| tmp = term[PITCH]; |
| break; |
| case 2: |
| tmp = throttleTerm; |
| tmp = term[THROTTLE]; |
| break; |
| case 3: |
| tmp = term[YAW]; |
| 169,7 → 170,7 |
| } |
| } |
| calculateControlServoValues; |
| calculateControlServoValues(); |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // Debugging |
| 176,9 → 177,9 |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| if (!(--debugDataTimer)) { |
| debugDataTimer = 24; // update debug outputs at 488 / 24 = 20.3 Hz. |
| debugOut.analog[0] = rate_PID[PITCH]; // in 0.1 deg |
| debugOut.analog[1] = rate_PID[ROLL]; // in 0.1 deg |
| debugOut.analog[2] = rate_PID[YAW]; |
| debugOut.analog[0] = gyro_PID[PITCH]; // in 0.1 deg |
| debugOut.analog[1] = gyro_PID[ROLL]; // in 0.1 deg |
| debugOut.analog[2] = gyro_PID[YAW]; |
| debugOut.analog[3] = attitude[PITCH] / (GYRO_DEG_FACTOR / 10); // in 0.1 deg |
| debugOut.analog[4] = attitude[ROLL] / (GYRO_DEG_FACTOR / 10); // in 0.1 deg |
| /branches/dongfang_FC_fixedwing/flight.h |
|---|
| 12,6 → 12,7 |
| #define PITCH 0 |
| #define ROLL 1 |
| #define YAW 2 |
| #define THROTTLE 3 |
| #define MAX_CONTROL_SERVOS 4 |
| 18,7 → 19,7 |
| extern int16_t controlServos[MAX_CONTROL_SERVOS]; |
| void flight_control(void); |
| void transmitMotorThrottleData(void); |
| void flight_setNeutral(void); |
| void flight_updateFlightParametersToFlightMode(uint8_t flightMode); |
| #endif //_FLIGHT_H |
| /branches/dongfang_FC_fixedwing/isqrt.S |
|---|
| 0,0 → 1,203 |
| ;-----------------------------------------------------------------------------; |
| ; Fast integer squareroot routines for avr-gcc project (C)ChaN, 2008 |
| ; http://elm-chan.org/docs/avrlib/sqrt32.S |
| ;-----------------------------------------------------------------------------; |
| ; uint16_t isqrt32 (uint32_t n); |
| ; uint8_t isqrt16 (uint16_t n); |
| ; uint16_t ihypot (int16_t x, int16_t y); |
| ;-----------------------------------------------------------------------------: |
| ; 32bit integer squareroot |
| ;-----------------------------------------------------------------------------; |
| ; uint16_t isqrt32 ( |
| ; uint32_t n |
| ; ); |
| ; |
| ; Return Value: |
| ; Squareroot of n. |
| ; |
| ; Size = 53 words |
| ; Clock = 532..548 cycles |
| ; Stack = 0 byte |
| .global isqrt32 |
| .func isqrt32 |
| isqrt32: |
| clr r0 |
| clr r18 |
| clr r19 |
| clr r20 |
| ldi r21, 1 |
| clr r27 |
| clr r30 |
| clr r31 |
| ldi r26, 16 |
| 1: lsl r22 |
| rol r23 |
| rol r24 |
| rol r25 |
| rol r0 |
| rol r18 |
| rol r19 |
| rol r20 |
| lsl r22 |
| rol r23 |
| rol r24 |
| rol r25 |
| rol r0 |
| rol r18 |
| rol r19 |
| rol r20 |
| brpl 2f |
| add r0, r21 |
| adc r18, r27 |
| adc r19, r30 |
| adc r20, r31 |
| rjmp 3f |
| 2: sub r0, r21 |
| sbc r18, r27 |
| sbc r19, r30 |
| sbc r20, r31 |
| 3: lsl r21 |
| rol r27 |
| rol r30 |
| andi r21, 0b11111000 |
| ori r21, 0b00000101 |
| sbrc r20, 7 |
| subi r21, 2 |
| dec r26 |
| brne 1b |
| lsr r30 |
| ror r27 |
| ror r21 |
| lsr r30 |
| ror r27 |
| ror r21 |
| mov r24, r21 |
| mov r25, r27 |
| ret |
| .endfunc |
| ;-----------------------------------------------------------------------------: |
| ; 16bit integer squareroot |
| ;-----------------------------------------------------------------------------; |
| ; uint8_t isqrt16 ( |
| ; uint16_t n |
| ; ); |
| ; |
| ; Return Value: |
| ; Squareroot of n. |
| ; |
| ; Size = 33 words |
| ; Clock = 181..189 cycles |
| ; Stack = 0 byte |
| .global isqrt16 |
| .func isqrt16 |
| isqrt16: |
| clr r18 |
| clr r19 |
| ldi r20, 1 |
| clr r21 |
| ldi r22, 8 |
| 1: lsl r24 |
| rol r25 |
| rol r18 |
| rol r19 |
| lsl r24 |
| rol r25 |
| rol r18 |
| rol r19 |
| brpl 2f |
| add r18, r20 |
| adc r19, r21 |
| rjmp 3f |
| 2: sub r18, r20 |
| sbc r19, r21 |
| 3: lsl r20 |
| rol r21 |
| andi r20, 0b11111000 |
| ori r20, 0b00000101 |
| sbrc r19, 7 |
| subi r20, 2 |
| dec r22 |
| brne 1b |
| lsr r21 |
| ror r20 |
| lsr r21 |
| ror r20 |
| mov r24, r20 |
| ret |
| .endfunc |
| ;-----------------------------------------------------------------------------: |
| ; 16bit integer hypot (megaAVR is required) |
| ;-----------------------------------------------------------------------------; |
| ; uint16_t ihypot ( |
| ; int16_t x, |
| ; int16_t y |
| ; ); |
| ; |
| ; Return Value: |
| ; Squareroot of (x*x + y*y) |
| ; |
| ; Size = 42 words |
| ; Clock = 581..597 cycles |
| ; Stack = 0 byte |
| .global ihypot |
| .func ihypot |
| ihypot: |
| clr r26 |
| sbrs r25, 7 |
| rjmp 1f |
| com r24 |
| com r25 |
| adc r24, r26 |
| adc r25, r26 |
| 1: sbrs r23, 7 |
| rjmp 2f |
| com r22 |
| com r23 |
| adc r22, r26 |
| adc r23, r26 |
| 2: mul r22, r22 |
| movw r18, r0 |
| mul r23, r23 |
| movw r20, r0 |
| mul r22, r23 |
| add r19, r0 |
| adc r20, r1 |
| adc r21, r26 |
| add r19, r0 |
| adc r20, r1 |
| adc r21, r26 |
| mul r24, r24 |
| movw r30, r0 |
| mul r25, r25 |
| add r18, r30 |
| adc r19, r31 |
| adc r20, r0 |
| adc r21, r1 |
| mul r24, r25 |
| add r19, r0 |
| adc r20, r1 |
| adc r21, r26 |
| add r19, r0 |
| adc r20, r1 |
| adc r21, r26 |
| movw r24, r20 |
| movw r22, r18 |
| clr r1 |
| rjmp isqrt32 |
| .endfunc |
| /branches/dongfang_FC_fixedwing/isqrt.h |
|---|
| 0,0 → 1,11 |
| #ifndef _ISQRT_H |
| #define _ISQRT_H |
| #include <inttypes.h> |
| // coded in assembler file |
| extern uint16_t isqrt32(uint32_t n); |
| extern uint8_t isqrt16(uint16_t n); |
| extern uint16_t ihypot(int16_t x, int16_t y); |
| #endif // _ISQRT_H |
| /branches/dongfang_FC_fixedwing/rc.c |
|---|
| 154,7 → 154,7 |
| #define RC_SCALING 4 |
| uint8_t getControlModeSwitch() { |
| uint8_t getControlModeSwitch(void) { |
| int16_t channel = RCChannel(CH_MODESWITCH) + POT_OFFSET; |
| uint8_t flightMode = channel < 256/3 ? FLIGHT_MODE_MANUAL : |
| (channel > 256*2/3 ? FLIGHT_MODE_ANGLES : FLIGHT_MODE_RATE); |
| 175,8 → 175,8 |
| return lastRCCommand; |
| } |
| int16_t channel = RCChannel(CH_MODESWITCH) + POT_OFFSET; |
| if (channel <= -32) { // <= 900 us |
| int16_t channel = RCChannel(CH_THROTTLE); |
| if (channel <= -140) { // <= 900 us |
| if (commandTimer == COMMAND_TIMER) { |
| lastRCCommand = COMMAND_GYROCAL; |
| } |
| 183,7 → 183,10 |
| if (commandTimer <= COMMAND_TIMER) { |
| commandTimer++; |
| } |
| } else commandTimer = 0; |
| } else { |
| commandTimer = 0; |
| lastRCCommand = COMMAND_NONE; |
| } |
| return lastRCCommand; |
| } |
| 194,17 → 197,20 |
| /* |
| * Get Pitch, Roll, Throttle, Yaw values |
| */ |
| void RC_periodicTaskAndPRTY(int16_t* PRTY) { |
| void RC_periodicTaskAndPRYT(int16_t* PRYT) { |
| if (RCQuality) { |
| RCQuality--; |
| PRTY[CONTROL_ELEVATOR] = RCChannel(CH_ELEVATOR) * RC_SCALING; |
| PRTY[CONTROL_AILERONS] = RCChannel(CH_AILERONS) * RC_SCALING; |
| PRTY[CONTROL_THROTTLE] = RCChannel(CH_THROTTLE) * RC_SCALING; |
| PRTY[CONTROL_RUDDER] = RCChannel(CH_RUDDER) * RC_SCALING; |
| debugOut.analog[16] = PRTY[CONTROL_ELEVATOR]; |
| debugOut.analog[17] = PRTY[CONTROL_THROTTLE]; |
| debugOut.analog[20] = RCChannel(CH_ELEVATOR); |
| debugOut.analog[21] = RCChannel(CH_AILERONS); |
| debugOut.analog[22] = RCChannel(CH_RUDDER); |
| debugOut.analog[23] = RCChannel(CH_THROTTLE); |
| PRYT[CONTROL_ELEVATOR] = RCChannel(CH_ELEVATOR) * RC_SCALING; |
| PRYT[CONTROL_AILERONS] = RCChannel(CH_AILERONS) * RC_SCALING; |
| PRYT[CONTROL_RUDDER] = RCChannel(CH_RUDDER) * RC_SCALING; |
| PRYT[CONTROL_THROTTLE] = RCChannel(CH_THROTTLE) * RC_SCALING; |
| uint8_t command = COMMAND_NONE; //RC_getStickCommand(); |
| if (lastRCCommand == command) { |
| // Keep timer from overrunning. |
| /branches/dongfang_FC_fixedwing/rc.h |
|---|
| 32,7 → 32,7 |
| */ |
| // void RC_periodicTask(void); |
| void RC_periodicTaskAndPRTY(int16_t* PRTY); |
| void RC_periodicTaskAndPRYT(int16_t* PRYT); |
| uint8_t RC_getArgument(void); |
| uint8_t RC_getCommand(void); |
| int16_t RC_getVariable(uint8_t varNum); |
| /branches/dongfang_FC_fixedwing/timer2.c |
|---|
| 126,13 → 126,15 |
| void calculateControlServoValues(void) { |
| int16_t value; |
| for (uint8_t axis=0; axis<3; axis++) { |
| for (uint8_t axis=0; axis<4; axis++) { |
| value = controlServos[axis]; |
| value /= 2; |
| value *= 2; |
| servoValues[axis] = value + NEUTRAL_PULSELENGTH; |
| } |
| debugOut.analog[18] = servoValues[0]; |
| debugOut.analog[19] = servoValues[2]; |
| debugOut.analog[24] = servoValues[0]; |
| debugOut.analog[25] = servoValues[1]; |
| debugOut.analog[26] = servoValues[2]; |
| debugOut.analog[27] = servoValues[3]; |
| } |
| void calculateFeaturedServoValues(void) { |
| 144,11 → 146,11 |
| for (axis=0; axis<2; axis++) { |
| value = featuredServoValue(axis); |
| servoValues[axis + 3] = value; |
| servoValues[axis + 4] = value; |
| } |
| for (axis=2; axis<MAX_SERVOS; axis++) { |
| value = 128 * SCALE_FACTOR; |
| servoValues[axis + 3] = value; |
| servoValues[axis + 4] = value; |
| } |
| recalculateServoTimes = 0; |
| /branches/dongfang_FC_fixedwing/uart0.c |
|---|
| 95,24 → 95,24 |
| "Error Y ", |
| "Term P ", |
| "Term R ", |
| "Term Y ", |
| "FlightMode ", //15 |
| "RC P ", |
| "RC Thr ", |
| "ServoFinal P ", |
| "ServoFinal T ", |
| "control act wghd", //20 |
| "acc vector wghd ", |
| "Height[dm] ", |
| "dHeight ", |
| "acc vector ", |
| "EFT ", //25 |
| "naviPitch ", |
| "naviRoll ", |
| "tolerance ", |
| "Gyro Act Cont. ", |
| "GPS altitude ", //30 |
| "GPS vert accura " |
| "Throttle ", |
| "Term Y ", //15 |
| "Flight mode ", |
| " ", |
| " ", |
| " ", |
| "RC P ", //20 |
| "RC R ", |
| "RC T ", |
| "RC Y ", |
| "Servo P ", |
| "Servo R ", //25 |
| "Servo T ", |
| "Servo Y ", |
| " ", |
| " . ", |
| " ", //30 |
| " " |
| }; |
| /****************************************************************/ |