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