WebSVN - FlightCtrl - Diff - Rev 1178 and 1340


// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Copyright (c) Holger Buss, Ingo Busker
// + only for non-profit use
// + www.MikroKopter.com
// + see the File "License.txt" for further Informations
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#include <stdarg.h>
#include <string.h>
#include "main.h"
#include "uart.h"
 
 
#define FC_ADDRESS 1
#define NC_ADDRESS 2
#define MK3MAG_ADDRESS 3
 
unsigned char GetExternalControl = 0,DebugDisplayAnforderung1 = 0, DebugDisplayAnforderung = 0,DebugDataAnforderung = 0,GetVersionAnforderung = 0, GetPPMChannelAnforderung = 0;
unsigned char DisplayLine = 0;
unsigned volatile char SioTmp = 0;
unsigned volatile char SendeBuffer[MAX_SENDE_BUFF];
unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF];
unsigned volatile char NMEABuffer[MAX_EMPFANGS_BUFF];
unsigned volatile char NeuerDatensatzEmpfangen = 0;
unsigned volatile char NeueKoordinateEmpfangen = 0;
unsigned volatile char UebertragungAbgeschlossen = 1;
unsigned volatile char CntCrcError = 0;
unsigned volatile char AnzahlEmpfangsBytes = 0;
unsigned char *pRxData = 0;
unsigned char RxDataLen = 0;
unsigned volatile char PC_DebugTimeout = 0;
 
unsigned char DebugTextAnforderung = 255;
unsigned char PcZugriff = 100;
unsigned char MotorTest[4] = {0,0,0,0};
unsigned char MeineSlaveAdresse = 1; // Flight-Ctrl
unsigned char ConfirmFrame;
struct str_DebugOut    DebugOut;
struct str_ExternControl  ExternControl;
struct str_VersionInfo VersionInfo;
struct str_WinkelOut WinkelOut;
struct str_Data3D Data3D;
 
int Debug_Timer,Kompass_Timer,Timer3D;
unsigned int DebugDataIntervall = 200, Intervall3D = 0;
 
const unsigned char ANALOG_TEXT[32][16] =
{
   //1234567890123456
    "AngleNick       ", //0
    "AngleRoll       ",
    "AccNick         ",
    "AccRoll         ",
    "GyroGier        ",
    "Hight Value     ", //5
    "AccZ            ",
    "Gas             ",
    "Compass Value   ",
    "Voltage         ",
    "Empfang         ", //10
    "Gyro Kompass    ",
    "Motor Front     ",
    "Motor Rear      ",
    "Motor Left      ",
    "Motor Right     ", //15
    "                ",
    "                ",
    "                ",
    "MK3Mag CalState ",
    "Servo           ", //20
    "                ",
    "                ",
    "                ",
    "                ",
    "                ", //25
    "                ",
    "Kalman_MaxDrift ",
    "                ",
    "                ",
    "GPS_Nick        ", //30
    "GPS_Roll        "
};
 
 
 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++ Sende-Part der Datenübertragung
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
SIGNAL(INT_VEC_TX)
{
 static unsigned int ptr = 0;
 unsigned char tmp_tx;
 if(!UebertragungAbgeschlossen)
  {
   ptr++;                    // die [0] wurde schon gesendet
   tmp_tx = SendeBuffer[ptr];
   if((tmp_tx == '\r') || (ptr == MAX_SENDE_BUFF))
    {
     ptr = 0;
     UebertragungAbgeschlossen = 1;
    }
   UDR = tmp_tx;
  }
  else ptr = 0;
}
 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++ Empfangs-Part der Datenübertragung, incl. CRC-Auswertung
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
SIGNAL(INT_VEC_RX)
{
 static unsigned int crc;
 static unsigned char crc1,crc2,buf_ptr;
 static unsigned char UartState = 0;
 unsigned char CrcOkay = 0;
 
 SioTmp = UDR;
 if(buf_ptr >= MAX_EMPFANGS_BUFF)    UartState = 0;
 if(SioTmp == '\r' && UartState == 2)
  {
   UartState = 0;
   crc -= RxdBuffer[buf_ptr-2];
   crc -= RxdBuffer[buf_ptr-1];
   crc %= 4096;
   crc1 = '=' + crc / 64;
   crc2 = '=' + crc % 64;
   CrcOkay = 0;
   if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; CntCrcError++;};
   if(!NeuerDatensatzEmpfangen && CrcOkay) // Datensatz schon verarbeitet
    {
     NeuerDatensatzEmpfangen = 1;
         AnzahlEmpfangsBytes = buf_ptr + 1;
     RxdBuffer[buf_ptr] = '\r';
         if(RxdBuffer[2] == 'R') wdt_enable(WDTO_250MS); // Reset-Commando
        }
  }
  else
  switch(UartState)
  {
   case 0:
          if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1;  // Startzeichen und Daten schon verarbeitet
                  buf_ptr = 0;
                  RxdBuffer[buf_ptr++] = SioTmp;
                  crc = SioTmp;
          break;
   case 1: // Adresse auswerten
                  UartState++;
                  RxdBuffer[buf_ptr++] = SioTmp;
                  crc += SioTmp;
                  break;
   case 2: //  Eingangsdaten sammeln
                  RxdBuffer[buf_ptr] = SioTmp;
                  if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;
                  else UartState = 0;
                  crc += SioTmp;
                  break;
   default:
          UartState = 0;
          break;
  }
}
 
 
// --------------------------------------------------------------------------
void AddCRC(unsigned int wieviele)
{
 unsigned int tmpCRC = 0,i;
 for(i = 0; i < wieviele;i++)
  {
   tmpCRC += SendeBuffer[i];
  }
   tmpCRC %= 4096;
   SendeBuffer[i++] = '=' + tmpCRC / 64;
   SendeBuffer[i++] = '=' + tmpCRC % 64;
   SendeBuffer[i++] = '\r';
  UebertragungAbgeschlossen = 0;
  UDR = SendeBuffer[0];
}
 
 
 
// --------------------------------------------------------------------------
void SendOutData(unsigned char cmd,unsigned char address, unsigned char BufferAnzahl, ...) //unsigned char *snd, unsigned char len)
{
 va_list ap;
 unsigned int pt = 0;
 unsigned char a,b,c;
 unsigned char ptr = 0;
 
 unsigned char *snd = 0;
 int len = 0;
 
 SendeBuffer[pt++] = '#';                               // Startzeichen
 SendeBuffer[pt++] = 'a' + address;             // Adresse (a=0; b=1,...)
 SendeBuffer[pt++] = cmd;                               // Commando
 
 va_start(ap, BufferAnzahl);
 if(BufferAnzahl)
 {
                snd = va_arg(ap, unsigned char*);
                len = va_arg(ap, int);
                ptr = 0;
                BufferAnzahl--;
 }
 while(len)
  {
        if(len)
        {
           a = snd[ptr++];
           len--;
           if((!len) && BufferAnzahl)
                {
                        snd = va_arg(ap, unsigned char*);
                        len = va_arg(ap, int);
                        ptr = 0;
                        BufferAnzahl--;
                }
        }
        else a = 0;
        if(len)
        {
                b = snd[ptr++];
                len--;
                if((!len) && BufferAnzahl)
                {
                        snd = va_arg(ap, unsigned char*);
                        len = va_arg(ap, int);
                        ptr = 0;
                        BufferAnzahl--;
                }
        }
        else b = 0;
        if(len)
        {
                c = snd[ptr++];
                len--;
                if((!len) && BufferAnzahl)
                {
                        snd = va_arg(ap, unsigned char*);
                        len = va_arg(ap, int);
                        ptr = 0;
                        BufferAnzahl--;
                }
        }
        else c = 0;
   SendeBuffer[pt++] = '=' + (a >> 2);
   SendeBuffer[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4));
   SendeBuffer[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6));
   SendeBuffer[pt++] = '=' + ( c & 0x3f);
  }
 va_end(ap);
 AddCRC(pt);
}
 
 
// --------------------------------------------------------------------------
void Decode64(void)  // die daten werden im rx buffer dekodiert, das geht nur, weil aus 4 byte immer 3 gemacht werden.
{
 unsigned char a,b,c,d;
 unsigned char x,y,z;
 unsigned char ptrIn = 3; // start at begin of data block
 unsigned char ptrOut = 3;
 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.
 
 while(len)
  {
   a = RxdBuffer[ptrIn++] - '=';
   b = RxdBuffer[ptrIn++] - '=';
   c = RxdBuffer[ptrIn++] - '=';
   d = RxdBuffer[ptrIn++] - '=';
 
   x = (a << 2) | (b >> 4);
   y = ((b & 0x0f) << 4) | (c >> 2);
   z = ((c & 0x03) << 6) | d;
 
   if(len--) RxdBuffer[ptrOut++] = x; else break;
   if(len--) RxdBuffer[ptrOut++] = y; else break;
   if(len--) RxdBuffer[ptrOut++] = z;   else break;
  }
        pRxData = (unsigned char*)&RxdBuffer[3]; // decodierte Daten beginnen beim 4. Byte
        RxDataLen = ptrOut - 3;  // wie viele Bytes wurden dekodiert?
 
}
 
// --------------------------------------------------------------------------
void BearbeiteRxDaten(void)
{
 if(!NeuerDatensatzEmpfangen) return;
 
        unsigned char tempchar1, tempchar2;
        Decode64(); // dekodiere datenblock im Empfangsbuffer
        switch(RxdBuffer[1]-'a') // check for Slave Address
        {
                case FC_ADDRESS: // FC special commands
 
                switch(RxdBuffer[2])
                {
                        case 'K':// Kompasswert
                                        memcpy((unsigned char *)&KompassValue , (unsigned char *)pRxData, sizeof(KompassValue));
                                        KompassRichtung = ((540 + KompassValue - KompassStartwert) % 360) - 180;
                                        break;
 
                        case 't':// Motortest
                                        memcpy(&MotorTest[0], (unsigned char *)pRxData, sizeof(MotorTest));
                                        //while(!UebertragungAbgeschlossen);
                                        //SendOutData('T', MeineSlaveAdresse, 0);
                                        PcZugriff = 255;
                                        break;
 
                        case 'p': // get PPM Channels
                                        GetPPMChannelAnforderung = 1;
                                        break;
 
                        case 'q':// "Get"-Anforderung für Settings
                                        // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
                                        if(pRxData[0] == 0xFF)
                                        {
                                                pRxData[0] = GetActiveParamSetNumber();
                                        }
                                        // limit settings range
                                        if(pRxData[0] < 1) pRxData[0] = 1; // limit to 5
                                        else if(pRxData[0] > 5) pRxData[0] = 5; // limit to 5
                                        // load requested parameter set
                                        ReadParameterSet(pRxData[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
 
                                        while(!UebertragungAbgeschlossen);
                                        tempchar1 = pRxData[0];
                                        tempchar2 = EE_DATENREVISION;
                                        SendOutData('Q', FC_ADDRESS, 3, &tempchar1, sizeof(tempchar1), &tempchar2, sizeof(tempchar2), (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
                                        break;
 
                        case 's': // Parametersatz speichern
                                        if((1 <= pRxData[0]) && (pRxData[0] <= 5) && (pRxData[1] == EE_DATENREVISION)) // check for setting to be in range
                                        {
                                                memcpy((unsigned char *) &EE_Parameter.Kanalbelegung[0], (unsigned char *)&pRxData[2], STRUCT_PARAM_LAENGE);
                                                WriteParameterSet(pRxData[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
                                                Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;
                                                Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;
                                                SetActiveParamSetNumber(pRxData[0]);
                                                tempchar1 = GetActiveParamSetNumber();
                                                Piep(tempchar1);
                                        }
                                        else
                                        {
                                                tempchar1 = 0; // mark in response an invlid setting
                                        }
                                        while(!UebertragungAbgeschlossen);
                                        SendOutData('S', FC_ADDRESS, 1, &tempchar1, sizeof(tempchar1));
                                        break;
 
                } // case FC_ADDRESS:
 
                default: // any Slave Address
 
                switch(RxdBuffer[2])
                {
                        // 't' comand placed here only for compatibility to BL
                        case 't':// Motortest
                                        memcpy(&MotorTest[0], (unsigned char *)pRxData, sizeof(MotorTest));
                                        while(!UebertragungAbgeschlossen);
                                        SendOutData('T', MeineSlaveAdresse, 0);
                                        PcZugriff = 255;
                                        break;
                        // 'K' comand placed here only for compatibility to old MK3MAG software, that does not send the right Slave Address
                        case 'K':// Kompasswert
                                        memcpy((unsigned char *)&KompassValue , (unsigned char *)pRxData, sizeof(KompassValue));
                                        KompassRichtung = ((540 + KompassValue - KompassStartwert) % 360) - 180;
                                        break;
                        case 'a':// Texte der Analogwerte
                                        DebugTextAnforderung = pRxData[0];
                                        if (DebugTextAnforderung > 31) DebugTextAnforderung = 31;
                                        PcZugriff = 255;
                                        break;
                        case 'b':
                                        memcpy((unsigned char *)&ExternControl, (unsigned char *)pRxData, sizeof(ExternControl));
                                        ConfirmFrame = ExternControl.Frame;
                                        PcZugriff = 255;
                                        break;
                        case 'c': // Poll the 3D-Data
                    if(!Intervall3D) { if(pRxData[0]) Timer3D = SetDelay(pRxData[0] * 10);}
                                        Intervall3D = pRxData[0] * 10;
                                        break;
                        case 'd': // Poll the debug data
                                        DebugDataIntervall = pRxData[0] * 10;
                                        if(DebugDataIntervall > 0) DebugDataAnforderung = 1;
                                        break;
 
                        case 'h':// x-1 Displayzeilen
                                PcZugriff = 255;
                                        RemoteKeys |= pRxData[0];
                                        if(RemoteKeys) DisplayLine = 0;
                                        DebugDisplayAnforderung = 1;
                                        break;
 
                        case 'l':// x-1 Displayzeilen
                                PcZugriff = 255;
                                        MenuePunkt = pRxData[0];
                                        DebugDisplayAnforderung1 = 1;
                                        break;
                        case 'v': // Version-Anforderung und Ausbaustufe
                                        GetVersionAnforderung = 1;
                                        break;
 
                        case 'g'://
                                        GetExternalControl = 1;
                                        break;
                }
                break; // default:
        }
        NeuerDatensatzEmpfangen = 0;
        pRxData = 0;
        RxDataLen = 0;
}
 
//############################################################################
//Routine für die Serielle Ausgabe
int uart_putchar (char c)
//############################################################################
{
        if (c == '\n')
                uart_putchar('\r');
        //Warten solange bis Zeichen gesendet wurde
        loop_until_bit_is_set(USR, UDRE);
        //Ausgabe des Zeichens
        UDR = c;
 
        return (0);
}
 
// --------------------------------------------------------------------------
void WriteProgramData(unsigned int pos, unsigned char wert)
{
  //if (ProgramLocation == IN_RAM) Buffer[pos] = wert;
  // else eeprom_write_byte(&EE_Buffer[pos], wert);
  // Buffer[pos] = wert;
}
 
//############################################################################
//INstallation der Seriellen Schnittstelle
void UART_Init (void)
//############################################################################
{
        //Enable TXEN im Register UCR TX-Data Enable & RX Enable
 
        UCR=(1 << TXEN) | (1 << RXEN);
    // UART Double Speed (U2X)
        USR   |= (1<<U2X);
        // RX-Interrupt Freigabe
        UCSRB |= (1<<RXCIE);
        // TX-Interrupt Freigabe
        UCSRB |= (1<<TXCIE);
 
        //Teiler wird gesetzt
        UBRR=(SYSCLK / (BAUD_RATE * 8L) - 1);
        //UBRR = 33;
        //öffnet einen Kanal für printf (STDOUT)
        //fdevopen (uart_putchar, 0);
        //sbi(PORTD,4);
        Debug_Timer = SetDelay(DebugDataIntervall);
        Kompass_Timer = SetDelay(220);
 
        VersionInfo.SWMajor = VERSION_MAJOR;
        VersionInfo.SWMinor = VERSION_MINOR;
        VersionInfo.SWPatch = VERSION_PATCH;
        VersionInfo.ProtoMajor  = VERSION_SERIAL_MAJOR;
        VersionInfo.ProtoMinor  = VERSION_SERIAL_MINOR;
 
        pRxData = 0;
        RxDataLen = 0;
}
 
//---------------------------------------------------------------------------------------------
void DatenUebertragung(void)
{
 if(!UebertragungAbgeschlossen) return;
 
        if(DebugDisplayAnforderung && UebertragungAbgeschlossen)
        {
                Menu();
                SendOutData('H', FC_ADDRESS, 2, &DisplayLine, sizeof(DisplayLine), &DisplayBuff[DisplayLine * 20], 20);
                DisplayLine++;
                if(DisplayLine >= 4) DisplayLine = 0;
                DebugDisplayAnforderung = 0;
        }
        if(DebugDisplayAnforderung1 && UebertragungAbgeschlossen)
        {
                Menu();
                SendOutData('L', FC_ADDRESS, 3, &MenuePunkt, sizeof(MenuePunkt), &MaxMenue, sizeof(MaxMenue), DisplayBuff, sizeof(DisplayBuff));
                DebugDisplayAnforderung1 = 0;
        }
        if(GetVersionAnforderung && UebertragungAbgeschlossen)
        {
                SendOutData('V', FC_ADDRESS, 1, (unsigned char *) &VersionInfo, sizeof(VersionInfo));
                GetVersionAnforderung = 0;
        }
 
        if(GetExternalControl && UebertragungAbgeschlossen)           // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
        {
                SendOutData('G',MeineSlaveAdresse, 1, (unsigned char *) &ExternControl, sizeof(ExternControl));
                GetExternalControl = 0;
        }
    if((CheckDelay(Kompass_Timer)) && UebertragungAbgeschlossen)
         {
                  WinkelOut.Winkel[0] = (int) (IntegralNick / (EE_Parameter.GyroAccFaktor * 4));  // etwa in 0.1 Grad
                  WinkelOut.Winkel[1] = (int) (IntegralRoll / (EE_Parameter.GyroAccFaktor * 4));  // etwa in 0.1 Grad
                  WinkelOut.UserParameter[0] = Parameter_UserParam1;
                  WinkelOut.UserParameter[1] = Parameter_UserParam2;
          SendOutData('w', MK3MAG_ADDRESS, 1, (unsigned char *) &WinkelOut,sizeof(WinkelOut));
          if(WinkelOut.CalcState > 4)  WinkelOut.CalcState = 6; // wird dann in SPI auf Null gesetzt
          Kompass_Timer = SetDelay(99);
         }
    if(((DebugDataIntervall>0 && CheckDelay(Debug_Timer)) || DebugDataAnforderung) && UebertragungAbgeschlossen)
         {
          SendOutData('D', FC_ADDRESS, 1, (unsigned char *) &DebugOut,sizeof(DebugOut));
          DebugDataAnforderung = 0;
          if(DebugDataIntervall>0) Debug_Timer = SetDelay(DebugDataIntervall);
         }
    if(Intervall3D > 0 && CheckDelay(Timer3D) && UebertragungAbgeschlossen)
         {
                  Data3D.Winkel[0] = (int) (IntegralNick / (EE_Parameter.GyroAccFaktor * 4));  // etwa in 0.1 Grad
                  Data3D.Winkel[1] = (int) (IntegralRoll / (EE_Parameter.GyroAccFaktor * 4));  // etwa in 0.1 Grad
          Data3D.Winkel[2] = (int) ((10 * ErsatzKompass) / GIER_GRAD_FAKTOR);
          SendOutData('C', FC_ADDRESS, 1, (unsigned char *) &Data3D,sizeof(Data3D));
          Timer3D = SetDelay(Intervall3D);
         }
    if(DebugTextAnforderung != 255) // Texte für die Analogdaten
     {
      SendOutData('A', FC_ADDRESS, 2, (unsigned char *)&DebugTextAnforderung, sizeof(DebugTextAnforderung),(unsigned char *) ANALOG_TEXT[DebugTextAnforderung], 16);
      DebugTextAnforderung = 255;
         }
     if(ConfirmFrame && UebertragungAbgeschlossen)   // Datensatz bestätigen
         {
                SendOutData('B', FC_ADDRESS, 1, (uint8_t*)&ConfirmFrame, sizeof(ConfirmFrame));
        ConfirmFrame = 0;
     }
 
     if(GetPPMChannelAnforderung && UebertragungAbgeschlossen)
     {
                 SendOutData('P', FC_ADDRESS, 1, (unsigned char *) &PPM_in, sizeof(PPM_in));
                 GetPPMChannelAnforderung = 0;
         }
 
}
 
 

Rev 1178	Rev 1340
1	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	1	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2	// + Copyright (c) 04.2007 Holger Buss	2	// + Copyright (c) Holger Buss, Ingo Busker
3	// + only for non-profit use	3	// + only for non-profit use
4	// + www.MikroKopter.com	4	// + www.MikroKopter.com
5	// + see the File "License.txt" for further Informations	5	// + see the File "License.txt" for further Informations
6	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	6	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
7	#include <stdarg.h>	7	#include <stdarg.h>
8	#include <string.h>	8	#include <string.h>
9	#include "main.h"	9	#include "main.h"
10	#include "uart.h"	10	#include "uart.h"
11		11
12		12
13	#define FC_ADDRESS 1	13	#define FC_ADDRESS 1
14	#define NC_ADDRESS 2	14	#define NC_ADDRESS 2
15	#define MK3MAG_ADDRESS 3	15	#define MK3MAG_ADDRESS 3
16		16
17	unsigned char GetExternalControl = 0,DebugDisplayAnforderung1 = 0, DebugDisplayAnforderung = 0,DebugDataAnforderung = 0,GetVersionAnforderung = 0, GetPPMChannelAnforderung = 0;	17	unsigned char GetExternalControl = 0,DebugDisplayAnforderung1 = 0, DebugDisplayAnforderung = 0,DebugDataAnforderung = 0,GetVersionAnforderung = 0, GetPPMChannelAnforderung = 0;
18	unsigned char DisplayLine = 0;	18	unsigned char DisplayLine = 0;
19	unsigned volatile char SioTmp = 0;	19	unsigned volatile char SioTmp = 0;
20	unsigned volatile char SendeBuffer[MAX_SENDE_BUFF];	20	unsigned volatile char SendeBuffer[MAX_SENDE_BUFF];
21	unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF];	21	unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF];
22	unsigned volatile char NMEABuffer[MAX_EMPFANGS_BUFF];	22	unsigned volatile char NMEABuffer[MAX_EMPFANGS_BUFF];
23	unsigned volatile char NeuerDatensatzEmpfangen = 0;	23	unsigned volatile char NeuerDatensatzEmpfangen = 0;
24	unsigned volatile char NeueKoordinateEmpfangen = 0;	24	unsigned volatile char NeueKoordinateEmpfangen = 0;
25	unsigned volatile char UebertragungAbgeschlossen = 1;	25	unsigned volatile char UebertragungAbgeschlossen = 1;
26	unsigned volatile char CntCrcError = 0;	26	unsigned volatile char CntCrcError = 0;
27	unsigned volatile char AnzahlEmpfangsBytes = 0;	27	unsigned volatile char AnzahlEmpfangsBytes = 0;
28	unsigned char *pRxData = 0;	28	unsigned char *pRxData = 0;
29	unsigned char RxDataLen = 0;	29	unsigned char RxDataLen = 0;
30	unsigned volatile char PC_DebugTimeout = 0;	30	unsigned volatile char PC_DebugTimeout = 0;
31		31
32	unsigned char DebugTextAnforderung = 255;	32	unsigned char DebugTextAnforderung = 255;
33	unsigned char PcZugriff = 100;	33	unsigned char PcZugriff = 100;
34	unsigned char MotorTest[4] = {0,0,0,0};	34	unsigned char MotorTest[4] = {0,0,0,0};
35	unsigned char MeineSlaveAdresse = 1; // Flight-Ctrl	35	unsigned char MeineSlaveAdresse = 1; // Flight-Ctrl
36	unsigned char ConfirmFrame;	36	unsigned char ConfirmFrame;
37	struct str_DebugOut DebugOut;	37	struct str_DebugOut DebugOut;
38	struct str_ExternControl ExternControl;	38	struct str_ExternControl ExternControl;
39	struct str_VersionInfo VersionInfo;	39	struct str_VersionInfo VersionInfo;
40	struct str_WinkelOut WinkelOut;	40	struct str_WinkelOut WinkelOut;
41	struct str_Data3D Data3D;	41	struct str_Data3D Data3D;
42		42
43	int Debug_Timer,Kompass_Timer,Timer3D;	43	int Debug_Timer,Kompass_Timer,Timer3D;
44	unsigned int DebugDataIntervall = 200, Intervall3D = 0;	44	unsigned int DebugDataIntervall = 200, Intervall3D = 0;
45		45
46	const unsigned char ANALOG_TEXT[32][16] =	46	const unsigned char ANALOG_TEXT[32][16] =
47	{	47	{
48	//1234567890123456	48	//1234567890123456
49	"AngleNick ", //0	49	"AngleNick ", //0
50	"AngleRoll ",	50	"AngleRoll ",
51	"AccNick ",	51	"AccNick ",
52	"AccRoll ",	52	"AccRoll ",
53	"GyroGier ",	53	"GyroGier ",
54	"Hight Value ", //5	54	"Hight Value ", //5
55	"AccZ ",	55	"AccZ ",
56	"Gas ",	56	"Gas ",
57	"Compass Value ",	57	"Compass Value ",
58	"Voltage ",	58	"Voltage ",
59	"Empfang ", //10	59	"Empfang ", //10
60	"Gyro Kompass ",	60	"Gyro Kompass ",
61	"Motor Front ",	61	"Motor Front ",
62	"Motor Rear ",	62	"Motor Rear ",
63	"Motor Left ",	63	"Motor Left ",
64	"Motor Right ", //15	64	"Motor Right ", //15
65	" ",	65	" ",
66	" ",	66	" ",
67	" ",	67	" ",
68	"MK3Mag CalState ",	68	"MK3Mag CalState ",
69	"Servo ", //20	69	"Servo ", //20
70	" ",	70	" ",
71	" ",	71	" ",
72	" ",	72	" ",
73	" ",	73	" ",
74	" ", //25	74	" ", //25
75	" ",	75	" ",
76	"Kalman_MaxDrift ",	76	"Kalman_MaxDrift ",
77	" ",	77	" ",
78	" ",	78	" ",
79	"GPS_Nick ", //30	79	"GPS_Nick ", //30
80	"GPS_Roll "	80	"GPS_Roll "
81	};	81	};
82		82
83		83
84		84
85	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	85	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
86	//++ Sende-Part der Datenübertragung	86	//++ Sende-Part der Datenübertragung
87	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	87	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
88	SIGNAL(INT_VEC_TX)	88	SIGNAL(INT_VEC_TX)
89	{	89	{
90	static unsigned int ptr = 0;	90	static unsigned int ptr = 0;
91	unsigned char tmp_tx;	91	unsigned char tmp_tx;
92	if(!UebertragungAbgeschlossen)	92	if(!UebertragungAbgeschlossen)
93	{	93	{
94	ptr++; // die [0] wurde schon gesendet	94	ptr++; // die [0] wurde schon gesendet
95	tmp_tx = SendeBuffer[ptr];	95	tmp_tx = SendeBuffer[ptr];
96	if((tmp_tx == '\r') \|\| (ptr == MAX_SENDE_BUFF))	96	if((tmp_tx == '\r') \|\| (ptr == MAX_SENDE_BUFF))
97	{	97	{
98	ptr = 0;	98	ptr = 0;
99	UebertragungAbgeschlossen = 1;	99	UebertragungAbgeschlossen = 1;
100	}	100	}
101	UDR = tmp_tx;	101	UDR = tmp_tx;
102	}	102	}
103	else ptr = 0;	103	else ptr = 0;
104	}	104	}
105		105
106	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	106	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
107	//++ Empfangs-Part der Datenübertragung, incl. CRC-Auswertung	107	//++ Empfangs-Part der Datenübertragung, incl. CRC-Auswertung
108	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	108	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
109	SIGNAL(INT_VEC_RX)	109	SIGNAL(INT_VEC_RX)
110	{	110	{
111	static unsigned int crc;	111	static unsigned int crc;
112	static unsigned char crc1,crc2,buf_ptr;	112	static unsigned char crc1,crc2,buf_ptr;
113	static unsigned char UartState = 0;	113	static unsigned char UartState = 0;
114	unsigned char CrcOkay = 0;	114	unsigned char CrcOkay = 0;
115		115
116	SioTmp = UDR;	116	SioTmp = UDR;
117	if(buf_ptr >= MAX_EMPFANGS_BUFF) UartState = 0;	117	if(buf_ptr >= MAX_EMPFANGS_BUFF) UartState = 0;
118	if(SioTmp == '\r' && UartState == 2)	118	if(SioTmp == '\r' && UartState == 2)
119	{	119	{
120	UartState = 0;	120	UartState = 0;
121	crc -= RxdBuffer[buf_ptr-2];	121	crc -= RxdBuffer[buf_ptr-2];
122	crc -= RxdBuffer[buf_ptr-1];	122	crc -= RxdBuffer[buf_ptr-1];
123	crc %= 4096;	123	crc %= 4096;
124	crc1 = '=' + crc / 64;	124	crc1 = '=' + crc / 64;
125	crc2 = '=' + crc % 64;	125	crc2 = '=' + crc % 64;
126	CrcOkay = 0;	126	CrcOkay = 0;
127	if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; CntCrcError++;};	127	if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; CntCrcError++;};
128	if(!NeuerDatensatzEmpfangen && CrcOkay) // Datensatz schon verarbeitet	128	if(!NeuerDatensatzEmpfangen && CrcOkay) // Datensatz schon verarbeitet
129	{	129	{
130	NeuerDatensatzEmpfangen = 1;	130	NeuerDatensatzEmpfangen = 1;
131	AnzahlEmpfangsBytes = buf_ptr + 1;	131	AnzahlEmpfangsBytes = buf_ptr + 1;
132	RxdBuffer[buf_ptr] = '\r';	132	RxdBuffer[buf_ptr] = '\r';
133	if(RxdBuffer[2] == 'R') wdt_enable(WDTO_250MS); // Reset-Commando	133	if(RxdBuffer[2] == 'R') wdt_enable(WDTO_250MS); // Reset-Commando
134	}	134	}
135	}	135	}
136	else	136	else
137	switch(UartState)	137	switch(UartState)
138	{	138	{
139	case 0:	139	case 0:
140	if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1; // Startzeichen und Daten schon verarbeitet	140	if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1; // Startzeichen und Daten schon verarbeitet
141	buf_ptr = 0;	141	buf_ptr = 0;
142	RxdBuffer[buf_ptr++] = SioTmp;	142	RxdBuffer[buf_ptr++] = SioTmp;
143	crc = SioTmp;	143	crc = SioTmp;
144	break;	144	break;
145	case 1: // Adresse auswerten	145	case 1: // Adresse auswerten
146	UartState++;	146	UartState++;
147	RxdBuffer[buf_ptr++] = SioTmp;	147	RxdBuffer[buf_ptr++] = SioTmp;
148	crc += SioTmp;	148	crc += SioTmp;
149	break;	149	break;
150	case 2: // Eingangsdaten sammeln	150	case 2: // Eingangsdaten sammeln
151	RxdBuffer[buf_ptr] = SioTmp;	151	RxdBuffer[buf_ptr] = SioTmp;
152	if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;	152	if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;
153	else UartState = 0;	153	else UartState = 0;
154	crc += SioTmp;	154	crc += SioTmp;
155	break;	155	break;
156	default:	156	default:
157	UartState = 0;	157	UartState = 0;
158	break;	158	break;
159	}	159	}
160	}	160	}
161		161
162		162
163	// --------------------------------------------------------------------------	163	// --------------------------------------------------------------------------
164	void AddCRC(unsigned int wieviele)	164	void AddCRC(unsigned int wieviele)
165	{	165	{
166	unsigned int tmpCRC = 0,i;	166	unsigned int tmpCRC = 0,i;
167	for(i = 0; i < wieviele;i++)	167	for(i = 0; i < wieviele;i++)
168	{	168	{
169	tmpCRC += SendeBuffer[i];	169	tmpCRC += SendeBuffer[i];
170	}	170	}
171	tmpCRC %= 4096;	171	tmpCRC %= 4096;
172	SendeBuffer[i++] = '=' + tmpCRC / 64;	172	SendeBuffer[i++] = '=' + tmpCRC / 64;
173	SendeBuffer[i++] = '=' + tmpCRC % 64;	173	SendeBuffer[i++] = '=' + tmpCRC % 64;
174	SendeBuffer[i++] = '\r';	174	SendeBuffer[i++] = '\r';
175	UebertragungAbgeschlossen = 0;	175	UebertragungAbgeschlossen = 0;
176	UDR = SendeBuffer[0];	176	UDR = SendeBuffer[0];
177	}	177	}
178		178
179		179
180		180
181	// --------------------------------------------------------------------------	181	// --------------------------------------------------------------------------
182	void SendOutData(unsigned char cmd,unsigned char address, unsigned char BufferAnzahl, ...) //unsigned char *snd, unsigned char len)	182	void SendOutData(unsigned char cmd,unsigned char address, unsigned char BufferAnzahl, ...) //unsigned char *snd, unsigned char len)
183	{	183	{
184	va_list ap;	184	va_list ap;
185	unsigned int pt = 0;	185	unsigned int pt = 0;
186	unsigned char a,b,c;	186	unsigned char a,b,c;
187	unsigned char ptr = 0;	187	unsigned char ptr = 0;
188		188
189	unsigned char *snd = 0;	189	unsigned char *snd = 0;
190	int len = 0;	190	int len = 0;
191		191
192	SendeBuffer[pt++] = '#'; // Startzeichen	192	SendeBuffer[pt++] = '#'; // Startzeichen
193	SendeBuffer[pt++] = 'a' + address; // Adresse (a=0; b=1,...)	193	SendeBuffer[pt++] = 'a' + address; // Adresse (a=0; b=1,...)
194	SendeBuffer[pt++] = cmd; // Commando	194	SendeBuffer[pt++] = cmd; // Commando
195		195
196	va_start(ap, BufferAnzahl);	196	va_start(ap, BufferAnzahl);
197	if(BufferAnzahl)	197	if(BufferAnzahl)
198	{	198	{
199	snd = va_arg(ap, unsigned char*);	199	snd = va_arg(ap, unsigned char*);
200	len = va_arg(ap, int);	200	len = va_arg(ap, int);
201	ptr = 0;	201	ptr = 0;
202	BufferAnzahl--;	202	BufferAnzahl--;
203	}	203	}
204	while(len)	204	while(len)
205	{	205	{
206	if(len)	206	if(len)
207	{	207	{
208	a = snd[ptr++];	208	a = snd[ptr++];
209	len--;	209	len--;
210	if((!len) && BufferAnzahl)	210	if((!len) && BufferAnzahl)
211	{	211	{
212	snd = va_arg(ap, unsigned char*);	212	snd = va_arg(ap, unsigned char*);
213	len = va_arg(ap, int);	213	len = va_arg(ap, int);
214	ptr = 0;	214	ptr = 0;
215	BufferAnzahl--;	215	BufferAnzahl--;
216	}	216	}
217	}	217	}
218	else a = 0;	218	else a = 0;
219	if(len)	219	if(len)
220	{	220	{
221	b = snd[ptr++];	221	b = snd[ptr++];
222	len--;	222	len--;
223	if((!len) && BufferAnzahl)	223	if((!len) && BufferAnzahl)
224	{	224	{
225	snd = va_arg(ap, unsigned char*);	225	snd = va_arg(ap, unsigned char*);
226	len = va_arg(ap, int);	226	len = va_arg(ap, int);
227	ptr = 0;	227	ptr = 0;
228	BufferAnzahl--;	228	BufferAnzahl--;
229	}	229	}
230	}	230	}
231	else b = 0;	231	else b = 0;
232	if(len)	232	if(len)
233	{	233	{
234	c = snd[ptr++];	234	c = snd[ptr++];
235	len--;	235	len--;
236	if((!len) && BufferAnzahl)	236	if((!len) && BufferAnzahl)
237	{	237	{
238	snd = va_arg(ap, unsigned char*);	238	snd = va_arg(ap, unsigned char*);
239	len = va_arg(ap, int);	239	len = va_arg(ap, int);
240	ptr = 0;	240	ptr = 0;
241	BufferAnzahl--;	241	BufferAnzahl--;
242	}	242	}
243	}	243	}
244	else c = 0;	244	else c = 0;
245	SendeBuffer[pt++] = '=' + (a >> 2);	245	SendeBuffer[pt++] = '=' + (a >> 2);
246	SendeBuffer[pt++] = '=' + (((a & 0x03) << 4) \| ((b & 0xf0) >> 4));	246	SendeBuffer[pt++] = '=' + (((a & 0x03) << 4) \| ((b & 0xf0) >> 4));
247	SendeBuffer[pt++] = '=' + (((b & 0x0f) << 2) \| ((c & 0xc0) >> 6));	247	SendeBuffer[pt++] = '=' + (((b & 0x0f) << 2) \| ((c & 0xc0) >> 6));
248	SendeBuffer[pt++] = '=' + ( c & 0x3f);	248	SendeBuffer[pt++] = '=' + ( c & 0x3f);
249	}	249	}
250	va_end(ap);	250	va_end(ap);
251	AddCRC(pt);	251	AddCRC(pt);
252	}	252	}
253		253
254		254
255	// --------------------------------------------------------------------------	255	// --------------------------------------------------------------------------
256	void Decode64(void) // die daten werden im rx buffer dekodiert, das geht nur, weil aus 4 byte immer 3 gemacht werden.	256	void Decode64(void) // die daten werden im rx buffer dekodiert, das geht nur, weil aus 4 byte immer 3 gemacht werden.
257	{	257	{
258	unsigned char a,b,c,d;	258	unsigned char a,b,c,d;
259	unsigned char x,y,z;	259	unsigned char x,y,z;
260	unsigned char ptrIn = 3; // start at begin of data block	260	unsigned char ptrIn = 3; // start at begin of data block
261	unsigned char ptrOut = 3;	261	unsigned char ptrOut = 3;
262	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.	262	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.
263		263
264	while(len)	264	while(len)
265	{	265	{
266	a = RxdBuffer[ptrIn++] - '=';	266	a = RxdBuffer[ptrIn++] - '=';
267	b = RxdBuffer[ptrIn++] - '=';	267	b = RxdBuffer[ptrIn++] - '=';
268	c = RxdBuffer[ptrIn++] - '=';	268	c = RxdBuffer[ptrIn++] - '=';
269	d = RxdBuffer[ptrIn++] - '=';	269	d = RxdBuffer[ptrIn++] - '=';
270		270
271	x = (a << 2) \| (b >> 4);	271	x = (a << 2) \| (b >> 4);
272	y = ((b & 0x0f) << 4) \| (c >> 2);	272	y = ((b & 0x0f) << 4) \| (c >> 2);
273	z = ((c & 0x03) << 6) \| d;	273	z = ((c & 0x03) << 6) \| d;
274		274
275	if(len--) RxdBuffer[ptrOut++] = x; else break;	275	if(len--) RxdBuffer[ptrOut++] = x; else break;
276	if(len--) RxdBuffer[ptrOut++] = y; else break;	276	if(len--) RxdBuffer[ptrOut++] = y; else break;
277	if(len--) RxdBuffer[ptrOut++] = z; else break;	277	if(len--) RxdBuffer[ptrOut++] = z; else break;
278	}	278	}
279	pRxData = (unsigned char*)&RxdBuffer[3]; // decodierte Daten beginnen beim 4. Byte	279	pRxData = (unsigned char*)&RxdBuffer[3]; // decodierte Daten beginnen beim 4. Byte
280	RxDataLen = ptrOut - 3; // wie viele Bytes wurden dekodiert?	280	RxDataLen = ptrOut - 3; // wie viele Bytes wurden dekodiert?
281		281
282	}	282	}
283		283
284	// --------------------------------------------------------------------------	284	// --------------------------------------------------------------------------
285	void BearbeiteRxDaten(void)	285	void BearbeiteRxDaten(void)
286	{	286	{
287	if(!NeuerDatensatzEmpfangen) return;	287	if(!NeuerDatensatzEmpfangen) return;
288		288
289	unsigned char tempchar1, tempchar2;	289	unsigned char tempchar1, tempchar2;
290	Decode64(); // dekodiere datenblock im Empfangsbuffer	290	Decode64(); // dekodiere datenblock im Empfangsbuffer
291	switch(RxdBuffer[1]-'a') // check for Slave Address	291	switch(RxdBuffer[1]-'a') // check for Slave Address
292	{	292	{
293	case FC_ADDRESS: // FC special commands	293	case FC_ADDRESS: // FC special commands
294		294
295	switch(RxdBuffer[2])	295	switch(RxdBuffer[2])
296	{	296	{
297	case 'K':// Kompasswert	297	case 'K':// Kompasswert
298	memcpy((unsigned char )&KompassValue , (unsigned char )pRxData, sizeof(KompassValue));	298	memcpy((unsigned char )&KompassValue , (unsigned char )pRxData, sizeof(KompassValue));
299	KompassRichtung = ((540 + KompassValue - KompassStartwert) % 360) - 180;	299	KompassRichtung = ((540 + KompassValue - KompassStartwert) % 360) - 180;
300	break;	300	break;
301		301
302	case 't':// Motortest	302	case 't':// Motortest
303	memcpy(&MotorTest[0], (unsigned char *)pRxData, sizeof(MotorTest));	303	memcpy(&MotorTest[0], (unsigned char *)pRxData, sizeof(MotorTest));
304	//while(!UebertragungAbgeschlossen);	304	//while(!UebertragungAbgeschlossen);
305	//SendOutData('T', MeineSlaveAdresse, 0);	305	//SendOutData('T', MeineSlaveAdresse, 0);
306	PcZugriff = 255;	306	PcZugriff = 255;
307	break;	307	break;
308		308
309	case 'p': // get PPM Channels	309	case 'p': // get PPM Channels
310	GetPPMChannelAnforderung = 1;	310	GetPPMChannelAnforderung = 1;
311	break;	311	break;
312		312
313	case 'q':// "Get"-Anforderung für Settings	313	case 'q':// "Get"-Anforderung für Settings
314	// Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen	314	// Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
315	if(pRxData[0] == 0xFF)	315	if(pRxData[0] == 0xFF)
316	{	316	{
317	pRxData[0] = GetActiveParamSetNumber();	317	pRxData[0] = GetActiveParamSetNumber();
318	}	318	}
319	// limit settings range	319	// limit settings range
320	if(pRxData[0] < 1) pRxData[0] = 1; // limit to 5	320	if(pRxData[0] < 1) pRxData[0] = 1; // limit to 5
321	else if(pRxData[0] > 5) pRxData[0] = 5; // limit to 5	321	else if(pRxData[0] > 5) pRxData[0] = 5; // limit to 5
322	// load requested parameter set	322	// load requested parameter set
323	ReadParameterSet(pRxData[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);	323	ReadParameterSet(pRxData[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
324		324
325	while(!UebertragungAbgeschlossen);	325	while(!UebertragungAbgeschlossen);
326	tempchar1 = pRxData[0];	326	tempchar1 = pRxData[0];
327	tempchar2 = EE_DATENREVISION;	327	tempchar2 = EE_DATENREVISION;
328	SendOutData('Q', FC_ADDRESS, 3, &tempchar1, sizeof(tempchar1), &tempchar2, sizeof(tempchar2), (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);	328	SendOutData('Q', FC_ADDRESS, 3, &tempchar1, sizeof(tempchar1), &tempchar2, sizeof(tempchar2), (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
329	break;	329	break;
330		330
331	case 's': // Parametersatz speichern	331	case 's': // Parametersatz speichern
332	if((1 <= pRxData[0]) && (pRxData[0] <= 5) && (pRxData[1] == EE_DATENREVISION)) // check for setting to be in range	332	if((1 <= pRxData[0]) && (pRxData[0] <= 5) && (pRxData[1] == EE_DATENREVISION)) // check for setting to be in range
333	{	333	{
334	memcpy((unsigned char ) &EE_Parameter.Kanalbelegung[0], (unsigned char )&pRxData[2], STRUCT_PARAM_LAENGE);	334	memcpy((unsigned char ) &EE_Parameter.Kanalbelegung[0], (unsigned char )&pRxData[2], STRUCT_PARAM_LAENGE);
335	WriteParameterSet(pRxData[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);	335	WriteParameterSet(pRxData[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
336	Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;	336	Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;
337	Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;	337	Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;
338	SetActiveParamSetNumber(pRxData[0]);	338	SetActiveParamSetNumber(pRxData[0]);
339	tempchar1 = GetActiveParamSetNumber();	339	tempchar1 = GetActiveParamSetNumber();
340	Piep(tempchar1);	340	Piep(tempchar1);
341	}	341	}
342	else	342	else
343	{	343	{
344	tempchar1 = 0; // mark in response an invlid setting	344	tempchar1 = 0; // mark in response an invlid setting
345	}	345	}
346	while(!UebertragungAbgeschlossen);	346	while(!UebertragungAbgeschlossen);
347	SendOutData('S', FC_ADDRESS, 1, &tempchar1, sizeof(tempchar1));	347	SendOutData('S', FC_ADDRESS, 1, &tempchar1, sizeof(tempchar1));
348	break;	348	break;
349		349
350	} // case FC_ADDRESS:	350	} // case FC_ADDRESS:
351		351
352	default: // any Slave Address	352	default: // any Slave Address
353		353
354	switch(RxdBuffer[2])	354	switch(RxdBuffer[2])
355	{	355	{
356	// 't' comand placed here only for compatibility to BL	356	// 't' comand placed here only for compatibility to BL
357	case 't':// Motortest	357	case 't':// Motortest
358	memcpy(&MotorTest[0], (unsigned char *)pRxData, sizeof(MotorTest));	358	memcpy(&MotorTest[0], (unsigned char *)pRxData, sizeof(MotorTest));
359	while(!UebertragungAbgeschlossen);	359	while(!UebertragungAbgeschlossen);
360	SendOutData('T', MeineSlaveAdresse, 0);	360	SendOutData('T', MeineSlaveAdresse, 0);
361	PcZugriff = 255;	361	PcZugriff = 255;
362	break;	362	break;
363	// 'K' comand placed here only for compatibility to old MK3MAG software, that does not send the right Slave Address	363	// 'K' comand placed here only for compatibility to old MK3MAG software, that does not send the right Slave Address
364	case 'K':// Kompasswert	364	case 'K':// Kompasswert
365	memcpy((unsigned char )&KompassValue , (unsigned char )pRxData, sizeof(KompassValue));	365	memcpy((unsigned char )&KompassValue , (unsigned char )pRxData, sizeof(KompassValue));
366	KompassRichtung = ((540 + KompassValue - KompassStartwert) % 360) - 180;	366	KompassRichtung = ((540 + KompassValue - KompassStartwert) % 360) - 180;
367	break;	367	break;
368	case 'a':// Texte der Analogwerte	368	case 'a':// Texte der Analogwerte
369	DebugTextAnforderung = pRxData[0];	369	DebugTextAnforderung = pRxData[0];
370	if (DebugTextAnforderung > 31) DebugTextAnforderung = 31;	370	if (DebugTextAnforderung > 31) DebugTextAnforderung = 31;
371	PcZugriff = 255;	371	PcZugriff = 255;
372	break;	372	break;
373	case 'b':	373	case 'b':
374	memcpy((unsigned char )&ExternControl, (unsigned char )pRxData, sizeof(ExternControl));	374	memcpy((unsigned char )&ExternControl, (unsigned char )pRxData, sizeof(ExternControl));
375	ConfirmFrame = ExternControl.Frame;	375	ConfirmFrame = ExternControl.Frame;
376	PcZugriff = 255;	376	PcZugriff = 255;
377	break;	377	break;
378	case 'c': // Poll the 3D-Data	378	case 'c': // Poll the 3D-Data
379	if(!Intervall3D) { if(pRxData[0]) Timer3D = SetDelay(pRxData[0] * 10);}	379	if(!Intervall3D) { if(pRxData[0]) Timer3D = SetDelay(pRxData[0] * 10);}
380	Intervall3D = pRxData[0] * 10;	380	Intervall3D = pRxData[0] * 10;
381	break;	381	break;
382	case 'd': // Poll the debug data	382	case 'd': // Poll the debug data
383	DebugDataIntervall = pRxData[0] * 10;	383	DebugDataIntervall = pRxData[0] * 10;
384	if(DebugDataIntervall > 0) DebugDataAnforderung = 1;	384	if(DebugDataIntervall > 0) DebugDataAnforderung = 1;
385	break;	385	break;
386		386
387	case 'h':// x-1 Displayzeilen	387	case 'h':// x-1 Displayzeilen
388	PcZugriff = 255;	388	PcZugriff = 255;
389	RemoteKeys \|= pRxData[0];	389	RemoteKeys \|= pRxData[0];
390	if(RemoteKeys) DisplayLine = 0;	390	if(RemoteKeys) DisplayLine = 0;
391	DebugDisplayAnforderung = 1;	391	DebugDisplayAnforderung = 1;
392	break;	392	break;
393		393
394	case 'l':// x-1 Displayzeilen	394	case 'l':// x-1 Displayzeilen
395	PcZugriff = 255;	395	PcZugriff = 255;
396	MenuePunkt = pRxData[0];	396	MenuePunkt = pRxData[0];
397	DebugDisplayAnforderung1 = 1;	397	DebugDisplayAnforderung1 = 1;
398	break;	398	break;
399	case 'v': // Version-Anforderung und Ausbaustufe	399	case 'v': // Version-Anforderung und Ausbaustufe
400	GetVersionAnforderung = 1;	400	GetVersionAnforderung = 1;
401	break;	401	break;
402		402
403	case 'g'://	403	case 'g'://
404	GetExternalControl = 1;	404	GetExternalControl = 1;
405	break;	405	break;
406	}	406	}
407	break; // default:	407	break; // default:
408	}	408	}
409	NeuerDatensatzEmpfangen = 0;	409	NeuerDatensatzEmpfangen = 0;
410	pRxData = 0;	410	pRxData = 0;
411	RxDataLen = 0;	411	RxDataLen = 0;
412	}	412	}
413		413
414	//############################################################################	414	//############################################################################
415	//Routine für die Serielle Ausgabe	415	//Routine für die Serielle Ausgabe
416	int uart_putchar (char c)	416	int uart_putchar (char c)
417	//############################################################################	417	//############################################################################
418	{	418	{
419	if (c == '\n')	419	if (c == '\n')
420	uart_putchar('\r');	420	uart_putchar('\r');
421	//Warten solange bis Zeichen gesendet wurde	421	//Warten solange bis Zeichen gesendet wurde
422	loop_until_bit_is_set(USR, UDRE);	422	loop_until_bit_is_set(USR, UDRE);
423	//Ausgabe des Zeichens	423	//Ausgabe des Zeichens
424	UDR = c;	424	UDR = c;
425		425
426	return (0);	426	return (0);
427	}	427	}
428		428
429	// --------------------------------------------------------------------------	429	// --------------------------------------------------------------------------
430	void WriteProgramData(unsigned int pos, unsigned char wert)	430	void WriteProgramData(unsigned int pos, unsigned char wert)
431	{	431	{
432	//if (ProgramLocation == IN_RAM) Buffer[pos] = wert;	432	//if (ProgramLocation == IN_RAM) Buffer[pos] = wert;
433	// else eeprom_write_byte(&EE_Buffer[pos], wert);	433	// else eeprom_write_byte(&EE_Buffer[pos], wert);
434	// Buffer[pos] = wert;	434	// Buffer[pos] = wert;
435	}	435	}
436		436
437	//############################################################################	437	//############################################################################
438	//INstallation der Seriellen Schnittstelle	438	//INstallation der Seriellen Schnittstelle
439	void UART_Init (void)	439	void UART_Init (void)
440	//############################################################################	440	//############################################################################
441	{	441	{
442	//Enable TXEN im Register UCR TX-Data Enable & RX Enable	442	//Enable TXEN im Register UCR TX-Data Enable & RX Enable
443		443
444	UCR=(1 << TXEN) \| (1 << RXEN);	444	UCR=(1 << TXEN) \| (1 << RXEN);
445	// UART Double Speed (U2X)	445	// UART Double Speed (U2X)
446	USR \|= (1<<U2X);	446	USR \|= (1<<U2X);
447	// RX-Interrupt Freigabe	447	// RX-Interrupt Freigabe
448	UCSRB \|= (1<<RXCIE);	448	UCSRB \|= (1<<RXCIE);
449	// TX-Interrupt Freigabe	449	// TX-Interrupt Freigabe
450	UCSRB \|= (1<<TXCIE);	450	UCSRB \|= (1<<TXCIE);
451		451
452	//Teiler wird gesetzt	452	//Teiler wird gesetzt
453	UBRR=(SYSCLK / (BAUD_RATE * 8L) - 1);	453	UBRR=(SYSCLK / (BAUD_RATE * 8L) - 1);
454	//UBRR = 33;	454	//UBRR = 33;
455	//öffnet einen Kanal für printf (STDOUT)	455	//öffnet einen Kanal für printf (STDOUT)
456	//fdevopen (uart_putchar, 0);	456	//fdevopen (uart_putchar, 0);
457	//sbi(PORTD,4);	457	//sbi(PORTD,4);
458	Debug_Timer = SetDelay(DebugDataIntervall);	458	Debug_Timer = SetDelay(DebugDataIntervall);
459	Kompass_Timer = SetDelay(220);	459	Kompass_Timer = SetDelay(220);
460		460
461	VersionInfo.SWMajor = VERSION_MAJOR;	461	VersionInfo.SWMajor = VERSION_MAJOR;
462	VersionInfo.SWMinor = VERSION_MINOR;	462	VersionInfo.SWMinor = VERSION_MINOR;
463	VersionInfo.SWPatch = VERSION_PATCH;	463	VersionInfo.SWPatch = VERSION_PATCH;
464	VersionInfo.ProtoMajor = VERSION_SERIAL_MAJOR;	464	VersionInfo.ProtoMajor = VERSION_SERIAL_MAJOR;
465	VersionInfo.ProtoMinor = VERSION_SERIAL_MINOR;	465	VersionInfo.ProtoMinor = VERSION_SERIAL_MINOR;
466		466
467	pRxData = 0;	467	pRxData = 0;
468	RxDataLen = 0;	468	RxDataLen = 0;
469	}	469	}
470		470
471	//---------------------------------------------------------------------------------------------	471	//---------------------------------------------------------------------------------------------
472	void DatenUebertragung(void)	472	void DatenUebertragung(void)
473	{	473	{
474	if(!UebertragungAbgeschlossen) return;	474	if(!UebertragungAbgeschlossen) return;
475		475
476	if(DebugDisplayAnforderung && UebertragungAbgeschlossen)	476	if(DebugDisplayAnforderung && UebertragungAbgeschlossen)
477	{	477	{
478	Menu();	478	Menu();
479	SendOutData('H', FC_ADDRESS, 2, &DisplayLine, sizeof(DisplayLine), &DisplayBuff[DisplayLine * 20], 20);	479	SendOutData('H', FC_ADDRESS, 2, &DisplayLine, sizeof(DisplayLine), &DisplayBuff[DisplayLine * 20], 20);
480	DisplayLine++;	480	DisplayLine++;
481	if(DisplayLine >= 4) DisplayLine = 0;	481	if(DisplayLine >= 4) DisplayLine = 0;
482	DebugDisplayAnforderung = 0;	482	DebugDisplayAnforderung = 0;
483	}	483	}
484	if(DebugDisplayAnforderung1 && UebertragungAbgeschlossen)	484	if(DebugDisplayAnforderung1 && UebertragungAbgeschlossen)
485	{	485	{
486	Menu();	486	Menu();
487	SendOutData('L', FC_ADDRESS, 3, &MenuePunkt, sizeof(MenuePunkt), &MaxMenue, sizeof(MaxMenue), DisplayBuff, sizeof(DisplayBuff));	487	SendOutData('L', FC_ADDRESS, 3, &MenuePunkt, sizeof(MenuePunkt), &MaxMenue, sizeof(MaxMenue), DisplayBuff, sizeof(DisplayBuff));
488	DebugDisplayAnforderung1 = 0;	488	DebugDisplayAnforderung1 = 0;
489	}	489	}
490	if(GetVersionAnforderung && UebertragungAbgeschlossen)	490	if(GetVersionAnforderung && UebertragungAbgeschlossen)
491	{	491	{
492	SendOutData('V', FC_ADDRESS, 1, (unsigned char *) &VersionInfo, sizeof(VersionInfo));	492	SendOutData('V', FC_ADDRESS, 1, (unsigned char *) &VersionInfo, sizeof(VersionInfo));
493	GetVersionAnforderung = 0;	493	GetVersionAnforderung = 0;
494	}	494	}
495		495
496	if(GetExternalControl && UebertragungAbgeschlossen) // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen	496	if(GetExternalControl && UebertragungAbgeschlossen) // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
497	{	497	{
498	SendOutData('G',MeineSlaveAdresse, 1, (unsigned char *) &ExternControl, sizeof(ExternControl));	498	SendOutData('G',MeineSlaveAdresse, 1, (unsigned char *) &ExternControl, sizeof(ExternControl));
499	GetExternalControl = 0;	499	GetExternalControl = 0;
500	}	500	}

Subversion Repositories FlightCtrl

(root)/tags/V0.72p/uart.c @ 2166 - Rev 1178 → 1340