WebSVN - FlightCtrl - Diff - Rev 1501 and 1521 - /branches/V0.91L_ACC-HH


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

Subversion Repositories FlightCtrl

(root)/branches/V0.91L_ACC-HH_MartinR/uart.c @ 2361 - Rev 1501 → 1521