WebSVN - FlightCtrl - Diff - Rev 2164 and 2189 - /branches/dongfang_FC

 #include <avr/pgmspace.h>
 #include <stdarg.h>
 #include <string.h>
-#include "eeprom.h"
-#include "menu.h"
+#include "eeprom.h"
 #include "timer0.h"
 #include "uart0.h"
 #include "rc.h"
 #include "externalControl.h"
-#include "output.h"
+#include "debug.h"
-#include "attitude.h"
+#include "profiler.h"
-#include "commands.h"
+#include "beeper.h"
 #ifdef USE_DIRECT_GPS
 #define MK3MAG_ADDRESS 3
 #define FALSE   0
 #define TRUE    1
+DebugOut_t debugOut;
+uint8_t requestedAnalogLabel = 255;
-uint8_t requestedDebugLabel = 255;
+uint8_t requestedProfilerLabel = 255;
-uint8_t request_verInfo = FALSE;
+uint8_t request_verInfo;
-uint8_t request_externalControl = FALSE;
+uint8_t request_externalControl;
-uint8_t request_display = FALSE;
+uint8_t request_display;
-uint8_t request_display1 = FALSE;
+uint8_t request_display1;
-uint8_t request_debugData = FALSE;
+uint8_t request_debugData;
-uint8_t request_data3D = FALSE;
+uint8_t request_profilerData;
-uint8_t request_PPMChannels = FALSE;
+uint8_t request_PPMChannels;
+uint8_t request_outputTest;
-uint8_t request_motorTest = FALSE;
+uint8_t request_variables;
-uint8_t request_variables = FALSE;
+uint8_t request_OSD;
-uint8_t request_OSD = FALSE;
+uint8_t request_DCM_matrix;
 #define request_OSD             (1<<10)
 */
-//uint16_t request = 0;
-uint8_t displayLine = 0;
+//uint16_t request = 0;
 volatile uint8_t txd_buffer[TXD_BUFFER_LEN];
 volatile uint8_t rxd_buffer_locked = FALSE;
 volatile uint8_t rxd_buffer[RXD_BUFFER_LEN];
-volatile uint8_t txd_complete = TRUE;
+volatile uint8_t txd_complete;
-volatile uint8_t receivedBytes = 0;
+volatile uint8_t receivedBytes;
-volatile uint8_t *pRxData = 0;
+volatile uint8_t *pRxData;
-volatile uint8_t rxDataLen = 0;
+volatile uint8_t rxDataLen;
-uint8_t motorTestActive = 0;
+uint8_t outputTestActive;
-uint8_t motorTest[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+uint8_t outputTest[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 uint8_t confirmFrame;
 typedef struct {
         int16_t heading;
 }__attribute__((packed)) Heading_t;
+IMUData imuData;
-Data3D_t data3D;
+uint16_t debugDataTimer;
-uint16_t debugData_timer;
+uint16_t profilerDataTimer;
-uint16_t data3D_timer;
+uint16_t OSDDataTimer;
-uint16_t OSD_timer;
+uint16_t debugDataInterval; // in 1ms
-uint16_t debugData_interval = 0; // in 1ms
+uint16_t profilerDataInterval; // in 1ms
-uint16_t data3D_interval = 0; // in 1ms
-uint16_t OSD_interval = 0;
+uint16_t imuDataInterval; // in 1ms
+uint16_t OSDDataInterval;
+#ifdef USE_DIRECT_GPS
+int16_t toMk3MagTimer;
+#endif
+// keep lables in flash to save 512 bytes of sram space
+           //1234567890123456
+const char analogLabel0[]  PROGMEM = "AngleRoll";
+const char analogLabel1[]  PROGMEM = "AnglePitch";
+const char analogLabel2[]  PROGMEM = "AngleYaw";
+const char analogLabel3[]  PROGMEM = "GyroX(Roll)";
+const char analogLabel4[]  PROGMEM = "GyroY(Pitch)";
+const char analogLabel5[]  PROGMEM = "GyroZ(Yaw)";
+const char analogLabel6[]  PROGMEM = "AccX(0.01m/s^2)";
+const char analogLabel7[]  PROGMEM = "AccY(0.01m/s^2)";
+const char analogLabel8[]  PROGMEM = "AccZ(0.01m/s^2)";
+const char analogLabel9[]  PROGMEM = "RC pitch";
+const char analogLabel10[] PROGMEM = "RC yaw";
+const char analogLabel11[] PROGMEM = "RC throttle";
+const char analogLabel12[] PROGMEM = "Roll";
+const char analogLabel13[] PROGMEM = "Pitch";
+const char analogLabel14[] PROGMEM = "rollControl";
+const char analogLabel15[] PROGMEM = "pitchControl";
+const char analogLabel16[] PROGMEM = "M1";
+const char analogLabel17[] PROGMEM = "M2";
+const char analogLabel18[] PROGMEM = "M3";
+const char analogLabel19[] PROGMEM = "M4";
+const char analogLabel20[] PROGMEM = "flightmode";
+const char analogLabel21[] PROGMEM = "Att freq";
+const char analogLabel22[] PROGMEM = "Height[dm]";
+const char analogLabel23[] PROGMEM = "dHeight";
+const char analogLabel24[] PROGMEM = "attitudeSumCount";
+const char analogLabel25[] PROGMEM = "simpleAirPressure";
+const char analogLabel26[] PROGMEM = "OCR0A";
-#ifdef USE_DIRECT_GPS
+const char analogLabel27[] PROGMEM = "filteredAirPressure";
-int16_t toMk3MagTimer;
+const char analogLabel28[] PROGMEM = "height";
-#endif
+const char analogLabel29[] PROGMEM = "Gyro Act Cont.";
+const char analogLabel30[] PROGMEM = "GPS altitude";
-// keep lables in flash to save 512 bytes of sram space
+const char analogLabel31[] PROGMEM = "GPS vert accura";
-const prog_uint8_t ANALOG_LABEL[32][16] = {
-                //1234567890123456
+PGM_P ANALOG_LABELS[] PROGMEM = {
-                "AnglePitch      ", //0
+    analogLabel0,
-                "AngleRoll       ",
+    analogLabel1,
-                "AngleYaw        ",
+    analogLabel2,
-                "GyroPitch       ",
+    analogLabel3,
-                "GyroRoll        ",
+    analogLabel4,
-                "GyroYaw         ", //5
+    analogLabel5,
-                "AccPitch(0.1deg)",
+    analogLabel6,
-                "AccRoll(0.1deg) ",
+    analogLabel7,
-                "AccZ            ",
+    analogLabel8,
-                "RC pitch        ",
+    analogLabel9,
-                "RC roll         ", //10
+    analogLabel10,
-                "                ",
+    analogLabel11,
-        "zerothOrderCorr ",
+    analogLabel12,
-                "DriftCompPitch  ",
+    analogLabel13,
-                "DriftCompRoll   ",
+    analogLabel14,
-                "GActivityDivider", //15
+    analogLabel15,
-                "AccPitch        ",
+    analogLabel16,
-                "AccRoll         ",
+    analogLabel17,
-        "CorrectionSum pi",
+    analogLabel18,
-                "CorrectionSum ro",
+    analogLabel19,
-                "control act wghd", //20
+    analogLabel20,
-                "acc vector wghd ",
+    analogLabel21,
-                "Height[dm]      ",
+    analogLabel22,
-                "dHeight         ",
+    analogLabel23,
-                "acc vector      ",
+    analogLabel24,
-                "EFT             ", //25
+    analogLabel25,
-                "naviPitch       ",
+    analogLabel26,
-                "naviRoll        ",
+    analogLabel27,
-                "Rate Tolerance  ",
+    analogLabel28,
-                "Gyro Act Cont.  ",
+    analogLabel29,
-                "GPS altitude    ", //30
+    analogLabel30,
-                "GPS vert accura "
+    analogLabel31
-  };
+};
         UCSR0B |= (1 << RXCIE0);
         // enable TX-Interrupt
         UCSR0B |= (1 << TXCIE0);
         // initialize the debug timer
+        debugDataTimer = setDelay(debugDataInterval);
-        debugData_timer = setDelay(debugData_interval);
+        profilerDataTimer = setDelay(profilerDataInterval);
         // unlock rxd_buffer
         rxd_buffer_locked = FALSE;
         if (rxd_buffer_locked)
                 return; // if rxd buffer is locked immediately return
         // the rxd buffer is unlocked
-        if ((ptr_rxd_buffer == 0) && (c == '#')) { // if rxd buffer is empty and syncronisation character is received
+        if ((ptr_rxd_buffer == 0) && (c == '#')) { // if rxd buffer is empty and synchronization character is received
                 rxd_buffer[ptr_rxd_buffer++] = c; // copy 1st byte to buffer
                 checksum = c; // init checksum
+        }
-        else if (ptr_rxd_buffer < RXD_BUFFER_LEN) { // collect incomming bytes
+        else if (ptr_rxd_buffer < RXD_BUFFER_LEN) { // collect incoming bytes
                 if (c != '\r') { // no termination character
                         rxd_buffer[ptr_rxd_buffer++] = c; // copy byte to rxd buffer
                         checksum += c; // update checksum
         UDR0 = txd_buffer[0]; // initiates the transmittion (continued in the TXD ISR)
+}
 // --------------------------------------------------------------------------
 // application example:
-// sendOutData('A', FC_ADDRESS, 2, (uint8_t *)&request_DebugLabel, sizeof(request_DebugLabel), label, 16);
+// sendData('A', FC_ADDRESS, 2, (uint8_t *)&request_DebugLabel, sizeof(request_DebugLabel), label, 16);
 /*
- void sendOutData(uint8_t cmd, uint8_t addr, uint8_t numofbuffers, ...) { // uint8_t *pdata, uint8_t len, ...
+ void sendData(uint8_t cmd, uint8_t addr, uint8_t numofbuffers, ...) { // uint8_t *pdata, uint8_t len, ...
  va_list ap;
  uint16_t txd_bufferIndex = 0;
  uint8_t *currentBuffer;
  uint8_t currentBufferIndex;
  va_end(ap);
  Addchecksum(pt); // add checksum after data block and initates the transmission
+ }
  */
-void sendOutData(uint8_t cmd, uint8_t addr, uint8_t numofbuffers, ...) { // uint8_t *pdata, uint8_t len, ...
+void sendData(uint8_t cmd, uint8_t addr, uint8_t numofbuffers, ...) { // uint8_t *pdata, uint8_t len, ...
         va_list ap;
         uint16_t pt = 0;
         uint8_t a, b, c;
         rxDataLen = ptrOut - 3;
+}
 // --------------------------------------------------------------------------
 void usart0_processRxData(void) {
-        // We control the motorTestActive var from here: Count it down.
+        // We control the outputTestActive var from here: Count it down.
-        if (motorTestActive)
+        if (outputTestActive)
-                motorTestActive--;
+          outputTestActive--;
         // if data in the rxd buffer are not locked immediately return
         if (!rxd_buffer_locked)
+                return;
                 return;
         uint8_t tempchar[3];
         decode64(); // decode data block in rxd_buffer
                 magneticHeading = ((Heading_t *)pRxData)->heading;
                 // compassOffCourse = ((540 + compassHeading - compassCourse) % 360) - 180;
                 break;
 #endif
                 case 't': // motor test
-                        if (rxDataLen > 20) {
-                                memcpy(&motorTest[0], (uint8_t*) pRxData, sizeof(motorTest));
+                        memcpy(&outputTest[0], (uint8_t*) pRxData, /*sizeof(outputTest)*/ 12); // 12 is an mktool limitation.
-                        } else {
-                                memcpy(&motorTest[0], (uint8_t*) pRxData, 4);
+                        outputTestActive = 255;
-                        }
+                        // Huh??
-                        motorTestActive = 255;
                         externalControlActive = 255;
                         break;
                 case 'n':// Read motor mixer
             tempchar[0] = EEMIXER_REVISION;
-            tempchar[1] = sizeof(MotorMixer_t);
+            tempchar[1] = sizeof(OutputMixer_t);
             while (!txd_complete)
                 ; // wait for previous frame to be sent
-                        sendOutData('N', FC_ADDRESS, 2, &tempchar, 2, (uint8_t*)&motorMixer, sizeof(motorMixer));
+                        sendData('N', FC_ADDRESS, 2, &tempchar, 2, (uint8_t*)&outputMixer, sizeof(OutputMixer_t));
                         break;
                 case 'm':// "Set Mixer Table
-                        if (pRxData[0] == EEMIXER_REVISION && (pRxData[1] == sizeof(MotorMixer_t))) {
+                        if (pRxData[0] == EEMIXER_REVISION && (pRxData[1] == sizeof(OutputMixer_t))) {
-                                memcpy(&motorMixer, (uint8_t*)&pRxData[2], sizeof(motorMixer));
+                                memcpy(&outputMixer, (uint8_t*)&pRxData[2], sizeof(OutputMixer_t));
-                                motorMixer_writeToEEProm();
+                                outputMixer_writeToEEProm();
                                 while (!txd_complete)
                                         ; // wait for previous frame to be sent
                                 tempchar[0] = 1;
                         } else {
                                 tempchar[0] = 0;
+                        }
-                        sendOutData('M', FC_ADDRESS, 1, &tempchar, 1);
+                        sendData('M', FC_ADDRESS, 1, &tempchar, 1);
                         break;
         case 'i':// Read IMU configuration
             tempchar[0] = IMUCONFIG_REVISION;
             tempchar[1] = sizeof(IMUConfig);
             while (!txd_complete)
                 ; // wait for previous frame to be sent
-            sendOutData('I', FC_ADDRESS, 2, &tempchar, 2, (uint8_t *) &IMUConfig, sizeof(IMUConfig));
+            sendData('I', FC_ADDRESS, 2, &tempchar, 2, (uint8_t *) &IMUConfig, sizeof(IMUConfig));
             break;
         case 'j':// Save IMU configuration
           if (!(MKFlags & MKFLAG_MOTOR_RUN)) // save settings only if motors are off
               } else {
                   tempchar[0] = 0; //indicate bad data
+              }
               while (!txd_complete)
                   ; // wait for previous frame to be sent
-              sendOutData('J', FC_ADDRESS, 1, &tempchar, 1);
+              sendData('J', FC_ADDRESS, 1, &tempchar, 1);
+          }
           break;
                 case 'q':// request settings
                         tempchar[0] = pRxData[0];
                         tempchar[1] = EEPARAM_REVISION;
                         tempchar[2] = sizeof(staticParams);
                         while (!txd_complete)
                                 ; // wait for previous frame to be sent
-                        sendOutData('Q', FC_ADDRESS, 2, &tempchar, 3, (uint8_t *) &staticParams, sizeof(staticParams));
+                        sendData('Q', FC_ADDRESS, 2, &tempchar, 3, (uint8_t *) &staticParams, sizeof(staticParams));
                         break;
                 case 's': // save settings
                         if (!(MKFlags & MKFLAG_MOTOR_RUN)) // save settings only if motors are off
                                         setActiveParamSet(pRxData[0]);
                                         configuration_paramSetDidChange();
                                         tempchar[0] = getActiveParamSet();
                                         beepNumber(tempchar[0]);
                                 } else {
-                                        tempchar[0] = 0; //indicate bad data
+                                        tempchar[0] = sizeof(staticParams); //indicate bad data
+                                }
                                 while (!txd_complete)
                                         ; // wait for previous frame to be sent
-                                sendOutData('S', FC_ADDRESS, 1, &tempchar, 1);
+                                sendData('S', FC_ADDRESS, 1, &tempchar, 1);
+                        }
                         break;
                 default:
                 } // case FC_ADDRESS:
         default: // any Slave Address
                 switch (rxd_buffer[2]) {
                 case 'a':// request for labels of the analog debug outputs
-                        requestedDebugLabel = pRxData[0];
+                        requestedAnalogLabel = pRxData[0];
-                        if (requestedDebugLabel > 31)
+                        if (requestedAnalogLabel > 31)
-                                requestedDebugLabel = 31;
+                                requestedAnalogLabel = 31;
                         break;
                 case 'b': // submit extern control
-                        memcpy(&externalControl, (uint8_t*) pRxData, sizeof(externalControl));
+                        memcpy(&externalControl, (uint8_t*) pRxData, sizeof(ExternalControl_t));
                         confirmFrame = externalControl.frame;
                         externalControlActive = 255;
                         break;
-                case 'h':// request for display columns
-                        remoteKeys |= pRxData[0];
+        case 'd': // request for the debug data
-                        if (remoteKeys)
+            debugDataInterval = (uint16_t) pRxData[0] * 10;
-                                displayLine = 0;
+            if (debugDataInterval > 0)
+                request_debugData = TRUE;
+            break;
+        case 'e': // Requeset for the DCM matrix
-                        request_display = TRUE;
+            request_DCM_matrix = TRUE;
+            break;
+        case 'f':
+            requestedProfilerLabel = pRxData[0];
+            if (requestedProfilerLabel > 15)
+                requestedProfilerLabel = 15;
+            break;
-                        break;
+        case 'u':
-                case 'l':// request for display columns
+            profilerDataInterval = (uint16_t) pRxData[0] * 10;
-                        menuItem = pRxData[0];
+            if (profilerDataInterval > 0)
-                        request_display1 = TRUE;
+                request_profilerData = TRUE;
-                        break;
+            break;
                 case 'o':// request for OSD data (FC style)
-                  OSD_interval = (uint16_t) pRxData[0] * 10;
+                  OSDDataInterval = (uint16_t) pRxData[0] * 10;
                 case 'g':// get external control data
                         request_externalControl = TRUE;
-                        break;
-                case 'd': // request for the debug data
-                        debugData_interval = (uint16_t) pRxData[0] * 10;
-                        if (debugData_interval > 0)
-                                request_debugData = TRUE;
-                        break;
-                case 'c': // request for the 3D data
-                        data3D_interval = (uint16_t) pRxData[0] * 10;
-                        if (data3D_interval > 0)
-                                request_data3D = TRUE;
                         break;
                 default:
                         //unsupported command received
                         break;
+}
 /************************************************************************/
 /* Routine f�r die Serielle Ausgabe                                     */
 /************************************************************************/
-int16_t uart_putchar(int8_t c) {
+int uart_putchar(char c, FILE* fims) {
         if (c == '\n')
-                uart_putchar('\r');
+                uart_putchar('\r', fims);
         // wait until previous character was send
         loop_until_bit_is_set(UCSR0A, UDRE0);
         // send character
         UDR0 = c;
 void usart0_transmitTxData(void) {
         if (!txd_complete)
                 return;
         if (request_verInfo && txd_complete) {
-                sendOutData('V', FC_ADDRESS, 1, (uint8_t *) &versionInfo, sizeof(versionInfo));
+                sendData('V', FC_ADDRESS, 1, (uint8_t *) &versionInfo, sizeof(versionInfo));
                 request_verInfo = FALSE;
+        }
-        if (request_display && txd_complete) {
-                LCD_printMenu();
-                sendOutData('H', FC_ADDRESS, 2, &displayLine, sizeof(displayLine),
-                                &displayBuff[displayLine * 20], 20);
-                displayLine++;
                 if (displayLine >= 4)
-                        displayLine = 0;
+        if (request_display && txd_complete) {
                 request_display = FALSE;
-        }
-        if (request_display1 && txd_complete) {
                 LCD_printMenu();
                 sendOutData('L', FC_ADDRESS, 3, &menuItem, sizeof(menuItem), &maxMenuItem,
-                                sizeof(maxMenuItem), displayBuff, sizeof(displayBuff));
+        if (request_display1 && txd_complete) {
                 request_display1 = FALSE;
+        }
-        }
+        if (requestedAnalogLabel != 0xFF && txd_complete) {
-        if (requestedDebugLabel != 0xFF && txd_complete) { // Texte f�r die Analogdaten
-                uint8_t label[16]; // local sram buffer
+                char label[17]; // local sram buffer
-                memcpy_P(label, ANALOG_LABEL[requestedDebugLabel], 16); // read lable from flash to sram buffer
+                memset(label, ' ', sizeof(label));
+                strcpy_P(label, (PGM_P)pgm_read_word(&(ANALOG_LABELS[requestedAnalogLabel]))); // read label from flash to sram buffer
+                sendData('A', FC_ADDRESS, 2, (uint8_t *) &requestedAnalogLabel, sizeof(requestedAnalogLabel), label, 16);
+                requestedAnalogLabel = 0xFF;
+        }
+    if (requestedProfilerLabel != 0xFF && txd_complete) {
+        char label[17]; // local sram buffer
+        memset(label, ' ', sizeof(label));
-                sendOutData('A', FC_ADDRESS, 2, (uint8_t *) &requestedDebugLabel,
+        strcpy_P(label, (PGM_P)pgm_read_word(&(PROFILER_LABELS[requestedProfilerLabel]))); // read label from flash to sram buffer
-                                sizeof(requestedDebugLabel), label, 16);
+        sendData('F', FC_ADDRESS, 2, (uint8_t *) &requestedProfilerLabel, sizeof(requestedProfilerLabel), label, 16);
-                requestedDebugLabel = 0xFF;
+        requestedProfilerLabel = 0xFF;
+    }
-        if (confirmFrame && txd_complete) { // Datensatz ohne checksum best�tigen
-                sendOutData('B', FC_ADDRESS, 1, (uint8_t*) &confirmFrame, sizeof(confirmFrame));
+        if (confirmFrame && txd_complete) { // Datensatz ohne checksum best�tigen
-                confirmFrame = 0;
+                sendData('B', FC_ADDRESS, 1, (uint8_t*) &confirmFrame, sizeof(confirmFrame));
                 confirmFrame = 0;
+        }
-        if (((debugData_interval && checkDelay(debugData_timer)) || request_debugData)
-                        && txd_complete) {
+        if (((debugDataInterval && checkDelay(debugDataTimer)) || request_debugData) && txd_complete) {
-                sendOutData('D', FC_ADDRESS, 1, (uint8_t *) &debugOut, sizeof(debugOut));
+                sendData('D', FC_ADDRESS, 1, (uint8_t *)&debugOut, sizeof(debugOut));
-                debugData_timer = setDelay(debugData_interval);
+                debugDataTimer = setDelay(debugDataInterval);
+                request_debugData = FALSE;
+        }
-                request_debugData = FALSE;
+    if (((profilerDataInterval && checkDelay(profilerDataTimer)) || request_profilerData) && txd_complete) {
+        sendData('U', FC_ADDRESS, 2, (uint8_t *)&totalProfilerHits, sizeof(totalProfilerHits), (uint8_t *)&activitiesTimerHits, sizeof(activitiesTimerHits));
-        }
+        profilerDataTimer = setDelay(profilerDataInterval);
+        request_profilerData = FALSE;
+    }
         if (((data3D_interval && checkDelay(data3D_timer)) || request_data3D) && txd_complete) {
-                sendOutData('C', FC_ADDRESS, 1, (uint8_t *) &data3D, sizeof(data3D));
+        if (request_DCM_matrix && txd_complete) {
-                data3D.anglePitch = (int16_t) (attitude[PITCH] / (GYRO_DEG_FACTOR_PITCHROLL/10)); // convert to multiple of 0.1 deg
+                /*
-                data3D.angleRoll = (int16_t) (attitude[ROLL] / (GYRO_DEG_FACTOR_PITCHROLL/10)); // convert to multiple of 0.1 deg
+                sendData('E', FC_ADDRESS, 1,
-                data3D.heading = (int16_t) (heading / (GYRO_DEG_FACTOR_YAW/10)); // convert to multiple of 0.1 deg
+                                (uint8_t *) &dcmGyro, sizeof(dcmGyro));
-                data3D_timer = setDelay(data3D_interval);
+                */
-                request_data3D = FALSE;
+                request_DCM_matrix = FALSE;
                 toMk3Mag.attitude[0] = (int16_t)(attitude[PITCH] / (GYRO_DEG_FACTOR_PITCHROLL/10)); // approx. 0.1 deg
                 toMk3Mag.attitude[1] = (int16_t)(attitude[ROLL] / (GYRO_DEG_FACTOR_PITCHROLL/10)); // approx. 0.1 deg
                 toMk3Mag.userParam[0] = dynamicParams.userParams[0];
                 toMk3Mag.userParam[1] = dynamicParams.userParams[1];
                 toMk3Mag.calState = compassCalState;
-                sendOutData('w', MK3MAG_ADDRESS, 1,(uint8_t *) &toMk3Mag,sizeof(toMk3Mag));
+                sendData('w', MK3MAG_ADDRESS, 1,(uint8_t *) &toMk3Mag,sizeof(toMk3Mag));
                 // the last state is 5 and should be send only once to avoid multiple flash writing
                 if(compassCalState > 4) compassCalState = 0;
                 toMk3MagTimer = setDelay(99);
+        }
 #endif
-        if (request_motorTest && txd_complete) {
+        if (request_outputTest && txd_complete) {
-                sendOutData('T', FC_ADDRESS, 0);
+                sendData('T', FC_ADDRESS, 0);
-                request_motorTest = FALSE;
+                request_outputTest = FALSE;
+        }
         if (request_PPMChannels && txd_complete) {
-                uint8_t length = MAX_CHANNELS;
+                uint8_t length = MAX_CONTROLCHANNELS;
-                sendOutData('P', FC_ADDRESS, 2, &length, 1, (uint8_t*)&PPM_in, sizeof(PPM_in));
+                sendData('P', FC_ADDRESS, 2, &length, 1, (uint8_t*)&PPM_in, sizeof(PPM_in));
                 request_PPMChannels = FALSE;
         }
         if (request_variables && txd_complete) {
-                sendOutData('X', FC_ADDRESS, 1, (uint8_t *) &variables, sizeof(variables));
+                sendData('X', FC_ADDRESS, 1, (uint8_t *) &variables, sizeof(variables));
                 request_variables = FALSE;
+        }
 #ifdef USE_DIRECT_GPS
         if (((OSD_interval && checkDelay(OSD_timer)) || request_OSD) && txd_complete) {
           int32_t height = analog_getHeight();
           data3D.anglePitch = (int16_t) (attitude[PITCH] / (GYRO_DEG_FACTOR_PITCHROLL/10)); // convert to multiple of 0.1 deg
           data3D.angleRoll = (int16_t) (attitude[ROLL] / (GYRO_DEG_FACTOR_PITCHROLL/10)); // convert to multiple of 0.1 deg
           data3D.heading = (int16_t) (heading / (GYRO_DEG_FACTOR_YAW/10)); // convert to multiple of 0.1 deg
-          sendOutData('O', FC_ADDRESS, 4, (uint8_t*)&data3D, sizeof(data3D), (uint8_t*)&GPSInfo, sizeof(GPSInfo), (uint8_t*)&height, sizeof(height), (uint8_t*)UBat, sizeof(UBat));
+          sendData('O', FC_ADDRESS, 4, (uint8_t*)&data3D, sizeof(data3D), (uint8_t*)&GPSInfo, sizeof(GPSInfo), (uint8_t*)&height, sizeof(height), (uint8_t*)UBat, sizeof(UBat));
           OSD_timer = setDelay(OSD_interval);

Subversion Repositories FlightCtrl

(root)/branches/dongfang_FC_rewrite/uart0.c - Rev 2164 → 2189