WebSVN - FlightCtrl - Diff - Rev 1051 and 1053 - /branches/V0.74d-FredericG/uart.c


// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Copyright (c) 04.2007 Holger Buss
// + 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"
 
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;
 
int Debug_Timer,Kompass_Timer;
unsigned int DebugDataIntervall = 200;
 
const unsigned char ANALOG_TEXT[32][16] =
{
   //1234567890123456
    "IntegralNick    ", //0
    "IntegralRoll    ",
    "AccNick         ",
    "AccRoll         ",
    "GyroGier        ",
    "HoehenWert      ", //5
    "AccZ            ",
    "Gas             ",
    "KompassValue    ",
    "Spannung        ",
    "Empfang         ", //10
    "Ersatzkompass   ",
    "Motor_Vorne     ",
    "Motor_Hinten    ",
    "Motor_Links     ",
    "Motor_Rechts    ", //15
    "                ",
    "Distance        ",
    "OsdBar          ",
    "MK3Mag CalState ",
    "Servo           ", //20
    "Nick            ",
    "Roll            ",
    "                ",
    "                ",
    "                ", //25
    "                ",
    "Kalman_MaxDrift ",
    "                ",
    "Kalman K        ",
    "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 modul, 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++] = modul;             // 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;
 
  Decode64(); // dekodiere datenblock im Empfangsbuffer
 
  switch(RxdBuffer[2])
  {
   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 'd': // Poll the debug data
                        DebugDataIntervall = pRxData[0] * 10;
            if (DebugDataIntervall) DebugDataAnforderung = 1;
            break;
 
   case 'h':// x-1 Displayzeilen
                RemoteKeys |= pRxData[0];
                if(RemoteKeys) DisplayLine = 0;
                        DebugDisplayAnforderung = 1;
                        break;
 
   case 'l':// x-1 Displayzeilen
            MenuePunkt = pRxData[0];
                        DebugDisplayAnforderung1 = 1;
                        break;
   case 't':// Motortest
            memcpy(&MotorTest[0], (unsigned char *)pRxData, sizeof(MotorTest));
            while(!UebertragungAbgeschlossen);
            SendOutData('T', MeineSlaveAdresse, 0);
            PcZugriff = 255;
                        break;
   case 'v': // Version-Anforderung     und Ausbaustufe
            GetVersionAnforderung = 1;
            break;
   case 'g'://
                        GetExternalControl = 1;
            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();
                        }
                        else // request active parameter set
                        {
                                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);
            SendOutData('Q', MeineSlaveAdresse, 2, &pRxData[0], sizeof(unsigned char), (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
            break;
   case 's': // Parametersatz speichern
                        if((1 <= pRxData[0]) && (pRxData[0] <= 5)) // check for setting to be in range
                        {
                                memcpy((unsigned char *) &EE_Parameter.Kanalbelegung[0], (unsigned char *)&pRxData[1], STRUCT_PARAM_LAENGE);
                                WriteParameterSet(pRxData[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
                                eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], RxdBuffer[2] - 'l' + 1);  // aktiven Datensatz merken
                                Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;
                                Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;
                                Piep(GetActiveParamSetNumber());
                                while(!UebertragungAbgeschlossen);
                SendOutData('S', MeineSlaveAdresse, 1, &pRxData[0], sizeof(unsigned char));
                        }
                        break;
 
  }
// DebugOut.AnzahlZyklen =  Debug_Timer_Intervall;
        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);
        MeineSlaveAdresse = 1; // Flight-Ctrl
 
        VersionInfo.Major = VERSION_MAJOR;
        VersionInfo.Minor = VERSION_MINOR;
        VersionInfo.Patch = VERSION_PATCH;
        VersionInfo.Compatible  = VERSION_SERIAL_COMPATIBLE;
 
        pRxData = 0;
        RxDataLen = 0;
}
 
//---------------------------------------------------------------------------------------------
void DatenUebertragung(void)
{
 if(!UebertragungAbgeschlossen) return;
 
   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 / 108);  // etwa in 0,1 Grad
                  WinkelOut.Winkel[1] = (int) (IntegralRoll / 108);  // etwa in 0,1 Grad
                  WinkelOut.UserParameter[0] = Parameter_UserParam1;
                  WinkelOut.UserParameter[1] = Parameter_UserParam2;
          SendOutData('k',MeineSlaveAdresse, 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 && CheckDelay(Debug_Timer)) || DebugDataAnforderung) && UebertragungAbgeschlossen)
         {
          SendOutData('D',MeineSlaveAdresse, 1, (unsigned char *) &DebugOut,sizeof(DebugOut));
          DebugDataAnforderung = 0;
          if(DebugDataIntervall) Debug_Timer = SetDelay(DebugDataIntervall);
         }
    if(DebugTextAnforderung != 255) // Texte für die Analogdaten
     {
      SendOutData('A', MeineSlaveAdresse, 2, (unsigned char *)&DebugTextAnforderung, sizeof(DebugTextAnforderung),(unsigned char *) ANALOG_TEXT[DebugTextAnforderung], 16);
      DebugTextAnforderung = 255;
         }
     if(ConfirmFrame && UebertragungAbgeschlossen)   // Datensatz bestätigen
         {
                SendOutData('B', MeineSlaveAdresse, 1, (uint8_t*)&ConfirmFrame, sizeof(ConfirmFrame));
        ConfirmFrame = 0;
     }
 
     if(DebugDisplayAnforderung && UebertragungAbgeschlossen)
         {
             Menu();
             SendOutData('H',MeineSlaveAdresse, 2, &DisplayLine, sizeof(DisplayLine), &DisplayBuff[DisplayLine * 20], 20);
             DisplayLine++;
             if(DisplayLine >= 4) DisplayLine = 0;
                 DebugDisplayAnforderung = 0;
         }
     if(DebugDisplayAnforderung1 && UebertragungAbgeschlossen)
         {
        Menu();
        SendOutData('L',MeineSlaveAdresse, 3, &MenuePunkt, sizeof(MenuePunkt), &MaxMenue, sizeof(MaxMenue), DisplayBuff, sizeof(DisplayBuff));
                DebugDisplayAnforderung1 = 0;
         }
    if(GetVersionAnforderung && UebertragungAbgeschlossen)
     {
      SendOutData('V',MeineSlaveAdresse, 1, (unsigned char *) &VersionInfo, sizeof(VersionInfo));
          GetVersionAnforderung = 0;
     }
     if(GetPPMChannelAnforderung && UebertragungAbgeschlossen)
     {
                 SendOutData('P',MeineSlaveAdresse, 1, (unsigned char *) &PPM_in, sizeof(PPM_in));
                 GetPPMChannelAnforderung = 0;
         }
 
}
 
 

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

Subversion Repositories FlightCtrl

(root)/branches/V0.74d-FredericG/uart.c @ 1738 - Rev 1051 → 1053