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
2340 holgerb 67
#define MAX_SENDE_BUFF     220
68
#define MAX_EMPFANGS_BUFF  220
1657 killagreg 69
 
70
#define BLPARAM_REVISION 1
71
#define MASK_SET_PWM_SCALING            0x01
72
#define MASK_SET_CURRENT_LIMIT          0x02
73
#define MASK_SET_TEMP_LIMIT                     0x04
74
#define MASK_SET_CURRENT_SCALING        0x08
75
#define MASK_SET_BITCONFIG                      0x10
76
#define MASK_RESET_CAPCOUNTER           0x20
77
#define MASK_SET_DEFAULT_PARAMS         0x40
78
#define MASK_SET_SAVE_EEPROM            0x80
79
 
1053 killagreg 80
unsigned char GetExternalControl = 0,DebugDisplayAnforderung1 = 0, DebugDisplayAnforderung = 0,DebugDataAnforderung = 0,GetVersionAnforderung = 0, GetPPMChannelAnforderung = 0;
81
unsigned char DisplayLine = 0;
1 ingob 82
unsigned volatile char SioTmp = 0;
83
unsigned volatile char NeuerDatensatzEmpfangen = 0;
84
unsigned volatile char NeueKoordinateEmpfangen = 0;
85
unsigned volatile char UebertragungAbgeschlossen = 1;
86
unsigned volatile char CntCrcError = 0;
87
unsigned volatile char AnzahlEmpfangsBytes = 0;
1441 ingob 88
unsigned volatile char TxdBuffer[MAX_SENDE_BUFF];
89
unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF];
90
 
1051 killagreg 91
unsigned char *pRxData = 0;
92
unsigned char RxDataLen = 0;
1 ingob 93
unsigned volatile char PC_DebugTimeout = 0;
1212 hbuss 94
unsigned volatile char PC_MotortestActive = 0;
1636 ingob 95
unsigned char DebugTextAnforderung = 255;
1051 killagreg 96
 
1 ingob 97
unsigned char PcZugriff = 100;
1212 hbuss 98
unsigned char MotorTest[16];
1036 hbuss 99
unsigned char MeineSlaveAdresse = 1; // Flight-Ctrl
595 hbuss 100
unsigned char ConfirmFrame;
1 ingob 101
struct str_DebugOut    DebugOut;
595 hbuss 102
struct str_ExternControl  ExternControl;
1 ingob 103
struct str_VersionInfo VersionInfo;
693 hbuss 104
struct str_WinkelOut WinkelOut;
1171 hbuss 105
struct str_Data3D Data3D;
1 ingob 106
 
1399 killagreg 107
int Display_Timer, Debug_Timer,Kompass_Timer,Timer3D;
1415 killagreg 108
unsigned int DebugDataIntervall = 0, Intervall3D = 0, Display_Interval = 0;
109
unsigned int AboTimeOut = 0;
1942 holgerb 110
unsigned volatile char ReceiverUpdateModeActive = 0; // 1 = Update      2 = JetiBox-Simulation
693 hbuss 111
 
1490 killagreg 112
const unsigned char ANALOG_TEXT[32][16] PROGMEM =
499 hbuss 113
{
1051 killagreg 114
   //1234567890123456
1175 hbuss 115
    "AngleNick       ", //0
116
    "AngleRoll       ",
1051 killagreg 117
    "AccNick         ",
499 hbuss 118
    "AccRoll         ",
1523 holgerb 119
    "YawGyro         ",
2316 holgerb 120
    "Altitude [0.1m] ", //5
499 hbuss 121
    "AccZ            ",
122
    "Gas             ",
1175 hbuss 123
    "Compass Value   ",
1528 holgerb 124
    "Voltage [0.1V]  ",
1521 killagreg 125
    "Receiver Level  ", //10
126
    "Gyro Compass    ",
127
    "Motor 1         ",
128
    "Motor 2         ",
129
    "Motor 3         ",
130
    "Motor 4         ", //15
2316 holgerb 131
    "16              ",
132
    "17              ",
133
    "18              ",
134
    "19              ",
2230 holgerb 135
    "Servo           ", //20
1521 killagreg 136
    "Hovergas        ",
2230 holgerb 137
    "Current [0.1A]  ",
1501 holgerb 138
    "Capacity [mAh]  ",
1913 holgerb 139
    "Height Setpoint ",
2316 holgerb 140
    "25              ", //25
141
        "26              ", //"26 CPU OverLoad ",
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';
2380 holgerb 203
         if(RxdBuffer[2] == 'R' && !MotorenEin)
1232 hbuss 204
          {
1435 killagreg 205
           LcdClear();
1232 hbuss 206
           wdt_enable(WDTO_250MS); // Reset-Commando
207
           ServoActive = 0;
1253 killagreg 208
          }
1051 killagreg 209
        }
1 ingob 210
  }
211
  else
212
  switch(UartState)
213
  {
214
   case 0:
215
          if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1;  // Startzeichen und Daten schon verarbeitet
216
                  buf_ptr = 0;
217
                  RxdBuffer[buf_ptr++] = SioTmp;
218
                  crc = SioTmp;
219
          break;
220
   case 1: // Adresse auswerten
221
                  UartState++;
222
                  RxdBuffer[buf_ptr++] = SioTmp;
223
                  crc += SioTmp;
224
                  break;
225
   case 2: //  Eingangsdaten sammeln
226
                  RxdBuffer[buf_ptr] = SioTmp;
1490 killagreg 227
                  if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;
1 ingob 228
                  else UartState = 0;
229
                  crc += SioTmp;
230
                  break;
1051 killagreg 231
   default:
232
          UartState = 0;
1 ingob 233
          break;
234
  }
235
}
236
 
237
 
238
// --------------------------------------------------------------------------
239
void AddCRC(unsigned int wieviele)
240
{
1051 killagreg 241
 unsigned int tmpCRC = 0,i;
1 ingob 242
 for(i = 0; i < wieviele;i++)
243
  {
1438 ingob 244
   tmpCRC += TxdBuffer[i];
1 ingob 245
  }
2340 holgerb 246
//   if(i > MAX_SENDE_BUFF - 3) tmpCRC += 11; 
1 ingob 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];
2340 holgerb 253
//if(DebugOut.Analog[] < i) DebugOut.Analog[] = i;
1 ingob 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
2416 holgerb 413
                                   if(!MotorenEin)
414
                                   {
1761 killagreg 415
                                        if((10 <= pRxData[0]) && (pRxData[0] < 20))
1054 killagreg 416
                                        {
1761 killagreg 417
                                                tempchar1 = pRxData[0] - 10;
418
                                                if(tempchar1< 1) tempchar1 = 1; // limit to 1
419
                                                else if(tempchar1 > 5) tempchar1 = 5; // limit to 5
420
                                                SetDefaultParameter(tempchar1, 1);
1054 killagreg 421
                                        }
1761 killagreg 422
                                        else if((20 <= pRxData[0]) && (pRxData[0] < 30))
423
                                        {
424
                                                tempchar1 = pRxData[0] - 20;
425
                                                if(tempchar1< 1) tempchar1 = 1; // limit to 1
426
                                                else if(tempchar1 > 5) tempchar1 = 5; // limit to 5
427
                                                SetDefaultParameter(tempchar1, 0);
428
                                        }
429
                                        else
430
                                        {
431
                                                tempchar1 = pRxData[0];
432
                                                if(tempchar1 == 0xFF)
433
                                                {
434
                                                        tempchar1 = GetActiveParamSet();
435
                                                }
436
                                                if(tempchar1< 1) tempchar1 = 1; // limit to 1
437
                                                else if(tempchar1 > 5) tempchar1 = 5; // limit to 5
438
                                                // load requested parameter set
439
                                                ParamSet_ReadFromEEProm(tempchar1);
440
                                        }
2416 holgerb 441
                                        LipoDetection(0);
442
                                   } else tempchar1 = GetActiveParamSet();     
1054 killagreg 443
                                        while(!UebertragungAbgeschlossen);
1622 killagreg 444
                                        SendOutData('Q', FC_ADDRESS, 2, &tempchar1, sizeof(tempchar1), (unsigned char *) &EE_Parameter, sizeof(EE_Parameter) - 1);
1636 ingob 445
                                        Debug("Lese Setting %d", tempchar1);
1054 killagreg 446
                                        break;
1051 killagreg 447
 
1054 killagreg 448
                        case 's': // Parametersatz speichern
1862 holgerb 449
                                        if((1 <= pRxData[0]) && (pRxData[0] <= 5) && (pRxData[1] == EEPARAM_REVISION) && MotorenEin == 0) // check for setting to be in range
1054 killagreg 450
                                        {
1622 killagreg 451
                                                memcpy(&EE_Parameter, (uint8_t*)&pRxData[1], sizeof(EE_Parameter) - 1);
452
                                                ParamSet_WriteToEEProm(pRxData[0]);
1054 killagreg 453
                                                Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;
454
                                                Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;
1622 killagreg 455
                                                tempchar1 = GetActiveParamSet();
1054 killagreg 456
                                        }
1058 killagreg 457
                                        else
458
                                        {
459
                                                tempchar1 = 0; // mark in response an invlid setting
460
                                        }
461
                                        while(!UebertragungAbgeschlossen);
462
                                        SendOutData('S', FC_ADDRESS, 1, &tempchar1, sizeof(tempchar1));
2390 holgerb 463
                                        if(!MotorenEin)
464
                                         {
465
                                          Piep(tempchar1,110);
466
                                          LipoDetection(0);
467
                                         }
1626 killagreg 468
                                        LIBFC_ReceiverInit(EE_Parameter.Receiver);
1054 killagreg 469
                                        break;
1405 hbuss 470
                        case 'f': // auf anderen Parametersatz umschalten
2340 holgerb 471
                                        if(MotorenEin) break;
1622 killagreg 472
                                if((1 <= pRxData[0]) && (pRxData[0] <= 5)) ParamSet_ReadFromEEProm(pRxData[0]);
473
                                        tempchar1 = GetActiveParamSet();
1405 hbuss 474
                                        while(!UebertragungAbgeschlossen);
475
                                        SendOutData('F', FC_ADDRESS, 1, &tempchar1, sizeof(tempchar1));
2390 holgerb 476
                                        if(!MotorenEin)
477
                                         {
478
                                          Piep(tempchar1,110);
479
                                          LipoDetection(0);
480
                                         }
1626 killagreg 481
                                        LIBFC_ReceiverInit(EE_Parameter.Receiver);
1405 hbuss 482
                                        break;
1391 killagreg 483
                        case 'y':// serial Potis
2340 holgerb 484
                                        for(tempchar1 = 0; tempchar1 < 12; tempchar1++) PPM_in[SERIAL_POTI_START + tempchar1] = (signed char) pRxData[tempchar1];
1391 killagreg 485
                                        break;
1662 killagreg 486
                        case 'u': // request BL parameter
487
                                Debug("Reading BL %d", pRxData[0]);
488
                                // try to read BL configuration
1665 killagreg 489
                                tempchar2 = I2C_ReadBLConfig(pRxData[0]);
1673 killagreg 490
                                if(tempchar2 == BLCONFIG_SUCCESS) tempchar1 = 1;
491
                                else tempchar1 = 0;
492
                                while(!UebertragungAbgeschlossen); // wait for previous frame to be sent
1674 ingob 493
                                SendOutData('U', FC_ADDRESS, 4, &tempchar1, sizeof(tempchar1), &tempchar2, sizeof(tempchar2), &pRxData[0], 1, &BLConfig, sizeof(BLConfig_t));
1662 killagreg 494
                                break;
495
                        case 'w': // write BL parameter
496
                                Debug("Writing BL %d", pRxData[0]);
497
                                if(RxDataLen >= 1+sizeof(BLConfig_t))
498
                                {
499
                                        memcpy(&BLConfig, (uint8_t*)(&pRxData[1]), sizeof(BLConfig_t));
1665 killagreg 500
                                        tempchar2 = I2C_WriteBLConfig(pRxData[0]);
501
                                        if(tempchar2 == BLCONFIG_SUCCESS) tempchar1 = 1;
502
                                        else tempchar1 = 0; // indicate error
1662 killagreg 503
                                        while(!UebertragungAbgeschlossen); // wait for previous frame to be sent
1665 killagreg 504
                                        SendOutData('W', FC_ADDRESS,2, &tempchar1, sizeof(tempchar1), &tempchar2, sizeof(tempchar2));
1662 killagreg 505
                                }
506
                                break;
1783 killagreg 507
                        case 'j':
1942 holgerb 508
                                if(MotorenEin) break;
1783 killagreg 509
                                tempchar1 = LIBFC_GetCPUType();
510
                                if((tempchar1 == CPU_ATMEGA644P) || (tempchar1 == CPU_ATMEGA1284P))
1782 ingob 511
                                {
1783 killagreg 512
                                        uint16_t ubrr = (uint16_t) ((uint32_t) F_CPU/ (8 * 38400L) - 1);
1782 ingob 513
 
1783 killagreg 514
                                        cli();
1782 ingob 515
 
1783 killagreg 516
                                        // UART0 & UART1 disable RX and TX-Interrupt
517
                                        UCSR0B &= ~((1 << RXCIE0)|(1 << TXCIE0));
518
                                        UCSR1B &= ~((1 << RXCIE1)|(1 << TXCIE1));
519
 
520
                                        // UART0 & UART1 disable receiver and transmitter
521
                                        UCSR0B &= ~((1 << TXEN0) | (1 << RXEN0));
522
                                        UCSR1B &= ~((1 << TXEN1) | (1 << RXEN1));
523
 
524
                                        // UART0 & UART1 flush receive buffer explicit
525
                                        while ( UCSR1A & (1<<RXC1) ) UDR1;
526
                                        while ( UCSR0A & (1<<RXC0) ) UDR0;
527
 
528
 
1942 holgerb 529
                                        if(pRxData[0] == 1) ReceiverUpdateModeActive = 2;
530
                                        else
531
                                        {           // Jeti or HoTT update
532
//#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
533
                                                if(pRxData[0] == 100)   ubrr = (uint16_t) ((uint32_t) F_CPU/ (8 * 19200L) - 1);  // HoTT
534
//#endif
535
                                                ReceiverUpdateModeActive = 1;
1783 killagreg 536
                                                // UART0 & UART1 set baudrate
537
                                                UBRR1H = (uint8_t)(ubrr>>8);
538
                                                UBRR1L = (uint8_t)ubrr;
539
                                                UBRR0H = UBRR1H;
540
                                                UBRR0L = UBRR1L;
541
                                                // UART1 no parity
542
                                                UCSR1C &= ~(1 << UPM11);
543
                                                UCSR1C &= ~(1 << UPM10);
544
                                                // UART1 8-bit
545
                                                UCSR1B &= ~(1 << UCSZ12);
546
                                                UCSR1C |= (1 << UCSZ11);
547
                                                UCSR1C |= (1 << UCSZ10);
548
                                        }
549
                                        // UART0 & UART1 1 stop bit
550
                                        UCSR1C &= ~(1 << USBS1);
551
                                        UCSR0C &= ~(1 << USBS0);
552
                                        // UART1 clear 9th bit
553
                                        UCSR1B &= ~(1<<TXB81);
554
                                        // enable receiver and transmitter for UART0 and UART1
555
                                        UCSR0B |= (1 << TXEN0) | (1 << RXEN0);
556
                                        UCSR1B |= (1 << TXEN1) | (1 << RXEN1);
557
                                        // enable RX-Interrupt for UART0 and UART1
558
                                        UCSR0B |= (1 << RXCIE0);
559
                                        UCSR1B |= (1 << RXCIE1);
560
                                        // disable other Interrupts
561
                                        TIMSK0 = 0;
562
                                        TIMSK1 = 0;
563
                                        TIMSK2 = 0;
564
 
565
                                        sei();
1777 ingob 566
                                }
567
                                break;
568
 
1056 killagreg 569
                } // case FC_ADDRESS:
1054 killagreg 570
 
571
                default: // any Slave Address
1056 killagreg 572
 
1054 killagreg 573
                switch(RxdBuffer[2])
574
                {
575
                        // 't' comand placed here only for compatibility to BL
576
                        case 't':// Motortest
1662 killagreg 577
                                if(AnzahlEmpfangsBytes >= sizeof(MotorTest)) memcpy(&MotorTest[0], (unsigned char *)pRxData, sizeof(MotorTest));
1212 hbuss 578
                                else memcpy(&MotorTest[0], (unsigned char *)pRxData, 4);
1054 killagreg 579
                                        while(!UebertragungAbgeschlossen);
580
                                        SendOutData('T', MeineSlaveAdresse, 0);
1212 hbuss 581
                                        PC_MotortestActive = 250;
1054 killagreg 582
                                        PcZugriff = 255;
1638 holgerb 583
                                        AboTimeOut = SetDelay(ABO_TIMEOUT);
1054 killagreg 584
                                        break;
585
                        // 'K' comand placed here only for compatibility to old MK3MAG software, that does not send the right Slave Address
586
                        case 'K':// Kompasswert
587
                                        memcpy((unsigned char *)&KompassValue , (unsigned char *)pRxData, sizeof(KompassValue));
1941 holgerb 588
//                                      KompassRichtung = ((540 + KompassValue - KompassSollWert) % 360) - 180;
1054 killagreg 589
                                        break;
590
                        case 'a':// Texte der Analogwerte
591
                                        DebugTextAnforderung = pRxData[0];
592
                                        if (DebugTextAnforderung > 31) DebugTextAnforderung = 31;
593
                                        PcZugriff = 255;
594
                                        break;
595
                        case 'b':
596
                                        memcpy((unsigned char *)&ExternControl, (unsigned char *)pRxData, sizeof(ExternControl));
597
                                        ConfirmFrame = ExternControl.Frame;
598
                                        PcZugriff = 255;
599
                                        break;
1171 hbuss 600
                        case 'c': // Poll the 3D-Data
601
                    if(!Intervall3D) { if(pRxData[0]) Timer3D = SetDelay(pRxData[0] * 10);}
602
                                        Intervall3D = pRxData[0] * 10;
1417 killagreg 603
                                        AboTimeOut = SetDelay(ABO_TIMEOUT);
1171 hbuss 604
                                        break;
1054 killagreg 605
                        case 'd': // Poll the debug data
1438 ingob 606
                                        PcZugriff = 255;
1399 killagreg 607
                                        DebugDataIntervall = (unsigned int)pRxData[0] * 10;
1171 hbuss 608
                                        if(DebugDataIntervall > 0) DebugDataAnforderung = 1;
1415 killagreg 609
                                        AboTimeOut = SetDelay(ABO_TIMEOUT);
1054 killagreg 610
                                        break;
611
 
612
                        case 'h':// x-1 Displayzeilen
1059 hbuss 613
                                PcZugriff = 255;
1399 killagreg 614
                                if((pRxData[0] & 0x80) == 0x00) // old format
615
                                        {
616
                                                DisplayLine = 2;
617
                                                Display_Interval = 0;
618
                                        }
619
                                        else // new format
620
                                        {
621
                                                RemoteKeys |= ~pRxData[0];
622
                                                Display_Interval = (unsigned int)pRxData[1] * 10;
623
                                                DisplayLine = 4;
1415 killagreg 624
                                                AboTimeOut = SetDelay(ABO_TIMEOUT);
1399 killagreg 625
                                        }
1054 killagreg 626
                                        DebugDisplayAnforderung = 1;
627
                                        break;
628
 
629
                        case 'l':// x-1 Displayzeilen
1059 hbuss 630
                                PcZugriff = 255;
1054 killagreg 631
                                        MenuePunkt = pRxData[0];
632
                                        DebugDisplayAnforderung1 = 1;
633
                                        break;
634
                        case 'v': // Version-Anforderung und Ausbaustufe
635
                                        GetVersionAnforderung = 1;
636
                                        break;
637
 
638
                        case 'g'://
639
                                        GetExternalControl = 1;
640
                                        break;
1657 killagreg 641
 
642
                        default:
643
                                //unsupported command received
644
                                break;
1054 killagreg 645
                }
646
                break; // default:
647
        }
1051 killagreg 648
        NeuerDatensatzEmpfangen = 0;
649
        pRxData = 0;
650
        RxDataLen = 0;
1 ingob 651
}
652
 
653
//############################################################################
654
//Routine für die Serielle Ausgabe
1444 ingob 655
void uart_putchar (char c)
1 ingob 656
//############################################################################
657
{
658
        //Warten solange bis Zeichen gesendet wurde
1561 killagreg 659
        loop_until_bit_is_set(UCSR0A, UDRE0);
1 ingob 660
        //Ausgabe des Zeichens
1561 killagreg 661
        UDR0 = c;
1 ingob 662
}
663
 
664
 
665
//############################################################################
666
//INstallation der Seriellen Schnittstelle
667
void UART_Init (void)
668
//############################################################################
669
{
1561 killagreg 670
        unsigned int ubrr = (unsigned int) ((unsigned long) F_CPU/(8 * USART0_BAUD) - 1);
671
 
1 ingob 672
        //Enable TXEN im Register UCR TX-Data Enable & RX Enable
1561 killagreg 673
        UCSR0B = (1 << TXEN0) | (1 << RXEN0);
1 ingob 674
    // UART Double Speed (U2X)
1561 killagreg 675
        UCSR0A |= (1 << U2X0);
1 ingob 676
        // RX-Interrupt Freigabe
1561 killagreg 677
        UCSR0B |= (1 << RXCIE0);
1 ingob 678
        // TX-Interrupt Freigabe
1561 killagreg 679
        UCSR0B |= (1 << TXCIE0);
680
        // USART0 Baud Rate Register
681
        // set clock divider
682
        UBRR0H = (uint8_t)(ubrr >> 8);
683
        UBRR0L = (uint8_t)ubrr;
1 ingob 684
 
1051 killagreg 685
        Debug_Timer = SetDelay(DebugDataIntervall);
686
        Kompass_Timer = SetDelay(220);
687
 
1058 killagreg 688
        VersionInfo.SWMajor = VERSION_MAJOR;
689
        VersionInfo.SWMinor = VERSION_MINOR;
690
        VersionInfo.SWPatch = VERSION_PATCH;
691
        VersionInfo.ProtoMajor  = VERSION_SERIAL_MAJOR;
2342 holgerb 692
        VersionInfo.reserved1  = 0;
693
        VersionInfo.reserved2  = 0;
694
    VersionInfo.HWMajor = PlatinenVersion;
1051 killagreg 695
        pRxData = 0;
696
        RxDataLen = 0;
1 ingob 697
}
698
 
699
//---------------------------------------------------------------------------------------------
1051 killagreg 700
void DatenUebertragung(void)
1 ingob 701
{
1415 killagreg 702
        if(!UebertragungAbgeschlossen) return;
1 ingob 703
 
1415 killagreg 704
        if(CheckDelay(AboTimeOut))
705
        {
706
                Display_Interval = 0;
707
                DebugDataIntervall = 0;
1417 killagreg 708
                Intervall3D = 0;
1415 killagreg 709
        }
710
 
1399 killagreg 711
        if(((Display_Interval>0 && CheckDelay(Display_Timer)) || DebugDisplayAnforderung) && UebertragungAbgeschlossen)
1065 killagreg 712
        {
1399 killagreg 713
                if(DisplayLine > 3)// new format
714
                {
1423 hbuss 715
                        Menu();
1399 killagreg 716
                        SendOutData('H', FC_ADDRESS, 1, (uint8_t *)DisplayBuff, 80);
717
                }
718
                else // old format
719
                {
720
                        LCD_printfxy(0,0,"!!! INCOMPATIBLE !!!");
721
                        SendOutData('H', FC_ADDRESS, 2, &DisplayLine, sizeof(DisplayLine), (uint8_t *)DisplayBuff, 20);
722
                        if(DisplayLine++ > 3) DisplayLine = 0;
723
                }
724
                Display_Timer = SetDelay(Display_Interval);
1065 killagreg 725
                DebugDisplayAnforderung = 0;
726
        }
727
        if(DebugDisplayAnforderung1 && UebertragungAbgeschlossen)
728
        {
729
                Menu();
730
                SendOutData('L', FC_ADDRESS, 3, &MenuePunkt, sizeof(MenuePunkt), &MaxMenue, sizeof(MaxMenue), DisplayBuff, sizeof(DisplayBuff));
731
                DebugDisplayAnforderung1 = 0;
732
        }
733
        if(GetVersionAnforderung && UebertragungAbgeschlossen)
734
        {
735
                SendOutData('V', FC_ADDRESS, 1, (unsigned char *) &VersionInfo, sizeof(VersionInfo));
736
                GetVersionAnforderung = 0;
1636 ingob 737
                Debug_OK("Version gesendet");
1065 killagreg 738
        }
1 ingob 739
 
1065 killagreg 740
        if(GetExternalControl && UebertragungAbgeschlossen)           // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
741
        {
742
                SendOutData('G',MeineSlaveAdresse, 1, (unsigned char *) &ExternControl, sizeof(ExternControl));
743
                GetExternalControl = 0;
744
        }
1171 hbuss 745
    if(((DebugDataIntervall>0 && CheckDelay(Debug_Timer)) || DebugDataAnforderung) && UebertragungAbgeschlossen)
1 ingob 746
         {
1639 holgerb 747
                  CopyDebugValues();
1276 hbuss 748
          SendOutData('D', FC_ADDRESS, 1, (unsigned char *) &DebugOut,sizeof(DebugOut));
1 ingob 749
          DebugDataAnforderung = 0;
1055 ingob 750
          if(DebugDataIntervall>0) Debug_Timer = SetDelay(DebugDataIntervall);
1051 killagreg 751
         }
1171 hbuss 752
    if(Intervall3D > 0 && CheckDelay(Timer3D) && UebertragungAbgeschlossen)
753
         {
2373 holgerb 754
                  Data3D.Winkel[0] = ToNaviCtrl.IntegralNick;//(int) (IntegralNick / (EE_Parameter.GyroAccFaktor * 4));  // etwa in 0.1 Grad
755
                  Data3D.Winkel[1] = ToNaviCtrl.IntegralRoll;//(int) (IntegralRoll / (EE_Parameter.GyroAccFaktor * 4));  // etwa in 0.1 Grad
1171 hbuss 756
          Data3D.Winkel[2] = (int) ((10 * ErsatzKompass) / GIER_GRAD_FAKTOR);
1685 holgerb 757
                  Data3D.Centroid[0] = SummeNick >> 9;
758
                  Data3D.Centroid[1] = SummeRoll >> 9;
759
                  Data3D.Centroid[2] = Mess_Integral_Gier >> 9;
1171 hbuss 760
          SendOutData('C', FC_ADDRESS, 1, (unsigned char *) &Data3D,sizeof(Data3D));
761
          Timer3D = SetDelay(Intervall3D);
762
         }
499 hbuss 763
    if(DebugTextAnforderung != 255) // Texte für die Analogdaten
764
     {
1490 killagreg 765
                unsigned char label[16]; // local sram buffer
766
                memcpy_P(label, ANALOG_TEXT[DebugTextAnforderung], 16); // read lable from flash to sra
767
      SendOutData('A', FC_ADDRESS, 2, (unsigned char *)&DebugTextAnforderung, sizeof(DebugTextAnforderung),label, 16);
499 hbuss 768
      DebugTextAnforderung = 255;
769
         }
1051 killagreg 770
     if(ConfirmFrame && UebertragungAbgeschlossen)   // Datensatz bestätigen
595 hbuss 771
         {
1054 killagreg 772
                SendOutData('B', FC_ADDRESS, 1, (uint8_t*)&ConfirmFrame, sizeof(ConfirmFrame));
1051 killagreg 773
        ConfirmFrame = 0;
595 hbuss 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
         }
2346 holgerb 780
    if((CheckDelay(Kompass_Timer)) && UebertragungAbgeschlossen)
781
         {
2373 holgerb 782
                  WinkelOut.Winkel[0] = ToNaviCtrl.IntegralNick;//(int) (IntegralNick / (EE_Parameter.GyroAccFaktor * 4));  // etwa in 0.1 Grad
783
                  WinkelOut.Winkel[1] = ToNaviCtrl.IntegralRoll;//(int) (IntegralRoll / (EE_Parameter.GyroAccFaktor * 4));  // etwa in 0.1 Grad
2346 holgerb 784
                  WinkelOut.UserParameter[0] = Parameter_UserParam1;
785
                  WinkelOut.UserParameter[1] = Parameter_UserParam2;
786
          SendOutData('k', MK3MAG_ADDRESS, 1, (unsigned char *) &WinkelOut,sizeof(WinkelOut));
787
          if(WinkelOut.CalcState > 4)  WinkelOut.CalcState = 6; // wird dann in SPI auf Null gesetzt
2416 holgerb 788
          if(JustMK3MagConnected) Kompass_Timer = SetDelay(99);
2346 holgerb 789
                  else Kompass_Timer = SetDelay(999);
790
         }
1636 ingob 791
#ifdef DEBUG                                                                                                                    // only include functions if DEBUG is defined
792
     if(SendDebugOutput && UebertragungAbgeschlossen)
793
     {
794
                 SendOutData('0', FC_ADDRESS, 1, (unsigned char *) &tDebug, sizeof(tDebug));
795
                 SendDebugOutput = 0;
796
         }
1654 killagreg 797
#endif
1 ingob 798
}
799
 
1636 ingob 800