WebSVN - FlightCtrl - Diff - Rev 1419 and 1423


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

Subversion Repositories FlightCtrl

(root)/tags/V0.82a/uart.c @ 2019 - Rev 1419 → 1423