WebSVN - FlightCtrl - Diff - Rev 1209 and 1211


// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + 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"
 
 
#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 'n':// "Get Mixer
                                        while(!UebertragungAbgeschlossen);
                    SendOutData('N', FC_ADDRESS, 1, (unsigned char *) &Mixer,sizeof(Mixer));
                                        break;
 
                        case 'm':// "Write Mixer
 
 
 
                                        while(!UebertragungAbgeschlossen);
                    if(pRxData[0] == MIXER_REVISION)
                                         {
                       memcpy(&Mixer, (unsigned char *)pRxData, sizeof(Mixer));
                       eeprom_write_block(&Mixer, &EEPromArray[EEPROM_ADR_MIXER_TABLE], sizeof(Mixer));
                                           tempchar1 = 1;
                                         }
                     else  tempchar1 = 0;
                                        SendOutData('M', FC_ADDRESS, 1, &tempchar1, sizeof(tempchar1));
                                        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 1209	Rev 1211
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		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 'n':// "Get Mixer	309	case 'n':// "Get Mixer
310	while(!UebertragungAbgeschlossen);	310	while(!UebertragungAbgeschlossen);
311	SendOutData('N', FC_ADDRESS, 1, (unsigned char *) &Mixer,sizeof(Mixer));	311	SendOutData('N', FC_ADDRESS, 1, (unsigned char *) &Mixer,sizeof(Mixer));
312	break;	312	break;
313		313
314	case 'm':// "Write Mixer	314	case 'm':// "Write Mixer
315	memcpy(&Mixer, (unsigned char *)pRxData, sizeof(Mixer));	-
316	eeprom_write_block(&Mixer, &EEPromArray[EEPROM_ADR_MIXER_TABLE], sizeof(Mixer));	-
317	eeprom_write_byte(&EEPromArray[EEPROM_ADR_MIXER_REVISION],EE_MIXER_REVISION); // Länge der Datensätze merken	-
318	while(!UebertragungAbgeschlossen);	315	while(!UebertragungAbgeschlossen);
319	SendOutData('M', FC_ADDRESS, 1, 1, 1);	316	if(pRxData[0] == MIXER_REVISION)
-		317	{
-		318	memcpy(&Mixer, (unsigned char *)pRxData, sizeof(Mixer));
-		319	eeprom_write_block(&Mixer, &EEPromArray[EEPROM_ADR_MIXER_TABLE], sizeof(Mixer));
-		320	tempchar1 = 1;
-		321	}
-		322	else tempchar1 = 0;
-		323	SendOutData('M', FC_ADDRESS, 1, &tempchar1, sizeof(tempchar1));
320	break;	324	break;
321		325
322	case 'p': // get PPM Channels	326	case 'p': // get PPM Channels
323	GetPPMChannelAnforderung = 1;	327	GetPPMChannelAnforderung = 1;
324	break;	328	break;
325		329
326	case 'q':// "Get"-Anforderung für Settings	330	case 'q':// "Get"-Anforderung für Settings
327	// Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen	331	// Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
328	if(pRxData[0] == 0xFF)	332	if(pRxData[0] == 0xFF)
329	{	333	{
330	pRxData[0] = GetActiveParamSetNumber();	334	pRxData[0] = GetActiveParamSetNumber();
331	}	335	}
332	// limit settings range	336	// limit settings range
333	if(pRxData[0] < 1) pRxData[0] = 1; // limit to 5	337	if(pRxData[0] < 1) pRxData[0] = 1; // limit to 5
334	else if(pRxData[0] > 5) pRxData[0] = 5; // limit to 5	338	else if(pRxData[0] > 5) pRxData[0] = 5; // limit to 5
335	// load requested parameter set	339	// load requested parameter set
336	ReadParameterSet(pRxData[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);	340	ReadParameterSet(pRxData[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
337		341
338	while(!UebertragungAbgeschlossen);	342	while(!UebertragungAbgeschlossen);
339	tempchar1 = pRxData[0];	343	tempchar1 = pRxData[0];
340	tempchar2 = EE_DATENREVISION;	344	tempchar2 = EE_DATENREVISION;
341	SendOutData('Q', FC_ADDRESS, 3, &tempchar1, sizeof(tempchar1), &tempchar2, sizeof(tempchar2), (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);	345	SendOutData('Q', FC_ADDRESS, 3, &tempchar1, sizeof(tempchar1), &tempchar2, sizeof(tempchar2), (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
342	break;	346	break;
343		347
344	case 's': // Parametersatz speichern	348	case 's': // Parametersatz speichern
345	if((1 <= pRxData[0]) && (pRxData[0] <= 5) && (pRxData[1] == EE_DATENREVISION)) // check for setting to be in range	349	if((1 <= pRxData[0]) && (pRxData[0] <= 5) && (pRxData[1] == EE_DATENREVISION)) // check for setting to be in range
346	{	350	{
347	memcpy((unsigned char ) &EE_Parameter.Kanalbelegung[0], (unsigned char )&pRxData[2], STRUCT_PARAM_LAENGE);	351	memcpy((unsigned char ) &EE_Parameter.Kanalbelegung[0], (unsigned char )&pRxData[2], STRUCT_PARAM_LAENGE);
348	WriteParameterSet(pRxData[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);	352	WriteParameterSet(pRxData[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
349	Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;	353	Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;
350	Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;	354	Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;
351	SetActiveParamSetNumber(pRxData[0]);	355	SetActiveParamSetNumber(pRxData[0]);
352	tempchar1 = GetActiveParamSetNumber();	356	tempchar1 = GetActiveParamSetNumber();
353	Piep(tempchar1);	357	Piep(tempchar1);
354	}	358	}
355	else	359	else
356	{	360	{
357	tempchar1 = 0; // mark in response an invlid setting	361	tempchar1 = 0; // mark in response an invlid setting
358	}	362	}
359	while(!UebertragungAbgeschlossen);	363	while(!UebertragungAbgeschlossen);
360	SendOutData('S', FC_ADDRESS, 1, &tempchar1, sizeof(tempchar1));	364	SendOutData('S', FC_ADDRESS, 1, &tempchar1, sizeof(tempchar1));
361	break;	365	break;
362		366
363	} // case FC_ADDRESS:	367	} // case FC_ADDRESS:
364		368
365	default: // any Slave Address	369	default: // any Slave Address
366		370
367	switch(RxdBuffer[2])	371	switch(RxdBuffer[2])
368	{	372	{
369	// 't' comand placed here only for compatibility to BL	373	// 't' comand placed here only for compatibility to BL
370	case 't':// Motortest	374	case 't':// Motortest
371	memcpy(&MotorTest[0], (unsigned char *)pRxData, sizeof(MotorTest));	375	memcpy(&MotorTest[0], (unsigned char *)pRxData, sizeof(MotorTest));
372	while(!UebertragungAbgeschlossen);	376	while(!UebertragungAbgeschlossen);
373	SendOutData('T', MeineSlaveAdresse, 0);	377	SendOutData('T', MeineSlaveAdresse, 0);
374	PcZugriff = 255;	378	PcZugriff = 255;
375	break;	379	break;
376	// 'K' comand placed here only for compatibility to old MK3MAG software, that does not send the right Slave Address	380	// 'K' comand placed here only for compatibility to old MK3MAG software, that does not send the right Slave Address
377	case 'K':// Kompasswert	381	case 'K':// Kompasswert
378	memcpy((unsigned char )&KompassValue , (unsigned char )pRxData, sizeof(KompassValue));	382	memcpy((unsigned char )&KompassValue , (unsigned char )pRxData, sizeof(KompassValue));
379	KompassRichtung = ((540 + KompassValue - KompassStartwert) % 360) - 180;	383	KompassRichtung = ((540 + KompassValue - KompassStartwert) % 360) - 180;
380	break;	384	break;
381	case 'a':// Texte der Analogwerte	385	case 'a':// Texte der Analogwerte
382	DebugTextAnforderung = pRxData[0];	386	DebugTextAnforderung = pRxData[0];
383	if (DebugTextAnforderung > 31) DebugTextAnforderung = 31;	387	if (DebugTextAnforderung > 31) DebugTextAnforderung = 31;
384	PcZugriff = 255;	388	PcZugriff = 255;
385	break;	389	break;
386	case 'b':	390	case 'b':
387	memcpy((unsigned char )&ExternControl, (unsigned char )pRxData, sizeof(ExternControl));	391	memcpy((unsigned char )&ExternControl, (unsigned char )pRxData, sizeof(ExternControl));
388	ConfirmFrame = ExternControl.Frame;	392	ConfirmFrame = ExternControl.Frame;
389	PcZugriff = 255;	393	PcZugriff = 255;
390	break;	394	break;
391	case 'c': // Poll the 3D-Data	395	case 'c': // Poll the 3D-Data
392	if(!Intervall3D) { if(pRxData[0]) Timer3D = SetDelay(pRxData[0] * 10);}	396	if(!Intervall3D) { if(pRxData[0]) Timer3D = SetDelay(pRxData[0] * 10);}
393	Intervall3D = pRxData[0] * 10;	397	Intervall3D = pRxData[0] * 10;
394	break;	398	break;
395	case 'd': // Poll the debug data	399	case 'd': // Poll the debug data
396	DebugDataIntervall = pRxData[0] * 10;	400	DebugDataIntervall = pRxData[0] * 10;
397	if(DebugDataIntervall > 0) DebugDataAnforderung = 1;	401	if(DebugDataIntervall > 0) DebugDataAnforderung = 1;
398	break;	402	break;
399		403
400	case 'h':// x-1 Displayzeilen	404	case 'h':// x-1 Displayzeilen
401	PcZugriff = 255;	405	PcZugriff = 255;
402	RemoteKeys \|= pRxData[0];	406	RemoteKeys \|= pRxData[0];
403	if(RemoteKeys) DisplayLine = 0;	407	if(RemoteKeys) DisplayLine = 0;
404	DebugDisplayAnforderung = 1;	408	DebugDisplayAnforderung = 1;
405	break;	409	break;
406		410
407	case 'l':// x-1 Displayzeilen	411	case 'l':// x-1 Displayzeilen
408	PcZugriff = 255;	412	PcZugriff = 255;
409	MenuePunkt = pRxData[0];	413	MenuePunkt = pRxData[0];
410	DebugDisplayAnforderung1 = 1;	414	DebugDisplayAnforderung1 = 1;
411	break;	415	break;
412	case 'v': // Version-Anforderung und Ausbaustufe	416	case 'v': // Version-Anforderung und Ausbaustufe
413	GetVersionAnforderung = 1;	417	GetVersionAnforderung = 1;
414	break;	418	break;
415		419
416	case 'g'://	420	case 'g'://
417	GetExternalControl = 1;	421	GetExternalControl = 1;
418	break;	422	break;
419	}	423	}
420	break; // default:	424	break; // default:
421	}	425	}
422	NeuerDatensatzEmpfangen = 0;	426	NeuerDatensatzEmpfangen = 0;
423	pRxData = 0;	427	pRxData = 0;
424	RxDataLen = 0;	428	RxDataLen = 0;
425	}	429	}
426		430
427	//############################################################################	431	//############################################################################
428	//Routine für die Serielle Ausgabe	432	//Routine für die Serielle Ausgabe
429	int uart_putchar (char c)	433	int uart_putchar (char c)
430	//############################################################################	434	//############################################################################
431	{	435	{
432	if (c == '\n')	436	if (c == '\n')
433	uart_putchar('\r');	437	uart_putchar('\r');
434	//Warten solange bis Zeichen gesendet wurde	438	//Warten solange bis Zeichen gesendet wurde
435	loop_until_bit_is_set(USR, UDRE);	439	loop_until_bit_is_set(USR, UDRE);
436	//Ausgabe des Zeichens	440	//Ausgabe des Zeichens
437	UDR = c;	441	UDR = c;
438		442
439	return (0);	443	return (0);
440	}	444	}
441		445
442	// --------------------------------------------------------------------------	446	// --------------------------------------------------------------------------
443	void WriteProgramData(unsigned int pos, unsigned char wert)	447	void WriteProgramData(unsigned int pos, unsigned char wert)
444	{	448	{
445	//if (ProgramLocation == IN_RAM) Buffer[pos] = wert;	449	//if (ProgramLocation == IN_RAM) Buffer[pos] = wert;
446	// else eeprom_write_byte(&EE_Buffer[pos], wert);	450	// else eeprom_write_byte(&EE_Buffer[pos], wert);
447	// Buffer[pos] = wert;	451	// Buffer[pos] = wert;
448	}	452	}
449		453
450	//############################################################################	454	//############################################################################
451	//INstallation der Seriellen Schnittstelle	455	//INstallation der Seriellen Schnittstelle
452	void UART_Init (void)	456	void UART_Init (void)
453	//############################################################################	457	//############################################################################
454	{	458	{
455	//Enable TXEN im Register UCR TX-Data Enable & RX Enable	459	//Enable TXEN im Register UCR TX-Data Enable & RX Enable
456		460
457	UCR=(1 << TXEN) \| (1 << RXEN);	461	UCR=(1 << TXEN) \| (1 << RXEN);
458	// UART Double Speed (U2X)	462	// UART Double Speed (U2X)
459	USR \|= (1<<U2X);	463	USR \|= (1<<U2X);
460	// RX-Interrupt Freigabe	464	// RX-Interrupt Freigabe
461	UCSRB \|= (1<<RXCIE);	465	UCSRB \|= (1<<RXCIE);
462	// TX-Interrupt Freigabe	466	// TX-Interrupt Freigabe
463	UCSRB \|= (1<<TXCIE);	467	UCSRB \|= (1<<TXCIE);
464		468
465	//Teiler wird gesetzt	469	//Teiler wird gesetzt
466	UBRR=(SYSCLK / (BAUD_RATE * 8L) - 1);	470	UBRR=(SYSCLK / (BAUD_RATE * 8L) - 1);
467	//UBRR = 33;	471	//UBRR = 33;
468	//öffnet einen Kanal für printf (STDOUT)	472	//öffnet einen Kanal für printf (STDOUT)
469	//fdevopen (uart_putchar, 0);	473	//fdevopen (uart_putchar, 0);
470	//sbi(PORTD,4);	474	//sbi(PORTD,4);
471	Debug_Timer = SetDelay(DebugDataIntervall);	475	Debug_Timer = SetDelay(DebugDataIntervall);
472	Kompass_Timer = SetDelay(220);	476	Kompass_Timer = SetDelay(220);
473		477
474	VersionInfo.SWMajor = VERSION_MAJOR;	478	VersionInfo.SWMajor = VERSION_MAJOR;
475	VersionInfo.SWMinor = VERSION_MINOR;	479	VersionInfo.SWMinor = VERSION_MINOR;
476	VersionInfo.SWPatch = VERSION_PATCH;	480	VersionInfo.SWPatch = VERSION_PATCH;
477	VersionInfo.ProtoMajor = VERSION_SERIAL_MAJOR;	481	VersionInfo.ProtoMajor = VERSION_SERIAL_MAJOR;
478	VersionInfo.ProtoMinor = VERSION_SERIAL_MINOR;	482	VersionInfo.ProtoMinor = VERSION_SERIAL_MINOR;
479		483
480	pRxData = 0;	484	pRxData = 0;
481	RxDataLen = 0;	485	RxDataLen = 0;
482	}	486	}
483		487
484	//---------------------------------------------------------------------------------------------	488	//---------------------------------------------------------------------------------------------
485	void DatenUebertragung(void)	489	void DatenUebertragung(void)
486	{	490	{
487	if(!UebertragungAbgeschlossen) return;	491	if(!UebertragungAbgeschlossen) return;
488		492
489	if(DebugDisplayAnforderung && UebertragungAbgeschlossen)	493	if(DebugDisplayAnforderung && UebertragungAbgeschlossen)
490	{	494	{
491	Menu();	495	Menu();
492	SendOutData('H', FC_ADDRESS, 2, &DisplayLine, sizeof(DisplayLine), &DisplayBuff[DisplayLine * 20], 20);	496	SendOutData('H', FC_ADDRESS, 2, &DisplayLine, sizeof(DisplayLine), &DisplayBuff[DisplayLine * 20], 20);
493	DisplayLine++;	497	DisplayLine++;

Subversion Repositories FlightCtrl

(root)/tags/V0.73d/uart.c @ 1982 - Rev 1209 → 1211