Subversion Repositories FlightCtrl

Rev

Go to most recent revision | Details | 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
2180 killagreg 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
2180 killagreg 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 -
2180 killagreg 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
2012 holgerb 67
#define MAX_SENDE_BUFF     175
68
#define MAX_EMPFANGS_BUFF  175
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         ",
1521 killagreg 120
    "Height Value    ", //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
1983 holgerb 131
    "16              ",
132
    "17              ",
1865 holgerb 133
    "18              ",
134
    "19              ",
854 hbuss 135
    "Servo           ", //20
1521 killagreg 136
    "Hovergas        ",
1523 holgerb 137
    "Current [0.1A]  ",
1501 holgerb 138
    "Capacity [mAh]  ",
1913 holgerb 139
    "Height Setpoint ",
1871 holgerb 140
    "25              ", //25
1936 holgerb 141
    "26              ", //"26 CPU OverLoad ",
1839 holgerb 142
    "Compass Setpoint",
1322 hbuss 143
    "I2C-Error       ",
1761 killagreg 144
    "BL Limit        ",
720 ingob 145
    "GPS_Nick        ", //30
146
    "GPS_Roll        "
499 hbuss 147
};
2180 killagreg 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
 
2180 killagreg 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';
1253 killagreg 203
         if(RxdBuffer[2] == 'R')
1232 hbuss 204
          {
1435 killagreg 205
           LcdClear();
1232 hbuss 206
           wdt_enable(WDTO_250MS); // Reset-Commando
207
           ServoActive = 0;
1253 killagreg 208
          }
1783 killagreg 209
 
1051 killagreg 210
        }
1 ingob 211
  }
212
  else
213
  switch(UartState)
214
  {
215
   case 0:
216
          if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1;  // Startzeichen und Daten schon verarbeitet
217
                  buf_ptr = 0;
218
                  RxdBuffer[buf_ptr++] = SioTmp;
219
                  crc = SioTmp;
220
          break;
221
   case 1: // Adresse auswerten
222
                  UartState++;
223
                  RxdBuffer[buf_ptr++] = SioTmp;
224
                  crc += SioTmp;
225
                  break;
226
   case 2: //  Eingangsdaten sammeln
227
                  RxdBuffer[buf_ptr] = SioTmp;
1490 killagreg 228
                  if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;
1 ingob 229
                  else UartState = 0;
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
  }
247
   tmpCRC %= 4096;
1438 ingob 248
   TxdBuffer[i++] = '=' + tmpCRC / 64;
249
   TxdBuffer[i++] = '=' + tmpCRC % 64;
250
   TxdBuffer[i++] = '\r';
1 ingob 251
  UebertragungAbgeschlossen = 0;
1561 killagreg 252
  UDR0 = TxdBuffer[0];
1 ingob 253
}
254
 
255
 
256
 
257
// --------------------------------------------------------------------------
1056 killagreg 258
void SendOutData(unsigned char cmd,unsigned char address, unsigned char BufferAnzahl, ...) //unsigned char *snd, unsigned char len)
1 ingob 259
{
1051 killagreg 260
 va_list ap;
1 ingob 261
 unsigned int pt = 0;
262
 unsigned char a,b,c;
263
 unsigned char ptr = 0;
264
 
1051 killagreg 265
 unsigned char *snd = 0;
266
 int len = 0;
267
 
1438 ingob 268
 TxdBuffer[pt++] = '#';                         // Startzeichen
269
 TxdBuffer[pt++] = 'a' + address;               // Adresse (a=0; b=1,...)
270
 TxdBuffer[pt++] = cmd;                         // Commando
1 ingob 271
 
1051 killagreg 272
 va_start(ap, BufferAnzahl);
273
 if(BufferAnzahl)
274
 {
275
                snd = va_arg(ap, unsigned char*);
276
                len = va_arg(ap, int);
277
                ptr = 0;
278
                BufferAnzahl--;
279
 }
1 ingob 280
 while(len)
281
  {
1051 killagreg 282
        if(len)
283
        {
284
           a = snd[ptr++];
285
           len--;
286
           if((!len) && BufferAnzahl)
287
                {
288
                        snd = va_arg(ap, unsigned char*);
289
                        len = va_arg(ap, int);
290
                        ptr = 0;
291
                        BufferAnzahl--;
292
                }
293
        }
294
        else a = 0;
295
        if(len)
296
        {
297
                b = snd[ptr++];
298
                len--;
299
                if((!len) && BufferAnzahl)
300
                {
301
                        snd = va_arg(ap, unsigned char*);
302
                        len = va_arg(ap, int);
303
                        ptr = 0;
304
                        BufferAnzahl--;
305
                }
306
        }
307
        else b = 0;
308
        if(len)
309
        {
310
                c = snd[ptr++];
311
                len--;
312
                if((!len) && BufferAnzahl)
313
                {
314
                        snd = va_arg(ap, unsigned char*);
315
                        len = va_arg(ap, int);
316
                        ptr = 0;
317
                        BufferAnzahl--;
318
                }
319
        }
320
        else c = 0;
1438 ingob 321
   TxdBuffer[pt++] = '=' + (a >> 2);
322
   TxdBuffer[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4));
323
   TxdBuffer[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6));
324
   TxdBuffer[pt++] = '=' + ( c & 0x3f);
1 ingob 325
  }
1051 killagreg 326
 va_end(ap);
1 ingob 327
 AddCRC(pt);
328
}
329
 
330
// --------------------------------------------------------------------------
1051 killagreg 331
void Decode64(void)  // die daten werden im rx buffer dekodiert, das geht nur, weil aus 4 byte immer 3 gemacht werden.
1 ingob 332
{
333
 unsigned char a,b,c,d;
1051 killagreg 334
 unsigned char ptrIn = 3; // start at begin of data block
335
 unsigned char ptrOut = 3;
336
 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.
337
 
2180 killagreg 338
 len/=4;
339
 while(len--)
1 ingob 340
  {
341
   a = RxdBuffer[ptrIn++] - '=';
342
   b = RxdBuffer[ptrIn++] - '=';
343
   c = RxdBuffer[ptrIn++] - '=';
344
   d = RxdBuffer[ptrIn++] - '=';
345
 
2180 killagreg 346
   RxdBuffer[ptrOut++] = (a << 2) | (b >> 4);
347
   RxdBuffer[ptrOut++] = ((b & 0x0f) << 4) | (c >> 2);
348
   RxdBuffer[ptrOut++] = ((c & 0x03) << 6) | d;
1 ingob 349
  }
1051 killagreg 350
        pRxData = (unsigned char*)&RxdBuffer[3]; // decodierte Daten beginnen beim 4. Byte
351
        RxDataLen = ptrOut - 3;  // wie viele Bytes wurden dekodiert?
1 ingob 352
 
353
}
354
 
355
// --------------------------------------------------------------------------
356
void BearbeiteRxDaten(void)
357
{
358
 if(!NeuerDatensatzEmpfangen) return;
359
 
1665 killagreg 360
        unsigned char tempchar1, tempchar2;
1056 killagreg 361
        Decode64(); // dekodiere datenblock im Empfangsbuffer
1055 ingob 362
        switch(RxdBuffer[1]-'a') // check for Slave Address
1054 killagreg 363
        {
364
                case FC_ADDRESS: // FC special commands
365
                switch(RxdBuffer[2])
366
                {
367
                        case 'K':// Kompasswert
368
                                        memcpy((unsigned char *)&KompassValue , (unsigned char *)pRxData, sizeof(KompassValue));
1941 holgerb 369
//                                      KompassRichtung = ((540 + KompassValue - KompassSollWert) % 360) - 180;
1054 killagreg 370
                                        break;
371
                        case 't':// Motortest
1212 hbuss 372
                                if(AnzahlEmpfangsBytes > 20) memcpy(&MotorTest[0], (unsigned char *)pRxData, sizeof(MotorTest));
373
                                else memcpy(&MotorTest[0], (unsigned char *)pRxData, 4);
374
                                        PC_MotortestActive = 240;
1065 killagreg 375
                                        //while(!UebertragungAbgeschlossen);
376
                                        //SendOutData('T', MeineSlaveAdresse, 0);
1054 killagreg 377
                                        PcZugriff = 255;
378
                                        break;
1053 killagreg 379
 
1209 hbuss 380
                        case 'n':// "Get Mixer
381
                                        while(!UebertragungAbgeschlossen);
1622 killagreg 382
                    SendOutData('N', FC_ADDRESS, 1, (unsigned char *) &Mixer, sizeof(Mixer) - 1);
1636 ingob 383
                                        Debug("Mixer lesen");
1209 hbuss 384
                                        break;
385
 
386
                        case 'm':// "Write Mixer
1622 killagreg 387
                    if(pRxData[0] == EEMIXER_REVISION)
1521 killagreg 388
                                        {
1622 killagreg 389
                       memcpy(&Mixer, (unsigned char *)pRxData, sizeof(Mixer) - 1);
390
                       MixerTable_WriteToEEProm();
1211 hbuss 391
                                           tempchar1 = 1;
1765 killagreg 392
                                           VersionInfo.HardwareError[1] &= ~FC_ERROR1_MIXER;
1521 killagreg 393
                                        }
1622 killagreg 394
                    else
395
                    {
396
                                                tempchar1 = 0;
397
                                        }
398
                                        while(!UebertragungAbgeschlossen);
1211 hbuss 399
                                        SendOutData('M', FC_ADDRESS, 1, &tempchar1, sizeof(tempchar1));
1209 hbuss 400
                                        break;
401
 
1054 killagreg 402
                        case 'p': // get PPM Channels
403
                                        GetPPMChannelAnforderung = 1;
1377 hbuss 404
                                        PcZugriff = 255;
1054 killagreg 405
                                        break;
1053 killagreg 406
 
1054 killagreg 407
                        case 'q':// "Get"-Anforderung für Settings
408
                                        // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
1761 killagreg 409
                                        if((10 <= pRxData[0]) && (pRxData[0] < 20))
1054 killagreg 410
                                        {
1761 killagreg 411
                                                tempchar1 = pRxData[0] - 10;
412
                                                if(tempchar1< 1) tempchar1 = 1; // limit to 1
413
                                                else if(tempchar1 > 5) tempchar1 = 5; // limit to 5
414
                                                SetDefaultParameter(tempchar1, 1);
1054 killagreg 415
                                        }
1761 killagreg 416
                                        else if((20 <= pRxData[0]) && (pRxData[0] < 30))
417
                                        {
418
                                                tempchar1 = pRxData[0] - 20;
419
                                                if(tempchar1< 1) tempchar1 = 1; // limit to 1
420
                                                else if(tempchar1 > 5) tempchar1 = 5; // limit to 5
421
                                                SetDefaultParameter(tempchar1, 0);
422
                                        }
423
                                        else
424
                                        {
425
                                                tempchar1 = pRxData[0];
426
                                                if(tempchar1 == 0xFF)
427
                                                {
428
                                                        tempchar1 = GetActiveParamSet();
429
                                                }
430
                                                if(tempchar1< 1) tempchar1 = 1; // limit to 1
431
                                                else if(tempchar1 > 5) tempchar1 = 5; // limit to 5
432
                                                // load requested parameter set
433
                                                ParamSet_ReadFromEEProm(tempchar1);
434
                                        }
1054 killagreg 435
                                        while(!UebertragungAbgeschlossen);
1622 killagreg 436
                                        SendOutData('Q', FC_ADDRESS, 2, &tempchar1, sizeof(tempchar1), (unsigned char *) &EE_Parameter, sizeof(EE_Parameter) - 1);
1636 ingob 437
                                        Debug("Lese Setting %d", tempchar1);
1654 killagreg 438
 
1054 killagreg 439
                                        break;
1051 killagreg 440
 
1054 killagreg 441
                        case 's': // Parametersatz speichern
1862 holgerb 442
                                        if((1 <= pRxData[0]) && (pRxData[0] <= 5) && (pRxData[1] == EEPARAM_REVISION) && MotorenEin == 0) // check for setting to be in range
1054 killagreg 443
                                        {
1622 killagreg 444
                                                memcpy(&EE_Parameter, (uint8_t*)&pRxData[1], sizeof(EE_Parameter) - 1);
445
                                                ParamSet_WriteToEEProm(pRxData[0]);
1054 killagreg 446
                                                Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;
447
                                                Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;
1622 killagreg 448
                                                tempchar1 = GetActiveParamSet();
1054 killagreg 449
                                        }
1058 killagreg 450
                                        else
451
                                        {
452
                                                tempchar1 = 0; // mark in response an invlid setting
453
                                        }
454
                                        while(!UebertragungAbgeschlossen);
455
                                        SendOutData('S', FC_ADDRESS, 1, &tempchar1, sizeof(tempchar1));
1405 hbuss 456
                                        if(!MotorenEin) Piep(tempchar1,110);
457
                                        LipoDetection(0);
1626 killagreg 458
                                        LIBFC_ReceiverInit(EE_Parameter.Receiver);
1054 killagreg 459
                                        break;
1405 hbuss 460
                        case 'f': // auf anderen Parametersatz umschalten
1622 killagreg 461
                                if((1 <= pRxData[0]) && (pRxData[0] <= 5)) ParamSet_ReadFromEEProm(pRxData[0]);
462
                                        tempchar1 = GetActiveParamSet();
1405 hbuss 463
                                        while(!UebertragungAbgeschlossen);
464
                                        SendOutData('F', FC_ADDRESS, 1, &tempchar1, sizeof(tempchar1));
465
                                        if(!MotorenEin) Piep(tempchar1,110);
466
                                        LipoDetection(0);
1626 killagreg 467
                                        LIBFC_ReceiverInit(EE_Parameter.Receiver);
1405 hbuss 468
                                        break;
1391 killagreg 469
                        case 'y':// serial Potis
470
                                        PPM_in[13] = (signed char) pRxData[0]; PPM_in[14] = (signed char) pRxData[1]; PPM_in[15] = (signed char) pRxData[2]; PPM_in[16] = (signed char) pRxData[3];
471
                                        PPM_in[17] = (signed char) pRxData[4]; PPM_in[18] = (signed char) pRxData[5]; PPM_in[19] = (signed char) pRxData[6]; PPM_in[20] = (signed char) pRxData[7];
472
                                        PPM_in[21] = (signed char) pRxData[8]; PPM_in[22] = (signed char) pRxData[9]; PPM_in[23] = (signed char) pRxData[10]; PPM_in[24] = (signed char) pRxData[11];
473
                                        break;
474
 
1662 killagreg 475
                        case 'u': // request BL parameter
476
                                Debug("Reading BL %d", pRxData[0]);
477
                                // try to read BL configuration
1665 killagreg 478
                                tempchar2 = I2C_ReadBLConfig(pRxData[0]);
1673 killagreg 479
                                if(tempchar2 == BLCONFIG_SUCCESS) tempchar1 = 1;
480
                                else tempchar1 = 0;
481
                                while(!UebertragungAbgeschlossen); // wait for previous frame to be sent
1674 ingob 482
                                SendOutData('U', FC_ADDRESS, 4, &tempchar1, sizeof(tempchar1), &tempchar2, sizeof(tempchar2), &pRxData[0], 1, &BLConfig, sizeof(BLConfig_t));
1662 killagreg 483
                                break;
484
 
485
                        case 'w': // write BL parameter
486
                                Debug("Writing BL %d", pRxData[0]);
487
                                if(RxDataLen >= 1+sizeof(BLConfig_t))
488
                                {
489
                                        memcpy(&BLConfig, (uint8_t*)(&pRxData[1]), sizeof(BLConfig_t));
1665 killagreg 490
                                        tempchar2 = I2C_WriteBLConfig(pRxData[0]);
491
                                        if(tempchar2 == BLCONFIG_SUCCESS) tempchar1 = 1;
492
                                        else tempchar1 = 0; // indicate error
1662 killagreg 493
                                        while(!UebertragungAbgeschlossen); // wait for previous frame to be sent
1665 killagreg 494
                                        SendOutData('W', FC_ADDRESS,2, &tempchar1, sizeof(tempchar1), &tempchar2, sizeof(tempchar2));
1662 killagreg 495
                                }
496
                                break;
1783 killagreg 497
                        case 'j':
1942 holgerb 498
                                if(MotorenEin) break;
1783 killagreg 499
                                tempchar1 = LIBFC_GetCPUType();
500
                                if((tempchar1 == CPU_ATMEGA644P) || (tempchar1 == CPU_ATMEGA1284P))
1782 ingob 501
                                {
1783 killagreg 502
                                        uint16_t ubrr = (uint16_t) ((uint32_t) F_CPU/ (8 * 38400L) - 1);
1782 ingob 503
 
1783 killagreg 504
                                        cli();
1782 ingob 505
 
1783 killagreg 506
                                        // UART0 & UART1 disable RX and TX-Interrupt
507
                                        UCSR0B &= ~((1 << RXCIE0)|(1 << TXCIE0));
508
                                        UCSR1B &= ~((1 << RXCIE1)|(1 << TXCIE1));
509
 
510
                                        // UART0 & UART1 disable receiver and transmitter
511
                                        UCSR0B &= ~((1 << TXEN0) | (1 << RXEN0));
512
                                        UCSR1B &= ~((1 << TXEN1) | (1 << RXEN1));
513
 
514
                                        // UART0 & UART1 flush receive buffer explicit
515
                                        while ( UCSR1A & (1<<RXC1) ) UDR1;
516
                                        while ( UCSR0A & (1<<RXC0) ) UDR0;
517
 
518
 
1942 holgerb 519
                                        if(pRxData[0] == 1) ReceiverUpdateModeActive = 2;
520
                                        else
521
                                        {           // Jeti or HoTT update
522
//#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
523
                                                if(pRxData[0] == 100)   ubrr = (uint16_t) ((uint32_t) F_CPU/ (8 * 19200L) - 1);  // HoTT
524
//#endif
525
                                                ReceiverUpdateModeActive = 1;
1783 killagreg 526
                                                // UART0 & UART1 set baudrate
527
                                                UBRR1H = (uint8_t)(ubrr>>8);
528
                                                UBRR1L = (uint8_t)ubrr;
529
                                                UBRR0H = UBRR1H;
530
                                                UBRR0L = UBRR1L;
531
                                                // UART1 no parity
532
                                                UCSR1C &= ~(1 << UPM11);
533
                                                UCSR1C &= ~(1 << UPM10);
534
                                                // UART1 8-bit
535
                                                UCSR1B &= ~(1 << UCSZ12);
536
                                                UCSR1C |= (1 << UCSZ11);
537
                                                UCSR1C |= (1 << UCSZ10);
538
                                        }
539
                                        // UART0 & UART1 1 stop bit
540
                                        UCSR1C &= ~(1 << USBS1);
541
                                        UCSR0C &= ~(1 << USBS0);
542
                                        // UART1 clear 9th bit
543
                                        UCSR1B &= ~(1<<TXB81);
544
                                        // enable receiver and transmitter for UART0 and UART1
545
                                        UCSR0B |= (1 << TXEN0) | (1 << RXEN0);
546
                                        UCSR1B |= (1 << TXEN1) | (1 << RXEN1);
547
                                        // enable RX-Interrupt for UART0 and UART1
548
                                        UCSR0B |= (1 << RXCIE0);
549
                                        UCSR1B |= (1 << RXCIE1);
550
                                        // disable other Interrupts
551
                                        TIMSK0 = 0;
552
                                        TIMSK1 = 0;
553
                                        TIMSK2 = 0;
554
 
555
                                        sei();
1777 ingob 556
                                }
557
                                break;
558
 
1056 killagreg 559
                } // case FC_ADDRESS:
1054 killagreg 560
 
561
                default: // any Slave Address
1056 killagreg 562
 
1054 killagreg 563
                switch(RxdBuffer[2])
564
                {
565
                        // 't' comand placed here only for compatibility to BL
566
                        case 't':// Motortest
1662 killagreg 567
                                if(AnzahlEmpfangsBytes >= sizeof(MotorTest)) memcpy(&MotorTest[0], (unsigned char *)pRxData, sizeof(MotorTest));
1212 hbuss 568
                                else memcpy(&MotorTest[0], (unsigned char *)pRxData, 4);
1054 killagreg 569
                                        while(!UebertragungAbgeschlossen);
570
                                        SendOutData('T', MeineSlaveAdresse, 0);
1212 hbuss 571
                                        PC_MotortestActive = 250;
1054 killagreg 572
                                        PcZugriff = 255;
1638 holgerb 573
                                        AboTimeOut = SetDelay(ABO_TIMEOUT);
1054 killagreg 574
                                        break;
575
                        // 'K' comand placed here only for compatibility to old MK3MAG software, that does not send the right Slave Address
576
                        case 'K':// Kompasswert
577
                                        memcpy((unsigned char *)&KompassValue , (unsigned char *)pRxData, sizeof(KompassValue));
1941 holgerb 578
//                                      KompassRichtung = ((540 + KompassValue - KompassSollWert) % 360) - 180;
1054 killagreg 579
                                        break;
580
                        case 'a':// Texte der Analogwerte
581
                                        DebugTextAnforderung = pRxData[0];
582
                                        if (DebugTextAnforderung > 31) DebugTextAnforderung = 31;
583
                                        PcZugriff = 255;
584
                                        break;
585
                        case 'b':
586
                                        memcpy((unsigned char *)&ExternControl, (unsigned char *)pRxData, sizeof(ExternControl));
587
                                        ConfirmFrame = ExternControl.Frame;
588
                                        PcZugriff = 255;
589
                                        break;
1171 hbuss 590
                        case 'c': // Poll the 3D-Data
591
                    if(!Intervall3D) { if(pRxData[0]) Timer3D = SetDelay(pRxData[0] * 10);}
592
                                        Intervall3D = pRxData[0] * 10;
1417 killagreg 593
                                        AboTimeOut = SetDelay(ABO_TIMEOUT);
1171 hbuss 594
                                        break;
1054 killagreg 595
                        case 'd': // Poll the debug data
1438 ingob 596
                                        PcZugriff = 255;
1399 killagreg 597
                                        DebugDataIntervall = (unsigned int)pRxData[0] * 10;
1171 hbuss 598
                                        if(DebugDataIntervall > 0) DebugDataAnforderung = 1;
1415 killagreg 599
                                        AboTimeOut = SetDelay(ABO_TIMEOUT);
1054 killagreg 600
                                        break;
601
 
602
                        case 'h':// x-1 Displayzeilen
1059 hbuss 603
                                PcZugriff = 255;
1399 killagreg 604
                                if((pRxData[0] & 0x80) == 0x00) // old format
605
                                        {
606
                                                DisplayLine = 2;
607
                                                Display_Interval = 0;
608
                                        }
609
                                        else // new format
610
                                        {
611
                                                RemoteKeys |= ~pRxData[0];
612
                                                Display_Interval = (unsigned int)pRxData[1] * 10;
613
                                                DisplayLine = 4;
1415 killagreg 614
                                                AboTimeOut = SetDelay(ABO_TIMEOUT);
1399 killagreg 615
                                        }
1054 killagreg 616
                                        DebugDisplayAnforderung = 1;
617
                                        break;
618
 
619
                        case 'l':// x-1 Displayzeilen
1059 hbuss 620
                                PcZugriff = 255;
1054 killagreg 621
                                        MenuePunkt = pRxData[0];
622
                                        DebugDisplayAnforderung1 = 1;
623
                                        break;
624
                        case 'v': // Version-Anforderung und Ausbaustufe
625
                                        GetVersionAnforderung = 1;
626
                                        break;
627
 
628
                        case 'g'://
629
                                        GetExternalControl = 1;
630
                                        break;
1657 killagreg 631
 
632
                        default:
633
                                //unsupported command received
634
                                break;
1054 killagreg 635
                }
636
                break; // default:
637
        }
1051 killagreg 638
        NeuerDatensatzEmpfangen = 0;
639
        pRxData = 0;
640
        RxDataLen = 0;
1 ingob 641
}
642
 
643
//############################################################################
644
//Routine für die Serielle Ausgabe
1444 ingob 645
void uart_putchar (char c)
1 ingob 646
//############################################################################
647
{
648
        //Warten solange bis Zeichen gesendet wurde
1561 killagreg 649
        loop_until_bit_is_set(UCSR0A, UDRE0);
1 ingob 650
        //Ausgabe des Zeichens
1561 killagreg 651
        UDR0 = c;
1 ingob 652
}
653
 
654
 
655
//############################################################################
656
//INstallation der Seriellen Schnittstelle
657
void UART_Init (void)
658
//############################################################################
659
{
1561 killagreg 660
        unsigned int ubrr = (unsigned int) ((unsigned long) F_CPU/(8 * USART0_BAUD) - 1);
661
 
1 ingob 662
        //Enable TXEN im Register UCR TX-Data Enable & RX Enable
1561 killagreg 663
        UCSR0B = (1 << TXEN0) | (1 << RXEN0);
1 ingob 664
    // UART Double Speed (U2X)
1561 killagreg 665
        UCSR0A |= (1 << U2X0);
1 ingob 666
        // RX-Interrupt Freigabe
1561 killagreg 667
        UCSR0B |= (1 << RXCIE0);
1 ingob 668
        // TX-Interrupt Freigabe
1561 killagreg 669
        UCSR0B |= (1 << TXCIE0);
670
        // USART0 Baud Rate Register
671
        // set clock divider
672
        UBRR0H = (uint8_t)(ubrr >> 8);
673
        UBRR0L = (uint8_t)ubrr;
1 ingob 674
 
1051 killagreg 675
        Debug_Timer = SetDelay(DebugDataIntervall);
676
        Kompass_Timer = SetDelay(220);
677
 
1058 killagreg 678
        VersionInfo.SWMajor = VERSION_MAJOR;
679
        VersionInfo.SWMinor = VERSION_MINOR;
680
        VersionInfo.SWPatch = VERSION_PATCH;
681
        VersionInfo.ProtoMajor  = VERSION_SERIAL_MAJOR;
682
        VersionInfo.ProtoMinor  = VERSION_SERIAL_MINOR;
1051 killagreg 683
 
684
        pRxData = 0;
685
        RxDataLen = 0;
1 ingob 686
}
687
 
688
//---------------------------------------------------------------------------------------------
1051 killagreg 689
void DatenUebertragung(void)
1 ingob 690
{
1415 killagreg 691
        if(!UebertragungAbgeschlossen) return;
1 ingob 692
 
1415 killagreg 693
        if(CheckDelay(AboTimeOut))
694
        {
695
                Display_Interval = 0;
696
                DebugDataIntervall = 0;
1417 killagreg 697
                Intervall3D = 0;
1415 killagreg 698
        }
699
 
1399 killagreg 700
        if(((Display_Interval>0 && CheckDelay(Display_Timer)) || DebugDisplayAnforderung) && UebertragungAbgeschlossen)
1065 killagreg 701
        {
1399 killagreg 702
                if(DisplayLine > 3)// new format
703
                {
1423 hbuss 704
                        Menu();
1399 killagreg 705
                        SendOutData('H', FC_ADDRESS, 1, (uint8_t *)DisplayBuff, 80);
706
                }
707
                else // old format
708
                {
709
                        LCD_printfxy(0,0,"!!! INCOMPATIBLE !!!");
710
                        SendOutData('H', FC_ADDRESS, 2, &DisplayLine, sizeof(DisplayLine), (uint8_t *)DisplayBuff, 20);
711
                        if(DisplayLine++ > 3) DisplayLine = 0;
712
                }
713
                Display_Timer = SetDelay(Display_Interval);
1065 killagreg 714
                DebugDisplayAnforderung = 0;
715
        }
716
        if(DebugDisplayAnforderung1 && UebertragungAbgeschlossen)
717
        {
718
                Menu();
719
                SendOutData('L', FC_ADDRESS, 3, &MenuePunkt, sizeof(MenuePunkt), &MaxMenue, sizeof(MaxMenue), DisplayBuff, sizeof(DisplayBuff));
720
                DebugDisplayAnforderung1 = 0;
721
        }
722
        if(GetVersionAnforderung && UebertragungAbgeschlossen)
723
        {
724
                SendOutData('V', FC_ADDRESS, 1, (unsigned char *) &VersionInfo, sizeof(VersionInfo));
725
                GetVersionAnforderung = 0;
1636 ingob 726
                Debug_OK("Version gesendet");
1065 killagreg 727
        }
1 ingob 728
 
1065 killagreg 729
        if(GetExternalControl && UebertragungAbgeschlossen)           // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
730
        {
731
                SendOutData('G',MeineSlaveAdresse, 1, (unsigned char *) &ExternControl, sizeof(ExternControl));
732
                GetExternalControl = 0;
733
        }
1051 killagreg 734
    if((CheckDelay(Kompass_Timer)) && UebertragungAbgeschlossen)
693 hbuss 735
         {
1171 hbuss 736
                  WinkelOut.Winkel[0] = (int) (IntegralNick / (EE_Parameter.GyroAccFaktor * 4));  // etwa in 0.1 Grad
737
                  WinkelOut.Winkel[1] = (int) (IntegralRoll / (EE_Parameter.GyroAccFaktor * 4));  // etwa in 0.1 Grad
717 hbuss 738
                  WinkelOut.UserParameter[0] = Parameter_UserParam1;
739
                  WinkelOut.UserParameter[1] = Parameter_UserParam2;
1619 killagreg 740
          SendOutData('k', MK3MAG_ADDRESS, 1, (unsigned char *) &WinkelOut,sizeof(WinkelOut));
855 hbuss 741
          if(WinkelOut.CalcState > 4)  WinkelOut.CalcState = 6; // wird dann in SPI auf Null gesetzt
1051 killagreg 742
          Kompass_Timer = SetDelay(99);
743
         }
1171 hbuss 744
    if(((DebugDataIntervall>0 && CheckDelay(Debug_Timer)) || DebugDataAnforderung) && UebertragungAbgeschlossen)
1 ingob 745
         {
1639 holgerb 746
                  CopyDebugValues();
1276 hbuss 747
          SendOutData('D', FC_ADDRESS, 1, (unsigned char *) &DebugOut,sizeof(DebugOut));
1 ingob 748
          DebugDataAnforderung = 0;
1055 ingob 749
          if(DebugDataIntervall>0) Debug_Timer = SetDelay(DebugDataIntervall);
1051 killagreg 750
         }
1171 hbuss 751
    if(Intervall3D > 0 && CheckDelay(Timer3D) && UebertragungAbgeschlossen)
752
         {
753
                  Data3D.Winkel[0] = (int) (IntegralNick / (EE_Parameter.GyroAccFaktor * 4));  // etwa in 0.1 Grad
754
                  Data3D.Winkel[1] = (int) (IntegralRoll / (EE_Parameter.GyroAccFaktor * 4));  // etwa in 0.1 Grad
755
          Data3D.Winkel[2] = (int) ((10 * ErsatzKompass) / GIER_GRAD_FAKTOR);
1685 holgerb 756
                  Data3D.Centroid[0] = SummeNick >> 9;
757
                  Data3D.Centroid[1] = SummeRoll >> 9;
758
                  Data3D.Centroid[2] = Mess_Integral_Gier >> 9;
1171 hbuss 759
          SendOutData('C', FC_ADDRESS, 1, (unsigned char *) &Data3D,sizeof(Data3D));
760
          Timer3D = SetDelay(Intervall3D);
761
         }
499 hbuss 762
    if(DebugTextAnforderung != 255) // Texte für die Analogdaten
763
     {
1490 killagreg 764
                unsigned char label[16]; // local sram buffer
765
                memcpy_P(label, ANALOG_TEXT[DebugTextAnforderung], 16); // read lable from flash to sra
766
      SendOutData('A', FC_ADDRESS, 2, (unsigned char *)&DebugTextAnforderung, sizeof(DebugTextAnforderung),label, 16);
499 hbuss 767
      DebugTextAnforderung = 255;
768
         }
1051 killagreg 769
     if(ConfirmFrame && UebertragungAbgeschlossen)   // Datensatz bestätigen
595 hbuss 770
         {
1054 killagreg 771
                SendOutData('B', FC_ADDRESS, 1, (uint8_t*)&ConfirmFrame, sizeof(ConfirmFrame));
1051 killagreg 772
        ConfirmFrame = 0;
595 hbuss 773
     }
1053 killagreg 774
 
1051 killagreg 775
     if(GetPPMChannelAnforderung && UebertragungAbgeschlossen)
776
     {
1054 killagreg 777
                 SendOutData('P', FC_ADDRESS, 1, (unsigned char *) &PPM_in, sizeof(PPM_in));
1051 killagreg 778
                 GetPPMChannelAnforderung = 0;
779
         }
1654 killagreg 780
 
1636 ingob 781
#ifdef DEBUG                                                                                                                    // only include functions if DEBUG is defined
782
     if(SendDebugOutput && UebertragungAbgeschlossen)
783
     {
784
                 SendOutData('0', FC_ADDRESS, 1, (unsigned char *) &tDebug, sizeof(tDebug));
785
                 SendDebugOutput = 0;
786
         }
1654 killagreg 787
#endif
1 ingob 788
 
789
}
790
 
1636 ingob 791