Subversion Repositories FlightCtrl

Rev

Rev 2466 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1 ingob 1
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2
// + www.MikroKopter.com
3
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2050 holgerb 4
// + Software Nutzungsbedingungen (english version: see below)
5
// + der Fa. HiSystems GmbH, Flachsmeerstrasse 2, 26802 Moormerland - nachfolgend Lizenzgeber genannt -
6
// + Der Lizenzgeber räumt dem Kunden ein nicht-ausschließliches, zeitlich und räumlich* unbeschränktes Recht ein, die im den
2230 holgerb 7
// + Mikrocontroller verwendete Firmware für die Hardware Flight-Ctrl, Navi-Ctrl, BL-Ctrl, MK3Mag & PC-Programm MikroKopter-Tool 
2050 holgerb 8
// + - nachfolgend Software genannt - nur für private Zwecke zu nutzen.
9
// + Der Einsatz dieser Software ist nur auf oder mit Produkten des Lizenzgebers zulässig.
10
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11
// + Die vom Lizenzgeber gelieferte Software ist urheberrechtlich geschützt. Alle Rechte an der Software sowie an sonstigen im
12
// + Rahmen der Vertragsanbahnung und Vertragsdurchführung überlassenen Unterlagen stehen im Verhältnis der Vertragspartner ausschließlich dem Lizenzgeber zu.
13
// + Die in der Software enthaltenen Copyright-Vermerke, Markenzeichen, andere Rechtsvorbehalte, Seriennummern sowie
14
// + sonstige der Programmidentifikation dienenden Merkmale dürfen vom Kunden nicht verändert oder unkenntlich gemacht werden.
15
// + Der Kunde trifft angemessene Vorkehrungen für den sicheren Einsatz der Software. Er wird die Software gründlich auf deren
16
// + Verwendbarkeit zu dem von ihm beabsichtigten Zweck testen, bevor er diese operativ einsetzt.
17
// + Die Haftung des Lizenzgebers wird - soweit gesetzlich zulässig - begrenzt in Höhe des typischen und vorhersehbaren
2230 holgerb 18
// + Schadens. Die gesetzliche Haftung bei Personenschäden und nach dem Produkthaftungsgesetz bleibt unberührt. Dem Lizenzgeber steht jedoch der Einwand 
2050 holgerb 19
// + des Mitverschuldens offen.
20
// + Der Kunde trifft angemessene Vorkehrungen für den Fall, dass die Software ganz oder teilweise nicht ordnungsgemäß arbeitet.
21
// + Er wird die Software gründlich auf deren Verwendbarkeit zu dem von ihm beabsichtigten Zweck testen, bevor er diese operativ einsetzt.
22
// + Der Kunde wird er seine Daten vor Einsatz der Software nach dem Stand der Technik sichern.
23
// + Der Kunde ist darüber unterrichtet, dass der Lizenzgeber seine Daten im zur Vertragsdurchführung erforderlichen Umfang
24
// + und auf Grundlage der Datenschutzvorschriften erhebt, speichert, verarbeitet und, sofern notwendig, an Dritte übermittelt.
25
// + *) Die räumliche Nutzung bezieht sich nur auf den Einsatzort, nicht auf die Reichweite der programmierten Software.
26
// + #### ENDE DER NUTZUNGSBEDINGUNGEN ####'
27
// +  Hinweis: Informationen über erweiterte Nutzungsrechte (wie z.B. Nutzung für nicht-private Zwecke) sind auf Anfrage per Email an info(@)hisystems.de verfügbar.
28
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
29
// + Software LICENSING TERMS
30
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
31
// + of HiSystems GmbH, Flachsmeerstrasse 2, 26802 Moormerland, Germany - the Licensor -
2230 holgerb 32
// + The Licensor grants the customer a non-exclusive license to use the microcontroller firmware of the Flight-Ctrl, Navi-Ctrl, BL-Ctrl, and MK3Mag hardware 
2050 holgerb 33
// + (the Software) exclusively for private purposes. The License is unrestricted with respect to time and territory*.
34
// + The Software may only be used with the Licensor's products.
35
// + The Software provided by the Licensor is protected by copyright. With respect to the relationship between the parties to this
36
// + agreement, all rights pertaining to the Software and other documents provided during the preparation and execution of this
37
// + agreement shall be the property of the Licensor.
38
// + The information contained in the Software copyright notices, trademarks, other legal reservations, serial numbers and other
39
// + features that can be used to identify the program may not be altered or defaced by the customer.
40
// + The customer shall be responsible for taking reasonable precautions
41
// + for the safe use of the Software. The customer shall test the Software thoroughly regarding its suitability for the
42
// + intended purpose before implementing it for actual operation. The Licensor's liability shall be limited to the extent of typical and
43
// + foreseeable damage to the extent permitted by law, notwithstanding statutory liability for bodily injury and product
44
// + liability. However, the Licensor shall be entitled to the defense of contributory negligence.
45
// + The customer will take adequate precautions in the case, that the software is not working properly. The customer will test
46
// + the software for his purpose before any operational usage. The customer will backup his data before using the software.
47
// + The customer understands that the Licensor collects, stores and processes, and, where required, forwards, customer data
48
// + to third parties to the extent necessary for executing the agreement, subject to applicable data protection and privacy regulations.
49
// + *) The territory aspect only refers to the place where the Software is used, not its programmed range.
50
// + #### END OF LICENSING TERMS ####
51
// + Note: For information on license extensions (e.g. commercial use), please contact us at info(@)hisystems.de.
52
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1051 killagreg 53
#include <stdarg.h>
54
#include <string.h>
1490 killagreg 55
#include <avr/pgmspace.h>
1 ingob 56
#include "main.h"
57
#include "uart.h"
1438 ingob 58
#include "libfc.h"
1622 killagreg 59
#include "eeprom.h"
1 ingob 60
 
1054 killagreg 61
#define FC_ADDRESS 1
62
#define NC_ADDRESS 2
63
#define MK3MAG_ADDRESS 3
1622 killagreg 64
#define BL_CTRL_ADDRESS 5
1054 killagreg 65
 
1415 killagreg 66
#define ABO_TIMEOUT 4000 // disable abo after 4 seconds
2340 holgerb 67
#define MAX_SENDE_BUFF     220
68
#define MAX_EMPFANGS_BUFF  220
1657 killagreg 69
 
70
#define BLPARAM_REVISION 1
71
#define MASK_SET_PWM_SCALING            0x01
72
#define MASK_SET_CURRENT_LIMIT          0x02
73
#define MASK_SET_TEMP_LIMIT                     0x04
74
#define MASK_SET_CURRENT_SCALING        0x08
75
#define MASK_SET_BITCONFIG                      0x10
76
#define MASK_RESET_CAPCOUNTER           0x20
77
#define MASK_SET_DEFAULT_PARAMS         0x40
78
#define MASK_SET_SAVE_EEPROM            0x80
79
 
1053 killagreg 80
unsigned char GetExternalControl = 0,DebugDisplayAnforderung1 = 0, DebugDisplayAnforderung = 0,DebugDataAnforderung = 0,GetVersionAnforderung = 0, GetPPMChannelAnforderung = 0;
81
unsigned char DisplayLine = 0;
1 ingob 82
unsigned volatile char SioTmp = 0;
83
unsigned volatile char NeuerDatensatzEmpfangen = 0;
84
unsigned volatile char NeueKoordinateEmpfangen = 0;
85
unsigned volatile char UebertragungAbgeschlossen = 1;
86
unsigned volatile char CntCrcError = 0;
87
unsigned volatile char AnzahlEmpfangsBytes = 0;
1441 ingob 88
unsigned volatile char TxdBuffer[MAX_SENDE_BUFF];
89
unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF];
90
 
1051 killagreg 91
unsigned char *pRxData = 0;
92
unsigned char RxDataLen = 0;
1 ingob 93
unsigned volatile char PC_DebugTimeout = 0;
1212 hbuss 94
unsigned volatile char PC_MotortestActive = 0;
1636 ingob 95
unsigned char DebugTextAnforderung = 255;
1051 killagreg 96
 
1 ingob 97
unsigned char PcZugriff = 100;
1212 hbuss 98
unsigned char MotorTest[16];
1036 hbuss 99
unsigned char MeineSlaveAdresse = 1; // Flight-Ctrl
595 hbuss 100
unsigned char ConfirmFrame;
1 ingob 101
struct str_DebugOut    DebugOut;
595 hbuss 102
struct str_ExternControl  ExternControl;
1 ingob 103
struct str_VersionInfo VersionInfo;
693 hbuss 104
struct str_WinkelOut WinkelOut;
1171 hbuss 105
struct str_Data3D Data3D;
1 ingob 106
 
1399 killagreg 107
int Display_Timer, Debug_Timer,Kompass_Timer,Timer3D;
1415 killagreg 108
unsigned int DebugDataIntervall = 0, Intervall3D = 0, Display_Interval = 0;
109
unsigned int AboTimeOut = 0;
1942 holgerb 110
unsigned volatile char ReceiverUpdateModeActive = 0; // 1 = Update      2 = JetiBox-Simulation
693 hbuss 111
 
1490 killagreg 112
const unsigned char ANALOG_TEXT[32][16] PROGMEM =
499 hbuss 113
{
1051 killagreg 114
   //1234567890123456
1175 hbuss 115
    "AngleNick       ", //0
116
    "AngleRoll       ",
1051 killagreg 117
    "AccNick         ",
499 hbuss 118
    "AccRoll         ",
1523 holgerb 119
    "YawGyro         ",
2316 holgerb 120
    "Altitude [0.1m] ", //5
499 hbuss 121
    "AccZ            ",
122
    "Gas             ",
1175 hbuss 123
    "Compass Value   ",
1528 holgerb 124
    "Voltage [0.1V]  ",
1521 killagreg 125
    "Receiver Level  ", //10
126
    "Gyro Compass    ",
127
    "Motor 1         ",
128
    "Motor 2         ",
129
    "Motor 3         ",
130
    "Motor 4         ", //15
2316 holgerb 131
    "16              ",
132
    "17              ",
133
    "18              ",
134
    "19              ",
2230 holgerb 135
    "Servo           ", //20
1521 killagreg 136
    "Hovergas        ",
2230 holgerb 137
    "Current [0.1A]  ",
1501 holgerb 138
    "Capacity [mAh]  ",
1913 holgerb 139
    "Height Setpoint ",
2316 holgerb 140
    "25              ", //25
141
        "26              ", //"26 CPU OverLoad ",
2437 holgerb 142
    "27              ",
1322 hbuss 143
    "I2C-Error       ",
2230 holgerb 144
    "BL Limit        ",
720 ingob 145
    "GPS_Nick        ", //30
146
    "GPS_Roll        "
499 hbuss 147
};
2230 holgerb 148
 
149
 
1 ingob 150
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
151
//++ Sende-Part der Datenübertragung
152
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1561 killagreg 153
ISR(USART0_TX_vect)
1 ingob 154
{
155
 static unsigned int ptr = 0;
156
 unsigned char tmp_tx;
1783 killagreg 157
 
158
 if(!UebertragungAbgeschlossen)
1 ingob 159
  {
160
   ptr++;                    // die [0] wurde schon gesendet
1438 ingob 161
   tmp_tx = TxdBuffer[ptr];
1 ingob 162
   if((tmp_tx == '\r') || (ptr == MAX_SENDE_BUFF))
163
    {
164
     ptr = 0;
165
     UebertragungAbgeschlossen = 1;
166
    }
1561 killagreg 167
   UDR0 = tmp_tx;
1051 killagreg 168
  }
1 ingob 169
  else ptr = 0;
170
}
171
 
172
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
173
//++ Empfangs-Part der Datenübertragung, incl. CRC-Auswertung
174
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1561 killagreg 175
ISR(USART0_RX_vect)
1 ingob 176
{
177
 static unsigned int crc;
178
 static unsigned char crc1,crc2,buf_ptr;
179
 static unsigned char UartState = 0;
180
 unsigned char CrcOkay = 0;
181
 
2230 holgerb 182
 if (ReceiverUpdateModeActive == 1) {   UDR1 = UDR0; return; }          // 1 = Update      
183
 if (ReceiverUpdateModeActive == 2) {   RxdBuffer[0] = UDR0; return; }  // 2 = JetiBox-Simulation 
1783 killagreg 184
 
1561 killagreg 185
 SioTmp = UDR0;
1783 killagreg 186
 
1438 ingob 187
 if(buf_ptr >= MAX_SENDE_BUFF)    UartState = 0;
1051 killagreg 188
 if(SioTmp == '\r' && UartState == 2)
1 ingob 189
  {
190
   UartState = 0;
191
   crc -= RxdBuffer[buf_ptr-2];
192
   crc -= RxdBuffer[buf_ptr-1];
193
   crc %= 4096;
194
   crc1 = '=' + crc / 64;
195
   crc2 = '=' + crc % 64;
196
   CrcOkay = 0;
197
   if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; CntCrcError++;};
198
   if(!NeuerDatensatzEmpfangen && CrcOkay) // Datensatz schon verarbeitet
199
    {
1051 killagreg 200
     NeuerDatensatzEmpfangen = 1;
201
         AnzahlEmpfangsBytes = buf_ptr + 1;
1 ingob 202
     RxdBuffer[buf_ptr] = '\r';
2380 holgerb 203
         if(RxdBuffer[2] == 'R' && !MotorenEin)
1232 hbuss 204
          {
1435 killagreg 205
           LcdClear();
1232 hbuss 206
           wdt_enable(WDTO_250MS); // Reset-Commando
207
           ServoActive = 0;
1253 killagreg 208
          }
1051 killagreg 209
        }
1 ingob 210
  }
211
  else
212
  switch(UartState)
213
  {
214
   case 0:
215
          if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1;  // Startzeichen und Daten schon verarbeitet
216
                  buf_ptr = 0;
217
                  RxdBuffer[buf_ptr++] = SioTmp;
218
                  crc = SioTmp;
219
          break;
220
   case 1: // Adresse auswerten
221
                  UartState++;
222
                  RxdBuffer[buf_ptr++] = SioTmp;
223
                  crc += SioTmp;
224
                  break;
225
   case 2: //  Eingangsdaten sammeln
226
                  RxdBuffer[buf_ptr] = SioTmp;
1490 killagreg 227
                  if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;
1 ingob 228
                  else UartState = 0;
2443 holgerb 229
//if(DebugOut.Analog[] < buf_ptr) DebugOut.Analog[] = buf_ptr;
1 ingob 230
                  crc += SioTmp;
231
                  break;
1051 killagreg 232
   default:
233
          UartState = 0;
1 ingob 234
          break;
235
  }
236
}
237
 
238
 
239
// --------------------------------------------------------------------------
240
void AddCRC(unsigned int wieviele)
241
{
1051 killagreg 242
 unsigned int tmpCRC = 0,i;
1 ingob 243
 for(i = 0; i < wieviele;i++)
244
  {
1438 ingob 245
   tmpCRC += TxdBuffer[i];
1 ingob 246
  }
2340 holgerb 247
//   if(i > MAX_SENDE_BUFF - 3) tmpCRC += 11; 
1 ingob 248
   tmpCRC %= 4096;
1438 ingob 249
   TxdBuffer[i++] = '=' + tmpCRC / 64;
250
   TxdBuffer[i++] = '=' + tmpCRC % 64;
251
   TxdBuffer[i++] = '\r';
1 ingob 252
  UebertragungAbgeschlossen = 0;
1561 killagreg 253
  UDR0 = TxdBuffer[0];
2340 holgerb 254
//if(DebugOut.Analog[] < i) DebugOut.Analog[] = i;
1 ingob 255
}
256
 
257
 
258
// --------------------------------------------------------------------------
1056 killagreg 259
void SendOutData(unsigned char cmd,unsigned char address, unsigned char BufferAnzahl, ...) //unsigned char *snd, unsigned char len)
1 ingob 260
{
1051 killagreg 261
 va_list ap;
1 ingob 262
 unsigned int pt = 0;
263
 unsigned char a,b,c;
264
 unsigned char ptr = 0;
265
 
1051 killagreg 266
 unsigned char *snd = 0;
267
 int len = 0;
268
 
1438 ingob 269
 TxdBuffer[pt++] = '#';                         // Startzeichen
270
 TxdBuffer[pt++] = 'a' + address;               // Adresse (a=0; b=1,...)
271
 TxdBuffer[pt++] = cmd;                         // Commando
1 ingob 272
 
1051 killagreg 273
 va_start(ap, BufferAnzahl);
274
 if(BufferAnzahl)
275
 {
276
                snd = va_arg(ap, unsigned char*);
277
                len = va_arg(ap, int);
278
                ptr = 0;
279
                BufferAnzahl--;
280
 }
1 ingob 281
 while(len)
282
  {
1051 killagreg 283
        if(len)
284
        {
285
           a = snd[ptr++];
286
           len--;
287
           if((!len) && BufferAnzahl)
288
                {
289
                        snd = va_arg(ap, unsigned char*);
290
                        len = va_arg(ap, int);
291
                        ptr = 0;
292
                        BufferAnzahl--;
293
                }
294
        }
295
        else a = 0;
296
        if(len)
297
        {
298
                b = snd[ptr++];
299
                len--;
300
                if((!len) && BufferAnzahl)
301
                {
302
                        snd = va_arg(ap, unsigned char*);
303
                        len = va_arg(ap, int);
304
                        ptr = 0;
305
                        BufferAnzahl--;
306
                }
307
        }
308
        else b = 0;
309
        if(len)
310
        {
311
                c = snd[ptr++];
312
                len--;
313
                if((!len) && BufferAnzahl)
314
                {
315
                        snd = va_arg(ap, unsigned char*);
316
                        len = va_arg(ap, int);
317
                        ptr = 0;
318
                        BufferAnzahl--;
319
                }
320
        }
321
        else c = 0;
1438 ingob 322
   TxdBuffer[pt++] = '=' + (a >> 2);
323
   TxdBuffer[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4));
324
   TxdBuffer[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6));
325
   TxdBuffer[pt++] = '=' + ( c & 0x3f);
1 ingob 326
  }
1051 killagreg 327
 va_end(ap);
1 ingob 328
 AddCRC(pt);
329
}
330
 
331
// --------------------------------------------------------------------------
1051 killagreg 332
void Decode64(void)  // die daten werden im rx buffer dekodiert, das geht nur, weil aus 4 byte immer 3 gemacht werden.
1 ingob 333
{
334
 unsigned char a,b,c,d;
2230 holgerb 335
 unsigned char x,y,z;
1051 killagreg 336
 unsigned char ptrIn = 3; // start at begin of data block
337
 unsigned char ptrOut = 3;
338
 unsigned char len = AnzahlEmpfangsBytes - 6; // von der Gesamtbytezahl eines Frames gehen 3 Bytes des Headers  ('#',Addr, Cmd) und 3 Bytes des Footers (CRC1, CRC2, '\r') ab.
339
 
2230 holgerb 340
 while(len)
1 ingob 341
  {
342
   a = RxdBuffer[ptrIn++] - '=';
343
   b = RxdBuffer[ptrIn++] - '=';
344
   c = RxdBuffer[ptrIn++] - '=';
345
   d = RxdBuffer[ptrIn++] - '=';
346
 
2230 holgerb 347
   x = (a << 2) | (b >> 4);
348
   y = ((b & 0x0f) << 4) | (c >> 2);
349
   z = ((c & 0x03) << 6) | d;
350
 
351
   if(len--) RxdBuffer[ptrOut++] = x; else break;
352
   if(len--) RxdBuffer[ptrOut++] = y; else break;
353
   if(len--) RxdBuffer[ptrOut++] = z;   else break;
1 ingob 354
  }
1051 killagreg 355
        pRxData = (unsigned char*)&RxdBuffer[3]; // decodierte Daten beginnen beim 4. Byte
356
        RxDataLen = ptrOut - 3;  // wie viele Bytes wurden dekodiert?
1 ingob 357
 
358
}
359
 
360
// --------------------------------------------------------------------------
361
void BearbeiteRxDaten(void)
362
{
363
 if(!NeuerDatensatzEmpfangen) return;
364
 
1665 killagreg 365
        unsigned char tempchar1, tempchar2;
1056 killagreg 366
        Decode64(); // dekodiere datenblock im Empfangsbuffer
1055 ingob 367
        switch(RxdBuffer[1]-'a') // check for Slave Address
1054 killagreg 368
        {
369
                case FC_ADDRESS: // FC special commands
370
                switch(RxdBuffer[2])
371
                {
372
                        case 'K':// Kompasswert
373
                                        memcpy((unsigned char *)&KompassValue , (unsigned char *)pRxData, sizeof(KompassValue));
1941 holgerb 374
//                                      KompassRichtung = ((540 + KompassValue - KompassSollWert) % 360) - 180;
1054 killagreg 375
                                        break;
376
                        case 't':// Motortest
1212 hbuss 377
                                if(AnzahlEmpfangsBytes > 20) memcpy(&MotorTest[0], (unsigned char *)pRxData, sizeof(MotorTest));
378
                                else memcpy(&MotorTest[0], (unsigned char *)pRxData, 4);
379
                                        PC_MotortestActive = 240;
1065 killagreg 380
                                        //while(!UebertragungAbgeschlossen);
381
                                        //SendOutData('T', MeineSlaveAdresse, 0);
1054 killagreg 382
                                        PcZugriff = 255;
383
                                        break;
1053 killagreg 384
 
1209 hbuss 385
                        case 'n':// "Get Mixer
386
                                        while(!UebertragungAbgeschlossen);
1622 killagreg 387
                    SendOutData('N', FC_ADDRESS, 1, (unsigned char *) &Mixer, sizeof(Mixer) - 1);
1636 ingob 388
                                        Debug("Mixer lesen");
1209 hbuss 389
                                        break;
390
 
391
                        case 'm':// "Write Mixer
1622 killagreg 392
                    if(pRxData[0] == EEMIXER_REVISION)
1521 killagreg 393
                                        {
1622 killagreg 394
                       memcpy(&Mixer, (unsigned char *)pRxData, sizeof(Mixer) - 1);
395
                       MixerTable_WriteToEEProm();
1211 hbuss 396
                                           tempchar1 = 1;
1765 killagreg 397
                                           VersionInfo.HardwareError[1] &= ~FC_ERROR1_MIXER;
1521 killagreg 398
                                        }
1622 killagreg 399
                    else
400
                    {
401
                                                tempchar1 = 0;
402
                                        }
403
                                        while(!UebertragungAbgeschlossen);
1211 hbuss 404
                                        SendOutData('M', FC_ADDRESS, 1, &tempchar1, sizeof(tempchar1));
1209 hbuss 405
                                        break;
406
 
1054 killagreg 407
                        case 'p': // get PPM Channels
408
                                        GetPPMChannelAnforderung = 1;
1377 hbuss 409
                                        PcZugriff = 255;
1054 killagreg 410
                                        break;
1053 killagreg 411
 
1054 killagreg 412
                        case 'q':// "Get"-Anforderung für Settings
413
                                        // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
2416 holgerb 414
                                   if(!MotorenEin)
415
                                   {
1761 killagreg 416
                                        if((10 <= pRxData[0]) && (pRxData[0] < 20))
1054 killagreg 417
                                        {
1761 killagreg 418
                                                tempchar1 = pRxData[0] - 10;
419
                                                if(tempchar1< 1) tempchar1 = 1; // limit to 1
420
                                                else if(tempchar1 > 5) tempchar1 = 5; // limit to 5
421
                                                SetDefaultParameter(tempchar1, 1);
1054 killagreg 422
                                        }
1761 killagreg 423
                                        else if((20 <= pRxData[0]) && (pRxData[0] < 30))
424
                                        {
425
                                                tempchar1 = pRxData[0] - 20;
426
                                                if(tempchar1< 1) tempchar1 = 1; // limit to 1
427
                                                else if(tempchar1 > 5) tempchar1 = 5; // limit to 5
428
                                                SetDefaultParameter(tempchar1, 0);
429
                                        }
430
                                        else
431
                                        {
432
                                                tempchar1 = pRxData[0];
433
                                                if(tempchar1 == 0xFF)
434
                                                {
435
                                                        tempchar1 = GetActiveParamSet();
436
                                                }
437
                                                if(tempchar1< 1) tempchar1 = 1; // limit to 1
438
                                                else if(tempchar1 > 5) tempchar1 = 5; // limit to 5
439
                                                // load requested parameter set
440
                                                ParamSet_ReadFromEEProm(tempchar1);
441
                                        }
2416 holgerb 442
                                        LipoDetection(0);
443
                                   } else tempchar1 = GetActiveParamSet();     
1054 killagreg 444
                                        while(!UebertragungAbgeschlossen);
1622 killagreg 445
                                        SendOutData('Q', FC_ADDRESS, 2, &tempchar1, sizeof(tempchar1), (unsigned char *) &EE_Parameter, sizeof(EE_Parameter) - 1);
1636 ingob 446
                                        Debug("Lese Setting %d", tempchar1);
1054 killagreg 447
                                        break;
1051 killagreg 448
 
1054 killagreg 449
                        case 's': // Parametersatz speichern
1862 holgerb 450
                                        if((1 <= pRxData[0]) && (pRxData[0] <= 5) && (pRxData[1] == EEPARAM_REVISION) && MotorenEin == 0) // check for setting to be in range
1054 killagreg 451
                                        {
1622 killagreg 452
                                                memcpy(&EE_Parameter, (uint8_t*)&pRxData[1], sizeof(EE_Parameter) - 1);
453
                                                ParamSet_WriteToEEProm(pRxData[0]);
1054 killagreg 454
                                                Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;
455
                                                Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;
1622 killagreg 456
                                                tempchar1 = GetActiveParamSet();
1054 killagreg 457
                                        }
1058 killagreg 458
                                        else
459
                                        {
460
                                                tempchar1 = 0; // mark in response an invlid setting
461
                                        }
462
                                        while(!UebertragungAbgeschlossen);
463
                                        SendOutData('S', FC_ADDRESS, 1, &tempchar1, sizeof(tempchar1));
2390 holgerb 464
                                        if(!MotorenEin)
465
                                         {
466
                                          Piep(tempchar1,110);
467
                                          LipoDetection(0);
468
                                         }
1626 killagreg 469
                                        LIBFC_ReceiverInit(EE_Parameter.Receiver);
1054 killagreg 470
                                        break;
1405 hbuss 471
                        case 'f': // auf anderen Parametersatz umschalten
2340 holgerb 472
                                        if(MotorenEin) break;
1622 killagreg 473
                                if((1 <= pRxData[0]) && (pRxData[0] <= 5)) ParamSet_ReadFromEEProm(pRxData[0]);
474
                                        tempchar1 = GetActiveParamSet();
1405 hbuss 475
                                        while(!UebertragungAbgeschlossen);
476
                                        SendOutData('F', FC_ADDRESS, 1, &tempchar1, sizeof(tempchar1));
2390 holgerb 477
                                        if(!MotorenEin)
478
                                         {
479
                                          Piep(tempchar1,110);
480
                                          LipoDetection(0);
481
                                         }
1626 killagreg 482
                                        LIBFC_ReceiverInit(EE_Parameter.Receiver);
1405 hbuss 483
                                        break;
1391 killagreg 484
                        case 'y':// serial Potis
2340 holgerb 485
                                        for(tempchar1 = 0; tempchar1 < 12; tempchar1++) PPM_in[SERIAL_POTI_START + tempchar1] = (signed char) pRxData[tempchar1];
1391 killagreg 486
                                        break;
1662 killagreg 487
                        case 'u': // request BL parameter
488
                                Debug("Reading BL %d", pRxData[0]);
489
                                // try to read BL configuration
1665 killagreg 490
                                tempchar2 = I2C_ReadBLConfig(pRxData[0]);
1673 killagreg 491
                                if(tempchar2 == BLCONFIG_SUCCESS) tempchar1 = 1;
492
                                else tempchar1 = 0;
493
                                while(!UebertragungAbgeschlossen); // wait for previous frame to be sent
1674 ingob 494
                                SendOutData('U', FC_ADDRESS, 4, &tempchar1, sizeof(tempchar1), &tempchar2, sizeof(tempchar2), &pRxData[0], 1, &BLConfig, sizeof(BLConfig_t));
1662 killagreg 495
                                break;
496
                        case 'w': // write BL parameter
497
                                Debug("Writing BL %d", pRxData[0]);
498
                                if(RxDataLen >= 1+sizeof(BLConfig_t))
499
                                {
500
                                        memcpy(&BLConfig, (uint8_t*)(&pRxData[1]), sizeof(BLConfig_t));
1665 killagreg 501
                                        tempchar2 = I2C_WriteBLConfig(pRxData[0]);
502
                                        if(tempchar2 == BLCONFIG_SUCCESS) tempchar1 = 1;
503
                                        else tempchar1 = 0; // indicate error
1662 killagreg 504
                                        while(!UebertragungAbgeschlossen); // wait for previous frame to be sent
1665 killagreg 505
                                        SendOutData('W', FC_ADDRESS,2, &tempchar1, sizeof(tempchar1), &tempchar2, sizeof(tempchar2));
1662 killagreg 506
                                }
507
                                break;
1783 killagreg 508
                        case 'j':
1942 holgerb 509
                                if(MotorenEin) break;
1783 killagreg 510
                                tempchar1 = LIBFC_GetCPUType();
511
                                if((tempchar1 == CPU_ATMEGA644P) || (tempchar1 == CPU_ATMEGA1284P))
1782 ingob 512
                                {
1783 killagreg 513
                                        uint16_t ubrr = (uint16_t) ((uint32_t) F_CPU/ (8 * 38400L) - 1);
1782 ingob 514
 
1783 killagreg 515
                                        cli();
1782 ingob 516
 
1783 killagreg 517
                                        // UART0 & UART1 disable RX and TX-Interrupt
518
                                        UCSR0B &= ~((1 << RXCIE0)|(1 << TXCIE0));
519
                                        UCSR1B &= ~((1 << RXCIE1)|(1 << TXCIE1));
520
 
521
                                        // UART0 & UART1 disable receiver and transmitter
522
                                        UCSR0B &= ~((1 << TXEN0) | (1 << RXEN0));
523
                                        UCSR1B &= ~((1 << TXEN1) | (1 << RXEN1));
524
 
525
                                        // UART0 & UART1 flush receive buffer explicit
526
                                        while ( UCSR1A & (1<<RXC1) ) UDR1;
527
                                        while ( UCSR0A & (1<<RXC0) ) UDR0;
528
 
529
 
1942 holgerb 530
                                        if(pRxData[0] == 1) ReceiverUpdateModeActive = 2;
531
                                        else
532
                                        {           // Jeti or HoTT update
533
//#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
534
                                                if(pRxData[0] == 100)   ubrr = (uint16_t) ((uint32_t) F_CPU/ (8 * 19200L) - 1);  // HoTT
535
//#endif
536
                                                ReceiverUpdateModeActive = 1;
1783 killagreg 537
                                                // UART0 & UART1 set baudrate
538
                                                UBRR1H = (uint8_t)(ubrr>>8);
539
                                                UBRR1L = (uint8_t)ubrr;
540
                                                UBRR0H = UBRR1H;
541
                                                UBRR0L = UBRR1L;
542
                                                // UART1 no parity
543
                                                UCSR1C &= ~(1 << UPM11);
544
                                                UCSR1C &= ~(1 << UPM10);
545
                                                // UART1 8-bit
546
                                                UCSR1B &= ~(1 << UCSZ12);
547
                                                UCSR1C |= (1 << UCSZ11);
548
                                                UCSR1C |= (1 << UCSZ10);
549
                                        }
550
                                        // UART0 & UART1 1 stop bit
551
                                        UCSR1C &= ~(1 << USBS1);
552
                                        UCSR0C &= ~(1 << USBS0);
553
                                        // UART1 clear 9th bit
554
                                        UCSR1B &= ~(1<<TXB81);
555
                                        // enable receiver and transmitter for UART0 and UART1
556
                                        UCSR0B |= (1 << TXEN0) | (1 << RXEN0);
557
                                        UCSR1B |= (1 << TXEN1) | (1 << RXEN1);
558
                                        // enable RX-Interrupt for UART0 and UART1
559
                                        UCSR0B |= (1 << RXCIE0);
560
                                        UCSR1B |= (1 << RXCIE1);
561
                                        // disable other Interrupts
562
                                        TIMSK0 = 0;
563
                                        TIMSK1 = 0;
564
                                        TIMSK2 = 0;
565
 
566
                                        sei();
1777 ingob 567
                                }
568
                                break;
569
 
1056 killagreg 570
                } // case FC_ADDRESS:
1054 killagreg 571
 
572
                default: // any Slave Address
1056 killagreg 573
 
1054 killagreg 574
                switch(RxdBuffer[2])
575
                {
2437 holgerb 576
#ifdef REDUNDANT_FC_SLAVE
2418 holgerb 577
                static unsigned int clear_I;
578
                        case '?':// Serielle Antwort eines BL-Reglers
579
                                        tempchar1 = RxdBuffer[1] - ('a'+11);
580
                                        if(tempchar1 >= MAX_MOTORS) break;
581
                                        memcpy((unsigned char *)&RedundantMotor[tempchar1], (unsigned char *)pRxData, sizeof(RedundantBl_t));
582
                                        if(RedundantMotor[tempchar1].BitSate & BL_BIT_STATE_I2C_OK && clear_I) clear_I--;
2437 holgerb 583
                                        if(!(RedundantMotor[tempchar1].BitSate & BL_BIT_STATE_I2C_OK)) ROT_FLASH;
584
                                        GRN_FLASH;
2418 holgerb 585
                                        if(RedundantMotor[tempchar1].BitSate & BL_BIT_STATE_I2C_BAD)
586
                                        {
2437 holgerb 587
                                        ROT_ON;
2418 holgerb 588
                                         if(clear_I == 0)
589
                                          {
590
                                                SummeNick = 0;
591
                                                SummeRoll = 0;
592
                                                Mess_Integral_Gier = 0;
593
                                          }    
594
                                         clear_I = 500;
595
                                        }
596
//DebugOut.Analog[16] = RedundantMotor[tempchar1].BitSate;
597
//DebugOut.Analog[17]++;
598
//DebugOut.Analog[18] = tempchar1;
599
                                        break;
2437 holgerb 600
#endif
1054 killagreg 601
                        // 't' comand placed here only for compatibility to BL
602
                        case 't':// Motortest
1662 killagreg 603
                                if(AnzahlEmpfangsBytes >= sizeof(MotorTest)) memcpy(&MotorTest[0], (unsigned char *)pRxData, sizeof(MotorTest));
1212 hbuss 604
                                else memcpy(&MotorTest[0], (unsigned char *)pRxData, 4);
1054 killagreg 605
                                        while(!UebertragungAbgeschlossen);
606
                                        SendOutData('T', MeineSlaveAdresse, 0);
1212 hbuss 607
                                        PC_MotortestActive = 250;
1054 killagreg 608
                                        PcZugriff = 255;
1638 holgerb 609
                                        AboTimeOut = SetDelay(ABO_TIMEOUT);
1054 killagreg 610
                                        break;
611
                        // 'K' comand placed here only for compatibility to old MK3MAG software, that does not send the right Slave Address
612
                        case 'K':// Kompasswert
613
                                        memcpy((unsigned char *)&KompassValue , (unsigned char *)pRxData, sizeof(KompassValue));
1941 holgerb 614
//                                      KompassRichtung = ((540 + KompassValue - KompassSollWert) % 360) - 180;
1054 killagreg 615
                                        break;
616
                        case 'a':// Texte der Analogwerte
617
                                        DebugTextAnforderung = pRxData[0];
618
                                        if (DebugTextAnforderung > 31) DebugTextAnforderung = 31;
619
                                        PcZugriff = 255;
620
                                        break;
621
                        case 'b':
622
                                        memcpy((unsigned char *)&ExternControl, (unsigned char *)pRxData, sizeof(ExternControl));
623
                                        ConfirmFrame = ExternControl.Frame;
624
                                        PcZugriff = 255;
625
                                        break;
1171 hbuss 626
                        case 'c': // Poll the 3D-Data
627
                    if(!Intervall3D) { if(pRxData[0]) Timer3D = SetDelay(pRxData[0] * 10);}
628
                                        Intervall3D = pRxData[0] * 10;
1417 killagreg 629
                                        AboTimeOut = SetDelay(ABO_TIMEOUT);
1171 hbuss 630
                                        break;
1054 killagreg 631
                        case 'd': // Poll the debug data
1438 ingob 632
                                        PcZugriff = 255;
1399 killagreg 633
                                        DebugDataIntervall = (unsigned int)pRxData[0] * 10;
1171 hbuss 634
                                        if(DebugDataIntervall > 0) DebugDataAnforderung = 1;
1415 killagreg 635
                                        AboTimeOut = SetDelay(ABO_TIMEOUT);
1054 killagreg 636
                                        break;
637
 
638
                        case 'h':// x-1 Displayzeilen
1059 hbuss 639
                                PcZugriff = 255;
1399 killagreg 640
                                if((pRxData[0] & 0x80) == 0x00) // old format
641
                                        {
642
                                                DisplayLine = 2;
643
                                                Display_Interval = 0;
644
                                        }
645
                                        else // new format
646
                                        {
647
                                                RemoteKeys |= ~pRxData[0];
648
                                                Display_Interval = (unsigned int)pRxData[1] * 10;
649
                                                DisplayLine = 4;
1415 killagreg 650
                                                AboTimeOut = SetDelay(ABO_TIMEOUT);
1399 killagreg 651
                                        }
1054 killagreg 652
                                        DebugDisplayAnforderung = 1;
653
                                        break;
654
 
655
                        case 'l':// x-1 Displayzeilen
1059 hbuss 656
                                PcZugriff = 255;
1054 killagreg 657
                                        MenuePunkt = pRxData[0];
658
                                        DebugDisplayAnforderung1 = 1;
659
                                        break;
660
                        case 'v': // Version-Anforderung und Ausbaustufe
2466 holgerb 661
#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
662
                                        if(RxDataLen > 0 && pRxData[0] == 2) GetVersionAnforderung = 2;
663
                                        else
664
#endif
1054 killagreg 665
                                        GetVersionAnforderung = 1;
666
                                        break;
667
                        case 'g'://
668
                                        GetExternalControl = 1;
669
                                        break;
1657 killagreg 670
 
671
                        default:
672
                                //unsupported command received
673
                                break;
1054 killagreg 674
                }
675
                break; // default:
676
        }
1051 killagreg 677
        NeuerDatensatzEmpfangen = 0;
678
        pRxData = 0;
679
        RxDataLen = 0;
1 ingob 680
}
681
 
682
//############################################################################
683
//Routine für die Serielle Ausgabe
1444 ingob 684
void uart_putchar (char c)
1 ingob 685
//############################################################################
686
{
687
        //Warten solange bis Zeichen gesendet wurde
1561 killagreg 688
        loop_until_bit_is_set(UCSR0A, UDRE0);
1 ingob 689
        //Ausgabe des Zeichens
1561 killagreg 690
        UDR0 = c;
1 ingob 691
}
692
 
693
 
694
//############################################################################
695
//INstallation der Seriellen Schnittstelle
696
void UART_Init (void)
697
//############################################################################
698
{
1561 killagreg 699
        unsigned int ubrr = (unsigned int) ((unsigned long) F_CPU/(8 * USART0_BAUD) - 1);
700
 
1 ingob 701
        //Enable TXEN im Register UCR TX-Data Enable & RX Enable
1561 killagreg 702
        UCSR0B = (1 << TXEN0) | (1 << RXEN0);
1 ingob 703
    // UART Double Speed (U2X)
1561 killagreg 704
        UCSR0A |= (1 << U2X0);
1 ingob 705
        // RX-Interrupt Freigabe
1561 killagreg 706
        UCSR0B |= (1 << RXCIE0);
1 ingob 707
        // TX-Interrupt Freigabe
1561 killagreg 708
        UCSR0B |= (1 << TXCIE0);
709
        // USART0 Baud Rate Register
710
        // set clock divider
711
        UBRR0H = (uint8_t)(ubrr >> 8);
712
        UBRR0L = (uint8_t)ubrr;
1 ingob 713
 
1051 killagreg 714
        Debug_Timer = SetDelay(DebugDataIntervall);
715
        Kompass_Timer = SetDelay(220);
716
 
1058 killagreg 717
        VersionInfo.SWMajor = VERSION_MAJOR;
718
        VersionInfo.SWMinor = VERSION_MINOR;
719
        VersionInfo.SWPatch = VERSION_PATCH;
720
        VersionInfo.ProtoMajor  = VERSION_SERIAL_MAJOR;
2342 holgerb 721
        VersionInfo.reserved1  = 0;
2466 holgerb 722
        VersionInfo.BL_Firmware  = 255;
2342 holgerb 723
    VersionInfo.HWMajor = PlatinenVersion;
1051 killagreg 724
        pRxData = 0;
725
        RxDataLen = 0;
1 ingob 726
}
727
 
728
//---------------------------------------------------------------------------------------------
1051 killagreg 729
void DatenUebertragung(void)
1 ingob 730
{
2418 holgerb 731
 
1415 killagreg 732
        if(!UebertragungAbgeschlossen) return;
1 ingob 733
 
1415 killagreg 734
        if(CheckDelay(AboTimeOut))
735
        {
736
                Display_Interval = 0;
737
                DebugDataIntervall = 0;
1417 killagreg 738
                Intervall3D = 0;
1415 killagreg 739
        }
740
 
1399 killagreg 741
        if(((Display_Interval>0 && CheckDelay(Display_Timer)) || DebugDisplayAnforderung) && UebertragungAbgeschlossen)
1065 killagreg 742
        {
1399 killagreg 743
                if(DisplayLine > 3)// new format
744
                {
1423 hbuss 745
                        Menu();
1399 killagreg 746
                        SendOutData('H', FC_ADDRESS, 1, (uint8_t *)DisplayBuff, 80);
747
                }
748
                else // old format
749
                {
750
                        LCD_printfxy(0,0,"!!! INCOMPATIBLE !!!");
751
                        SendOutData('H', FC_ADDRESS, 2, &DisplayLine, sizeof(DisplayLine), (uint8_t *)DisplayBuff, 20);
752
                        if(DisplayLine++ > 3) DisplayLine = 0;
753
                }
754
                Display_Timer = SetDelay(Display_Interval);
1065 killagreg 755
                DebugDisplayAnforderung = 0;
756
        }
757
        if(DebugDisplayAnforderung1 && UebertragungAbgeschlossen)
758
        {
759
                Menu();
760
                SendOutData('L', FC_ADDRESS, 3, &MenuePunkt, sizeof(MenuePunkt), &MaxMenue, sizeof(MaxMenue), DisplayBuff, sizeof(DisplayBuff));
761
                DebugDisplayAnforderung1 = 0;
762
        }
763
        if(GetVersionAnforderung && UebertragungAbgeschlossen)
764
        {
2466 holgerb 765
#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
766
                if(GetVersionAnforderung == 2) // poll version of NC
767
                {
768
                 struct str_VersionInfo nc;
769
                 nc.SWMajor = NC_Version.Major;
770
                 nc.SWMinor = NC_Version.Minor;
771
                 nc.SWPatch = NC_Version.Patch;
772
                 nc.HWMajor = NC_Version.Hardware;
773
                 nc.HardwareError[0] = 0xff;
774
                 nc.HardwareError[1] = 0xff;
775
                 nc.ProtoMajor = VersionInfo.ProtoMajor;
776
                 nc.BL_Firmware = VersionInfo.BL_Firmware;
777
                 nc.Flags = VersionInfo.Flags;
778
                 nc.reserved1 = 0;
779
                 SendOutData('V', FC_ADDRESS, 1, (unsigned char *) &nc, sizeof(nc));
780
                }
781
                else
782
#endif
783
                {
784
                 SendOutData('V', FC_ADDRESS, 1, (unsigned char *) &VersionInfo, sizeof(VersionInfo));
785
                }
1065 killagreg 786
                GetVersionAnforderung = 0;
1636 ingob 787
                Debug_OK("Version gesendet");
1065 killagreg 788
        }
1 ingob 789
 
1065 killagreg 790
        if(GetExternalControl && UebertragungAbgeschlossen)           // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
791
        {
792
                SendOutData('G',MeineSlaveAdresse, 1, (unsigned char *) &ExternControl, sizeof(ExternControl));
793
                GetExternalControl = 0;
794
        }
1171 hbuss 795
    if(((DebugDataIntervall>0 && CheckDelay(Debug_Timer)) || DebugDataAnforderung) && UebertragungAbgeschlossen)
1 ingob 796
         {
1639 holgerb 797
                  CopyDebugValues();
1276 hbuss 798
          SendOutData('D', FC_ADDRESS, 1, (unsigned char *) &DebugOut,sizeof(DebugOut));
1 ingob 799
          DebugDataAnforderung = 0;
1055 ingob 800
          if(DebugDataIntervall>0) Debug_Timer = SetDelay(DebugDataIntervall);
1051 killagreg 801
         }
1171 hbuss 802
    if(Intervall3D > 0 && CheckDelay(Timer3D) && UebertragungAbgeschlossen)
803
         {
2373 holgerb 804
                  Data3D.Winkel[0] = ToNaviCtrl.IntegralNick;//(int) (IntegralNick / (EE_Parameter.GyroAccFaktor * 4));  // etwa in 0.1 Grad
805
                  Data3D.Winkel[1] = ToNaviCtrl.IntegralRoll;//(int) (IntegralRoll / (EE_Parameter.GyroAccFaktor * 4));  // etwa in 0.1 Grad
1171 hbuss 806
          Data3D.Winkel[2] = (int) ((10 * ErsatzKompass) / GIER_GRAD_FAKTOR);
1685 holgerb 807
                  Data3D.Centroid[0] = SummeNick >> 9;
808
                  Data3D.Centroid[1] = SummeRoll >> 9;
809
                  Data3D.Centroid[2] = Mess_Integral_Gier >> 9;
1171 hbuss 810
          SendOutData('C', FC_ADDRESS, 1, (unsigned char *) &Data3D,sizeof(Data3D));
811
          Timer3D = SetDelay(Intervall3D);
812
         }
499 hbuss 813
    if(DebugTextAnforderung != 255) // Texte für die Analogdaten
814
     {
1490 killagreg 815
                unsigned char label[16]; // local sram buffer
816
                memcpy_P(label, ANALOG_TEXT[DebugTextAnforderung], 16); // read lable from flash to sra
817
      SendOutData('A', FC_ADDRESS, 2, (unsigned char *)&DebugTextAnforderung, sizeof(DebugTextAnforderung),label, 16);
499 hbuss 818
      DebugTextAnforderung = 255;
819
         }
1051 killagreg 820
     if(ConfirmFrame && UebertragungAbgeschlossen)   // Datensatz bestätigen
595 hbuss 821
         {
1054 killagreg 822
                SendOutData('B', FC_ADDRESS, 1, (uint8_t*)&ConfirmFrame, sizeof(ConfirmFrame));
1051 killagreg 823
        ConfirmFrame = 0;
595 hbuss 824
     }
1051 killagreg 825
     if(GetPPMChannelAnforderung && UebertragungAbgeschlossen)
826
     {
1054 killagreg 827
                 SendOutData('P', FC_ADDRESS, 1, (unsigned char *) &PPM_in, sizeof(PPM_in));
1051 killagreg 828
                 GetPPMChannelAnforderung = 0;
829
         }
2427 holgerb 830
#ifndef REDUNDANT_FC_SLAVE
2346 holgerb 831
    if((CheckDelay(Kompass_Timer)) && UebertragungAbgeschlossen)
832
         {
2425 holgerb 833
          if(!NaviDataOkay)  // no external compass needed
834
                   {
835
                    WinkelOut.Winkel[0] = ToNaviCtrl.IntegralNick;//(int) (IntegralNick / (EE_Parameter.GyroAccFaktor * 4));  // etwa in 0.1 Grad
836
                    WinkelOut.Winkel[1] = ToNaviCtrl.IntegralRoll;//(int) (IntegralRoll / (EE_Parameter.GyroAccFaktor * 4));  // etwa in 0.1 Grad
837
                    WinkelOut.UserParameter[0] = Parameter_UserParam1;
838
                    WinkelOut.UserParameter[1] = Parameter_UserParam2;
839
                    SendOutData('k', MK3MAG_ADDRESS, 1, (unsigned char *) &WinkelOut,sizeof(WinkelOut));
840
                   }   
2346 holgerb 841
          if(WinkelOut.CalcState > 4)  WinkelOut.CalcState = 6; // wird dann in SPI auf Null gesetzt
2416 holgerb 842
          if(JustMK3MagConnected) Kompass_Timer = SetDelay(99);
2346 holgerb 843
                  else Kompass_Timer = SetDelay(999);
844
         }
2418 holgerb 845
#endif
846
 
2427 holgerb 847
#ifdef REDUNDANT_FC_SLAVE
2418 holgerb 848
  if(UebertragungAbgeschlossen || MotorenEin)
849
  {
2452 holgerb 850
    static unsigned char who, request;
2418 holgerb 851
    unsigned char SendRedundantMotor[MAX_MOTORS], i;
2452 holgerb 852
    if(!request) { who = (who+1) % RequiredMotors; request = 1;} // nur in jedem 2. Zykus abfragen, weil die Antwort zu lang ist
853
        else request = 0;
2418 holgerb 854
    for(i=0; i<RequiredMotors; i++)
855
     {
2452 holgerb 856
          if(request) SendRedundantMotor[0] = who+1;
857
          else SendRedundantMotor[0] = 0;
2418 holgerb 858
          if(PC_MotortestActive) SendRedundantMotor[0] |= 0x80;
859
      SendRedundantMotor[i+1] = Motor[i].SetPoint;
860
     }
861
         SendOutData('!', FC_ADDRESS, 1, (unsigned char *) &SendRedundantMotor, RequiredMotors+1);
862
  }    
863
#endif
864
 
1636 ingob 865
#ifdef DEBUG                                                                                                                    // only include functions if DEBUG is defined
866
     if(SendDebugOutput && UebertragungAbgeschlossen)
867
     {
868
                 SendOutData('0', FC_ADDRESS, 1, (unsigned char *) &tDebug, sizeof(tDebug));
869
                 SendDebugOutput = 0;
870
         }
1654 killagreg 871
#endif
1 ingob 872
}
873
 
1636 ingob 874