WebSVN - MK3Mag - Diff - Rev 13 and 62


/*#######################################################################################
MK3Mag 3D-Magnet sensor
!!! THIS IS NOT FREE SOFTWARE !!!                                                      
#######################################################################################*/
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Copyright (c) 05.2008 Holger Buss
// + Thanks to Ilja Fähnrich (P_Latzhalter)
// + Nur für den privaten Gebrauch / NON-COMMERCIAL USE ONLY
// + www.MikroKopter.com
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Die Portierung oder Nutzung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur 
// + mit unserer Zustimmung zulässig
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation), 
// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist. 
// + AUSNAHME: Ein bei www.mikrokopter.de erworbener vorbestückter MK3Mag darf als Baugruppe auch in kommerziellen Systemen verbaut werden
// + Im Zweifelsfall bitte anfragen bei: info@mikrokopter.de
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht, 
// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
// + eindeutig als Ursprung verlinkt werden
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion
// + Benutzung auf eigene Gefahr
// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Die Portierung oder Nutzung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur 
// + mit unserer Zustimmung zulässig
/// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Redistributions of source code (with or without modifications) must retain the above copyright notice, 
// + this list of conditions and the following disclaimer.
// +   * porting the sources to other systems or using the software on other systems (except hardware from www.mikrokopter.de) is not allowed
// +   * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
// +     from this software without specific prior written permission.
// +   * The use of this project (hardware, software, binary files, sources and documentation) is only permittet 
// +     for non-commercial use (directly or indirectly)
// +     Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted 
// +     with our written permission
// +     Exception: A preassembled MK3Mag, purchased from www.mikrokopter.de may be used as a part of commercial systems
// +     In case of doubt please contact: info@MikroKopter.de
// +   * If sources or documentations are redistributet on other webpages, our webpage (http://www.MikroKopter.de) must be 
// +     clearly linked as origin 
// +  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// +  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// +  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// +  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// +  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// +  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// +  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// +  POSSIBILITY OF SUCH DAMAGE. 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
#include "main.h"
#include "uart.h"
 
#define MAX_SENDE_BUFF     100
#define MAX_EMPFANGS_BUFF  100
 
unsigned volatile char SIO_Sollwert = 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 UebertragungAbgeschlossen = 1;
unsigned char GetVersionAnforderung = 0,DebugTextAnforderung = 0,DebugGetAnforderung = 0, KompassAntwort = 0;
unsigned char MeineSlaveAdresse;
unsigned char MotorTest[4] = {0,0,0,0};
unsigned volatile char AnzahlEmpfangsBytes = 0;
unsigned char PcZugriff;
 
struct str_DebugOut       DebugOut;
struct str_ExternData     ExternData;
struct str_ExternControl  ExternControl;
struct str_VersionInfo    VersionInfo;
 
 
 
int Debug_Timer;
 
const unsigned char ANALOG_TEXT[32][16] =
{
   //1234567890123456
    "Magnet N        ", //0
    "Magnet R        ",
    "Magnet Z        ",
    "Raw    N        ",
    "Raw    R        ",
    "Raw    Z        ", //5
    "Lage N          ",
    "Lage R          ",
    "Xmin            ",
    "Xmax            ",
    "Ymin            ", //10
    "Ymax            ",
    "Zmin            ",
    "ZMax            ",
    "Calstate        ",
    "Kompass         ", //15
    "User0           ",
    "User1           ",
    "Analog18        ",
    "Analog19        ",
    "Analog20        ", //20
    "Analog21        ",
    "Analog22        ",
    "Analog23        ",
    "Analog24        ",
    "Analog25        ", //25
    "Analog26        ",
    "Analog27        ",
    "Analog28        ",
    "Analog29        ",
    "Analog30        ", //30
    "Analog31        "
};
 
 
 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++ 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;
}
 
void SendUart(void)
{
 static unsigned int ptr = 0;
 unsigned char tmp_tx;
 if(!(USR & 0x40)) return;
 if(!UebertragungAbgeschlossen)  
  {
   ptr++;                    // die [0] wurde schon gesendet
   tmp_tx = SendeBuffer[ptr];  
   if((tmp_tx == '\r') || (ptr == MAX_SENDE_BUFF))
    {
     ptr = 0;
     UebertragungAbgeschlossen = 1;
    }
   USR |= (1<TXC0);
   UDR = tmp_tx;
  }
  else ptr = 0;
}
 
// --------------------------------------------------------------------------
void Decode64(unsigned char *ptrOut, unsigned char len, unsigned char ptrIn,unsigned char max)  // Wohin mit den Daten; Wie lang; Wo im RxdBuffer
{
 unsigned char a,b,c,d;
 unsigned char ptr = 0;
 unsigned char x,y,z;
 while(len)
  {
   a = RxdBuffer[ptrIn++] - '=';
   b = RxdBuffer[ptrIn++] - '=';
   c = RxdBuffer[ptrIn++] - '=';
   d = RxdBuffer[ptrIn++] - '=';
   if(ptrIn > max - 2) break;     // nicht mehr Daten verarbeiten, als empfangen wurden
 
   x = (a << 2) | (b >> 4);
   y = ((b & 0x0f) << 4) | (c >> 2);
   z = ((c & 0x03) << 6) | d;
 
   if(len--) ptrOut[ptr++] = x; else break;
   if(len--) ptrOut[ptr++] = y; else break;
   if(len--) ptrOut[ptr++] = z; else break;
  }
 
}
 
 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++ Empfangs-Part der Datenübertragung
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
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; };
   if(CrcOkay) // Datensatz schon verarbeitet
    {
     NeuerDatensatzEmpfangen = 1;
         AnzahlEmpfangsBytes = buf_ptr;
     RxdBuffer[buf_ptr] = '\r';
         if((RxdBuffer[2] == 'R')) wdt_enable(WDTO_250MS); // Reset-Commando
//     uart_putchar(RxdBuffer[2]);       
        }                                
  }
  else
  switch(UartState)
  {
   case 0:
          if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1;  // Startzeichen und Daten schon verarbeitet
                  buf_ptr = 0;
                  RxdBuffer[buf_ptr++] = SioTmp;
                  crc = SioTmp;
          break;
   case 1: // Adresse auswerten
                  UartState++;
                  RxdBuffer[buf_ptr++] = SioTmp;
                  crc += SioTmp;
                  break;
   case 2: //  Eingangsdaten sammeln
                  RxdBuffer[buf_ptr] = SioTmp;
                  if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;
                  else UartState = 0;
                  crc += SioTmp;
                  break;
   default:
          UartState = 0;
          break;
  }
 
};
 
 
// --------------------------------------------------------------------------
void AddCRC(unsigned int wieviele)
{
 unsigned int tmpCRC = 0,i;
 for(i = 0; i < wieviele;i++)
  {
   tmpCRC += SendeBuffer[i];
  }
   tmpCRC %= 4096;
   SendeBuffer[i++] = '=' + tmpCRC / 64;
   SendeBuffer[i++] = '=' + tmpCRC % 64;
   SendeBuffer[i++] = '\r';
  UebertragungAbgeschlossen = 0;
  UDR = SendeBuffer[0];
}
 
 
// --------------------------------------------------------------------------
void SendOutData(unsigned char cmd,unsigned char modul, unsigned char *snd, unsigned char len)
{
 unsigned int pt = 0;
 unsigned char a,b,c;
 unsigned char ptr = 0;
 
 SendeBuffer[pt++] = '#';               // Startzeichen
 SendeBuffer[pt++] = modul;             // Adresse (a=0; b=1,...)
 SendeBuffer[pt++] = cmd;                       // Commando
 
 while(len)
  {
   if(len) { a = snd[ptr++]; len--;} else a = 0;
   if(len) { b = snd[ptr++]; len--;} else b = 0;
   if(len) { c = snd[ptr++]; len--;} 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);
  }
 AddCRC(pt);
}
 
 
 
//############################################################################
//Routine für die Serielle Ausgabe
int uart_putchar (char c)
//############################################################################
{
    if(!(UCR & (1 << TXEN))) return (0);
        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)
{
}
 
//############################################################################
//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);    // serieller Empfangsinterrupt       
 
        // TX-Interrupt Freigabe
        UCSRB |= (1<<TXCIE);          
 
        //Teiler wird gesetzt 
        UBRR= (SYSCLK / (BAUD_RATE * 8L) -1 );
        //öffnet einen Kanal für printf (STDOUT)
//      fdevopen (uart_putchar, NULL);
    Debug_Timer = SetDelay(200);  
    // Version beim Start ausgeben (nicht schön, aber geht... ) 
        uart_putchar ('\n');uart_putchar ('C');uart_putchar ('P');uart_putchar (':');
        uart_putchar ('V');uart_putchar (0x30 + VERSION_HAUPTVERSION);uart_putchar ('.');uart_putchar (0x30 + VERSION_NEBENVERSION/10); uart_putchar (0x30 + VERSION_NEBENVERSION%10);
    uart_putchar ('\n');
}
 
 
void BearbeiteRxDaten(void)
{
 if(!NeuerDatensatzEmpfangen) return;
// unsigned int tmp_int_arr1[1];
// unsigned int tmp_int_arr2[2];
// unsigned int tmp_int_arr3[3];
 unsigned char tmp_char_arr2[2];
// unsigned char tmp_char_arr3[3];
// unsigned char tmp_char_arr4[4];
 //if(!MotorenEin) 
 PcZugriff = 255;
 
  switch(RxdBuffer[2])
  {
   case 'w':// Lagewinkel
            Decode64((unsigned char *) &ExternData,sizeof(ExternData),3,AnzahlEmpfangsBytes);
            DebugOut.Analog[15]++;
            KompassAntwort = 1;
            break;
   case 'c':
   case 'b':
                        Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);
            ExternData.Winkel[0] = ExternControl.Par1;
            ExternData.Winkel[1] = ExternControl.Par2;
            break;
   case 'v': // Version-Anforderung     und Ausbaustufe
            GetVersionAnforderung = 1;
            PC_Connected = 255;
            break;                                                               
 
   case 'a':// Texte der Analogwerte
            Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
            DebugTextAnforderung = tmp_char_arr2[0];
            PC_Connected = 255;
                        break;
   case 'g':// "Get"-Anforderung für Debug-Daten 
            // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
            PC_Connected = 255;
            DebugGetAnforderung = 1;
            break;
   case 'h':// x-1 Displayzeilen
            PC_Connected = 255;
            break;
/*
   case 'b':
                        Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);
                        RemoteTasten |= ExternControl.RemoteTasten;
            ConfirmFrame = ExternControl.Frame;
            break;
   case 'c':
                        Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);
                        RemoteTasten |= ExternControl.RemoteTasten;
            ConfirmFrame = ExternControl.Frame;
            DebugDataAnforderung = 1;
            break;
   case 'h':// x-1 Displayzeilen
            Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
            RemoteTasten |= tmp_char_arr2[0];
                        if(tmp_char_arr2[1] == 255) NurKanalAnforderung = 1; else NurKanalAnforderung = 0; // keine Displaydaten
                        DebugDisplayAnforderung = 1;
                        break;
   case 't':// Motortest
            Decode64((unsigned char *) &MotorTest[0],sizeof(MotorTest),3,AnzahlEmpfangsBytes);
                        break;
   case 'k':// Keys von DubWise
            Decode64((unsigned char *) &DubWiseKeys[0],sizeof(DubWiseKeys),3,AnzahlEmpfangsBytes);
                        ConfirmFrame = DubWiseKeys[3];
                        break;
   case 'q':// "Get"-Anforderung für Settings
            // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
            Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
            if(tmp_char_arr2[0] != 0xff)
             {
                          if(tmp_char_arr2[0] > 5) tmp_char_arr2[0] = 5;
                  ReadParameterSet(tmp_char_arr2[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);                   
                  SendOutData('L' + tmp_char_arr2[0] -1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
             }
             else
                  SendOutData('L' + GetActiveParamSetNumber()-1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
             
            break;
       
   case 'l':
   case 'm':
   case 'n':
   case 'o':
   case 'p': // Parametersatz speichern
            Decode64((unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE,3,AnzahlEmpfangsBytes);
                        WriteParameterSet(RxdBuffer[2] - 'l' + 1, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
            eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], RxdBuffer[2] - 'l' + 1);  // aktiven Datensatz merken
            Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;
            Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;
            Piep(GetActiveParamSetNumber());
         break;
*/             
         
  }
// DebugOut.AnzahlZyklen =  Debug_Timer_Intervall;
 NeuerDatensatzEmpfangen = 0;
}
 
 
//---------------------------------------------------------------------------------------------
void DatenUebertragung(void)  
{
 if((CheckDelay(Debug_Timer) && UebertragungAbgeschlossen))      // im Singlestep-Betrieb in jedem Schtitt senden
         {
         SetDebugValues();
          SendOutData('D',MeineSlaveAdresse,(unsigned char *) &DebugOut,sizeof(DebugOut));
          Debug_Timer = SetDelay(250);   // Sendeintervall
         }
    if(GetVersionAnforderung && UebertragungAbgeschlossen)
     {
      SendOutData('V',MeineSlaveAdresse,(unsigned char *) &VersionInfo,sizeof(VersionInfo));
          GetVersionAnforderung = 0;
     }
    if(DebugTextAnforderung != 255) // Texte für die Analogdaten
     {
      SendOutData('A',DebugTextAnforderung + '0',(unsigned char *) ANALOG_TEXT[DebugTextAnforderung],16);
      DebugTextAnforderung = 255;
         }
   if(DebugGetAnforderung && UebertragungAbgeschlossen)               // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
   {
      SendOutData('G',MeineSlaveAdresse,(unsigned char *) &ExternControl,sizeof(ExternControl));
          DebugGetAnforderung = 0;
   }
   if(KompassAntwort && UebertragungAbgeschlossen)            // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
   {
      SendOutData('K',MeineSlaveAdresse,(unsigned char *) &I2C_Heading,sizeof(I2C_Heading));
          KompassAntwort = 0;
   }
}
 
 

Rev 13	Rev 62
1	/*#######################################################################################	1	/*#######################################################################################
2	MK3Mag 3D-Magnet sensor	2	MK3Mag 3D-Magnet sensor
3	!!! THIS IS NOT FREE SOFTWARE !!!	3	!!! THIS IS NOT FREE SOFTWARE !!!
4	#######################################################################################*/	4	#######################################################################################*/
5	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	5	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
6	// + Copyright (c) 05.2008 Holger Buss	6	// + Copyright (c) 05.2008 Holger Buss
7	// + Thanks to Ilja Fähnrich (P_Latzhalter)	7	// + Thanks to Ilja Fähnrich (P_Latzhalter)
8	// + Nur für den privaten Gebrauch	8	// + Nur für den privaten Gebrauch / NON-COMMERCIAL USE ONLY
9	// + www.MikroKopter.com	9	// + www.MikroKopter.com
10	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	10	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11	// + Die Portierung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur	11	// + Die Portierung oder Nutzung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
12	// + mit unserer Zustimmung zulässig	12	// + mit unserer Zustimmung zulässig
13	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	13	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
14	// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),	14	// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),
15	// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.	15	// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.
16	// + AUSNAHME: Ein bei www.mikrokopter.de erworbener vorbestückter MK3Mag darf als Baugruppe auch in kommerziellen Systemen verbaut werden	16	// + AUSNAHME: Ein bei www.mikrokopter.de erworbener vorbestückter MK3Mag darf als Baugruppe auch in kommerziellen Systemen verbaut werden
17	// + Im Zweifelsfall bitte anfragen bei: info@mikrokopter.de	17	// + Im Zweifelsfall bitte anfragen bei: info@mikrokopter.de
18	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	18	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
19	// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,	19	// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,
20	// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen	20	// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen
21	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	21	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
22	// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts	22	// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
23	// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"	23	// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
24	// + eindeutig als Ursprung verlinkt werden	24	// + eindeutig als Ursprung verlinkt werden
25	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	25	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
26	// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion	26	// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion
27	// + Benutzung auf eigene Gefahr	27	// + Benutzung auf eigene Gefahr
28	// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden	28	// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
29	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	29	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-		30	// + Die Portierung oder Nutzung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
-		31	// + mit unserer Zustimmung zulässig
-		32	/// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
30	// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen	33	// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
31	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	34	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
32	// + Redistributions of source code (with or without modifications) must retain the above copyright notice,	35	// + Redistributions of source code (with or without modifications) must retain the above copyright notice,
33	// + this list of conditions and the following disclaimer.	36	// + this list of conditions and the following disclaimer.
34	// + * PORTING this software (or parts of it) to systems (other than hardware from www.mikrokopter.de) is NOT allowed	37	// + * porting the sources to other systems or using the software on other systems (except hardware from www.mikrokopter.de) is not allowed
35	// + * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived	38	// + * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
36	// + from this software without specific prior written permission.	39	// + from this software without specific prior written permission.
37	// + * The use of this project (hardware, software, binary files, sources and documentation) is only permittet	40	// + * The use of this project (hardware, software, binary files, sources and documentation) is only permittet
38	// + for non-commercial use (directly or indirectly)	41	// + for non-commercial use (directly or indirectly)
39	// + Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted	42	// + Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted
40	// + with our written permission	43	// + with our written permission
41	// + Exception: A preassembled MK3Mag, purchased from www.mikrokopter.de may be used as a part of commercial systems	44	// + Exception: A preassembled MK3Mag, purchased from www.mikrokopter.de may be used as a part of commercial systems
42	// + In case of doubt please contact: info@MikroKopter.de	45	// + In case of doubt please contact: info@MikroKopter.de
43	// + * If sources or documentations are redistributet on other webpages, our webpage (http://www.MikroKopter.de) must be	46	// + * If sources or documentations are redistributet on other webpages, our webpage (http://www.MikroKopter.de) must be
44	// + clearly linked as origin	47	// + clearly linked as origin
45	// + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"	48	// + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
46	// + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE	49	// + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
47	// + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE	50	// + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
48	// + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE	51	// + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
49	// + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR	52	// + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
50	// + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF	53	// + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
51	// + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS	54	// + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
52	// + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN	55	// + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
53	// + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)	56	// + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
54	// + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE	57	// + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
55	// + POSSIBILITY OF SUCH DAMAGE.	58	// + POSSIBILITY OF SUCH DAMAGE.
56	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	59	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
57		60
58	#include "main.h"	61	#include "main.h"
59	#include "uart.h"	62	#include "uart.h"
60		63
61	#define MAX_SENDE_BUFF 100	64	#define MAX_SENDE_BUFF 100
62	#define MAX_EMPFANGS_BUFF 100	65	#define MAX_EMPFANGS_BUFF 100
63		66
64	unsigned volatile char SIO_Sollwert = 0;	67	unsigned volatile char SIO_Sollwert = 0;
65	unsigned volatile char SioTmp = 0;	68	unsigned volatile char SioTmp = 0;
66	unsigned volatile char SendeBuffer[MAX_SENDE_BUFF];	69	unsigned volatile char SendeBuffer[MAX_SENDE_BUFF];
67	unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF];	70	unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF];
68	unsigned volatile char NeuerDatensatzEmpfangen = 0;	71	unsigned volatile char NeuerDatensatzEmpfangen = 0;
69	unsigned volatile char UebertragungAbgeschlossen = 1;	72	unsigned volatile char UebertragungAbgeschlossen = 1;
70	unsigned char GetVersionAnforderung = 0,DebugTextAnforderung = 0,DebugGetAnforderung = 0, KompassAntwort = 0;	73	unsigned char GetVersionAnforderung = 0,DebugTextAnforderung = 0,DebugGetAnforderung = 0, KompassAntwort = 0;
71	unsigned char MeineSlaveAdresse;	74	unsigned char MeineSlaveAdresse;
72	unsigned char MotorTest[4] = {0,0,0,0};	75	unsigned char MotorTest[4] = {0,0,0,0};
73	unsigned volatile char AnzahlEmpfangsBytes = 0;	76	unsigned volatile char AnzahlEmpfangsBytes = 0;
74	unsigned char PcZugriff;	77	unsigned char PcZugriff;
75		78
76	struct str_DebugOut DebugOut;	79	struct str_DebugOut DebugOut;
77	struct str_ExternData ExternData;	80	struct str_ExternData ExternData;
78	struct str_ExternControl ExternControl;	81	struct str_ExternControl ExternControl;
79	struct str_VersionInfo VersionInfo;	82	struct str_VersionInfo VersionInfo;
80		83
81		84
82		85
83	int Debug_Timer;	86	int Debug_Timer;
84		87
85	const unsigned char ANALOG_TEXT[32][16] =	88	const unsigned char ANALOG_TEXT[32][16] =
86	{	89	{
87	//1234567890123456	90	//1234567890123456
88	"Magnet N ", //0	91	"Magnet N ", //0
89	"Magnet R ",	92	"Magnet R ",
90	"Magnet Z ",	93	"Magnet Z ",
91	"Raw N ",	94	"Raw N ",
92	"Raw R ",	95	"Raw R ",
93	"Raw Z ", //5	96	"Raw Z ", //5
94	"Lage N ",	97	"Lage N ",
95	"Lage R ",	98	"Lage R ",
96	"Xmin ",	99	"Xmin ",
97	"Xmax ",	100	"Xmax ",
98	"Ymin ", //10	101	"Ymin ", //10
99	"Ymax ",	102	"Ymax ",
100	"Zmin ",	103	"Zmin ",
101	"ZMax ",	104	"ZMax ",
102	"Calstate ",	105	"Calstate ",
103	"Kompass ", //15	106	"Kompass ", //15
104	"User0 ",	107	"User0 ",
105	"User1 ",	108	"User1 ",
106	"Analog18 ",	109	"Analog18 ",
107	"Analog19 ",	110	"Analog19 ",
108	"Analog20 ", //20	111	"Analog20 ", //20
109	"Analog21 ",	112	"Analog21 ",
110	"Analog22 ",	113	"Analog22 ",
111	"Analog23 ",	114	"Analog23 ",
112	"Analog24 ",	115	"Analog24 ",
113	"Analog25 ", //25	116	"Analog25 ", //25
114	"Analog26 ",	117	"Analog26 ",
115	"Analog27 ",	118	"Analog27 ",
116	"Analog28 ",	119	"Analog28 ",
117	"Analog29 ",	120	"Analog29 ",
118	"Analog30 ", //30	121	"Analog30 ", //30
119	"Analog31 "	122	"Analog31 "
120	};	123	};
121		124
122		125
123		126
124	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	127	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
125	//++ Sende-Part der Datenübertragung	128	//++ Sende-Part der Datenübertragung
126	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	129	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
127	SIGNAL(INT_VEC_TX)	130	SIGNAL(INT_VEC_TX)
128	{	131	{
129	static unsigned int ptr = 0;	132	static unsigned int ptr = 0;
130	unsigned char tmp_tx;	133	unsigned char tmp_tx;
131	if(!UebertragungAbgeschlossen)	134	if(!UebertragungAbgeschlossen)
132	{	135	{
133	ptr++; // die [0] wurde schon gesendet	136	ptr++; // die [0] wurde schon gesendet
134	tmp_tx = SendeBuffer[ptr];	137	tmp_tx = SendeBuffer[ptr];
135	if((tmp_tx == '\r') \|\| (ptr == MAX_SENDE_BUFF))	138	if((tmp_tx == '\r') \|\| (ptr == MAX_SENDE_BUFF))
136	{	139	{
137	ptr = 0;	140	ptr = 0;
138	UebertragungAbgeschlossen = 1;	141	UebertragungAbgeschlossen = 1;
139	}	142	}
140	UDR = tmp_tx;	143	UDR = tmp_tx;
141	}	144	}
142	else ptr = 0;	145	else ptr = 0;
143	}	146	}
144		147
145	void SendUart(void)	148	void SendUart(void)
146	{	149	{
147	static unsigned int ptr = 0;	150	static unsigned int ptr = 0;
148	unsigned char tmp_tx;	151	unsigned char tmp_tx;
149	if(!(USR & 0x40)) return;	152	if(!(USR & 0x40)) return;
150	if(!UebertragungAbgeschlossen)	153	if(!UebertragungAbgeschlossen)
151	{	154	{
152	ptr++; // die [0] wurde schon gesendet	155	ptr++; // die [0] wurde schon gesendet
153	tmp_tx = SendeBuffer[ptr];	156	tmp_tx = SendeBuffer[ptr];
154	if((tmp_tx == '\r') \|\| (ptr == MAX_SENDE_BUFF))	157	if((tmp_tx == '\r') \|\| (ptr == MAX_SENDE_BUFF))
155	{	158	{
156	ptr = 0;	159	ptr = 0;
157	UebertragungAbgeschlossen = 1;	160	UebertragungAbgeschlossen = 1;
158	}	161	}
159	USR \|= (1<TXC0);	162	USR \|= (1<TXC0);
160	UDR = tmp_tx;	163	UDR = tmp_tx;
161	}	164	}
162	else ptr = 0;	165	else ptr = 0;
163	}	166	}
164		167
165	// --------------------------------------------------------------------------	168	// --------------------------------------------------------------------------
166	void Decode64(unsigned char *ptrOut, unsigned char len, unsigned char ptrIn,unsigned char max) // Wohin mit den Daten; Wie lang; Wo im RxdBuffer	169	void Decode64(unsigned char *ptrOut, unsigned char len, unsigned char ptrIn,unsigned char max) // Wohin mit den Daten; Wie lang; Wo im RxdBuffer
167	{	170	{
168	unsigned char a,b,c,d;	171	unsigned char a,b,c,d;
169	unsigned char ptr = 0;	172	unsigned char ptr = 0;
170	unsigned char x,y,z;	173	unsigned char x,y,z;
171	while(len)	174	while(len)
172	{	175	{
173	a = RxdBuffer[ptrIn++] - '=';	176	a = RxdBuffer[ptrIn++] - '=';
174	b = RxdBuffer[ptrIn++] - '=';	177	b = RxdBuffer[ptrIn++] - '=';
175	c = RxdBuffer[ptrIn++] - '=';	178	c = RxdBuffer[ptrIn++] - '=';
176	d = RxdBuffer[ptrIn++] - '=';	179	d = RxdBuffer[ptrIn++] - '=';
177	if(ptrIn > max - 2) break; // nicht mehr Daten verarbeiten, als empfangen wurden	180	if(ptrIn > max - 2) break; // nicht mehr Daten verarbeiten, als empfangen wurden
178		181
179	x = (a << 2) \| (b >> 4);	182	x = (a << 2) \| (b >> 4);
180	y = ((b & 0x0f) << 4) \| (c >> 2);	183	y = ((b & 0x0f) << 4) \| (c >> 2);
181	z = ((c & 0x03) << 6) \| d;	184	z = ((c & 0x03) << 6) \| d;
182		185
183	if(len--) ptrOut[ptr++] = x; else break;	186	if(len--) ptrOut[ptr++] = x; else break;
184	if(len--) ptrOut[ptr++] = y; else break;	187	if(len--) ptrOut[ptr++] = y; else break;
185	if(len--) ptrOut[ptr++] = z; else break;	188	if(len--) ptrOut[ptr++] = z; else break;
186	}	189	}
187		190
188	}	191	}
189		192
190		193
191	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	194	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
192	//++ Empfangs-Part der Datenübertragung	195	//++ Empfangs-Part der Datenübertragung
193	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	196	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
194	SIGNAL(INT_VEC_RX)	197	SIGNAL(INT_VEC_RX)
195	{	198	{
196	static unsigned int crc;	199	static unsigned int crc;
197	static unsigned char crc1,crc2,buf_ptr;	200	static unsigned char crc1,crc2,buf_ptr;
198	static unsigned char UartState = 0;	201	static unsigned char UartState = 0;
199	unsigned char CrcOkay = 0;	202	unsigned char CrcOkay = 0;
200		203
201	SioTmp = UDR;	204	SioTmp = UDR;
202	if(buf_ptr >= MAX_EMPFANGS_BUFF) UartState = 0;	205	if(buf_ptr >= MAX_EMPFANGS_BUFF) UartState = 0;
203	if(SioTmp == '\r' && UartState == 2)	206	if(SioTmp == '\r' && UartState == 2)
204	{	207	{
205	UartState = 0;	208	UartState = 0;
206	crc -= RxdBuffer[buf_ptr-2];	209	crc -= RxdBuffer[buf_ptr-2];
207	crc -= RxdBuffer[buf_ptr-1];	210	crc -= RxdBuffer[buf_ptr-1];
208	crc %= 4096;	211	crc %= 4096;
209	crc1 = '=' + crc / 64;	212	crc1 = '=' + crc / 64;
210	crc2 = '=' + crc % 64;	213	crc2 = '=' + crc % 64;
211	CrcOkay = 0;	214	CrcOkay = 0;
212	if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; };	215	if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; };
213	if(CrcOkay) // Datensatz schon verarbeitet	216	if(CrcOkay) // Datensatz schon verarbeitet
214	{	217	{
215	NeuerDatensatzEmpfangen = 1;	218	NeuerDatensatzEmpfangen = 1;
216	AnzahlEmpfangsBytes = buf_ptr;	219	AnzahlEmpfangsBytes = buf_ptr;
217	RxdBuffer[buf_ptr] = '\r';	220	RxdBuffer[buf_ptr] = '\r';
218	if((RxdBuffer[2] == 'R')) wdt_enable(WDTO_250MS); // Reset-Commando	221	if((RxdBuffer[2] == 'R')) wdt_enable(WDTO_250MS); // Reset-Commando
219	// uart_putchar(RxdBuffer[2]);	222	// uart_putchar(RxdBuffer[2]);
220	}	223	}
221	}	224	}
222	else	225	else
223	switch(UartState)	226	switch(UartState)
224	{	227	{
225	case 0:	228	case 0:
226	if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1; // Startzeichen und Daten schon verarbeitet	229	if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1; // Startzeichen und Daten schon verarbeitet
227	buf_ptr = 0;	230	buf_ptr = 0;
228	RxdBuffer[buf_ptr++] = SioTmp;	231	RxdBuffer[buf_ptr++] = SioTmp;
229	crc = SioTmp;	232	crc = SioTmp;
230	break;	233	break;
231	case 1: // Adresse auswerten	234	case 1: // Adresse auswerten
232	UartState++;	235	UartState++;
233	RxdBuffer[buf_ptr++] = SioTmp;	236	RxdBuffer[buf_ptr++] = SioTmp;
234	crc += SioTmp;	237	crc += SioTmp;
235	break;	238	break;
236	case 2: // Eingangsdaten sammeln	239	case 2: // Eingangsdaten sammeln
237	RxdBuffer[buf_ptr] = SioTmp;	240	RxdBuffer[buf_ptr] = SioTmp;
238	if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;	241	if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;
239	else UartState = 0;	242	else UartState = 0;
240	crc += SioTmp;	243	crc += SioTmp;
241	break;	244	break;
242	default:	245	default:
243	UartState = 0;	246	UartState = 0;
244	break;	247	break;
245	}	248	}
246		249
247	};	250	};
248		251
249		252
250	// --------------------------------------------------------------------------	253	// --------------------------------------------------------------------------
251	void AddCRC(unsigned int wieviele)	254	void AddCRC(unsigned int wieviele)
252	{	255	{
253	unsigned int tmpCRC = 0,i;	256	unsigned int tmpCRC = 0,i;
254	for(i = 0; i < wieviele;i++)	257	for(i = 0; i < wieviele;i++)
255	{	258	{
256	tmpCRC += SendeBuffer[i];	259	tmpCRC += SendeBuffer[i];
257	}	260	}
258	tmpCRC %= 4096;	261	tmpCRC %= 4096;
259	SendeBuffer[i++] = '=' + tmpCRC / 64;	262	SendeBuffer[i++] = '=' + tmpCRC / 64;
260	SendeBuffer[i++] = '=' + tmpCRC % 64;	263	SendeBuffer[i++] = '=' + tmpCRC % 64;
261	SendeBuffer[i++] = '\r';	264	SendeBuffer[i++] = '\r';
262	UebertragungAbgeschlossen = 0;	265	UebertragungAbgeschlossen = 0;
263	UDR = SendeBuffer[0];	266	UDR = SendeBuffer[0];
264	}	267	}
265		268
266		269
267	// --------------------------------------------------------------------------	270	// --------------------------------------------------------------------------
268	void SendOutData(unsigned char cmd,unsigned char modul, unsigned char *snd, unsigned char len)	271	void SendOutData(unsigned char cmd,unsigned char modul, unsigned char *snd, unsigned char len)
269	{	272	{
270	unsigned int pt = 0;	273	unsigned int pt = 0;
271	unsigned char a,b,c;	274	unsigned char a,b,c;
272	unsigned char ptr = 0;	275	unsigned char ptr = 0;
273		276
274	SendeBuffer[pt++] = '#'; // Startzeichen	277	SendeBuffer[pt++] = '#'; // Startzeichen
275	SendeBuffer[pt++] = modul; // Adresse (a=0; b=1,...)	278	SendeBuffer[pt++] = modul; // Adresse (a=0; b=1,...)
276	SendeBuffer[pt++] = cmd; // Commando	279	SendeBuffer[pt++] = cmd; // Commando
277		280
278	while(len)	281	while(len)
279	{	282	{
280	if(len) { a = snd[ptr++]; len--;} else a = 0;	283	if(len) { a = snd[ptr++]; len--;} else a = 0;
281	if(len) { b = snd[ptr++]; len--;} else b = 0;	284	if(len) { b = snd[ptr++]; len--;} else b = 0;
282	if(len) { c = snd[ptr++]; len--;} else c = 0;	285	if(len) { c = snd[ptr++]; len--;} else c = 0;
283	SendeBuffer[pt++] = '=' + (a >> 2);	286	SendeBuffer[pt++] = '=' + (a >> 2);
284	SendeBuffer[pt++] = '=' + (((a & 0x03) << 4) \| ((b & 0xf0) >> 4));	287	SendeBuffer[pt++] = '=' + (((a & 0x03) << 4) \| ((b & 0xf0) >> 4));
285	SendeBuffer[pt++] = '=' + (((b & 0x0f) << 2) \| ((c & 0xc0) >> 6));	288	SendeBuffer[pt++] = '=' + (((b & 0x0f) << 2) \| ((c & 0xc0) >> 6));
286	SendeBuffer[pt++] = '=' + ( c & 0x3f);	289	SendeBuffer[pt++] = '=' + ( c & 0x3f);
287	}	290	}
288	AddCRC(pt);	291	AddCRC(pt);
289	}	292	}
290		293
291		294
292		295
293	//############################################################################	296	//############################################################################
294	//Routine für die Serielle Ausgabe	297	//Routine für die Serielle Ausgabe
295	int uart_putchar (char c)	298	int uart_putchar (char c)
296	//############################################################################	299	//############################################################################
297	{	300	{
298	if(!(UCR & (1 << TXEN))) return (0);	301	if(!(UCR & (1 << TXEN))) return (0);
299	if (c == '\n')	302	if (c == '\n')
300	uart_putchar('\r');	303	uart_putchar('\r');
301	//Warten solange bis Zeichen gesendet wurde	304	//Warten solange bis Zeichen gesendet wurde
302	loop_until_bit_is_set(USR, UDRE);	305	loop_until_bit_is_set(USR, UDRE);
303	//Ausgabe des Zeichens	306	//Ausgabe des Zeichens
304	UDR = c;	307	UDR = c;
305		308
306	return (0);	309	return (0);
307	}	310	}
308		311
309	// --------------------------------------------------------------------------	312	// --------------------------------------------------------------------------
310	void WriteProgramData(unsigned int pos, unsigned char wert)	313	void WriteProgramData(unsigned int pos, unsigned char wert)
311	{	314	{
312	}	315	}
313		316
314	//############################################################################	317	//############################################################################
315	//INstallation der Seriellen Schnittstelle	318	//INstallation der Seriellen Schnittstelle
316	void UART_Init (void)	319	void UART_Init (void)
317	//############################################################################	320	//############################################################################
318	{	321	{
319	//Enable TXEN im Register UCR TX-Data Enable & RX Enable	322	//Enable TXEN im Register UCR TX-Data Enable & RX Enable
320		323
321	UCR=(1 << TXEN) \| (1 << RXEN);	324	UCR=(1 << TXEN) \| (1 << RXEN);
322	// UART Double Speed (U2X)	325	// UART Double Speed (U2X)
323	USR \|= (1<<U2X);	326	USR \|= (1<<U2X);
324	// RX-Interrupt Freigabe	327	// RX-Interrupt Freigabe
325		328
326	UCSRB \|= (1<<RXCIE); // serieller Empfangsinterrupt	329	UCSRB \|= (1<<RXCIE); // serieller Empfangsinterrupt
327		330
328	// TX-Interrupt Freigabe	331	// TX-Interrupt Freigabe
329	UCSRB \|= (1<<TXCIE);	332	UCSRB \|= (1<<TXCIE);
330		333
331	//Teiler wird gesetzt	334	//Teiler wird gesetzt
332	UBRR= (SYSCLK / (BAUD_RATE * 8L) -1 );	335	UBRR= (SYSCLK / (BAUD_RATE * 8L) -1 );
333	//öffnet einen Kanal für printf (STDOUT)	336	//öffnet einen Kanal für printf (STDOUT)
334	// fdevopen (uart_putchar, NULL);	337	// fdevopen (uart_putchar, NULL);
335	Debug_Timer = SetDelay(200);	338	Debug_Timer = SetDelay(200);
336	// Version beim Start ausgeben (nicht schön, aber geht... )	339	// Version beim Start ausgeben (nicht schön, aber geht... )
337	uart_putchar ('\n');uart_putchar ('C');uart_putchar ('P');uart_putchar (':');	340	uart_putchar ('\n');uart_putchar ('C');uart_putchar ('P');uart_putchar (':');
338	uart_putchar ('V');uart_putchar (0x30 + VERSION_HAUPTVERSION);uart_putchar ('.');uart_putchar (0x30 + VERSION_NEBENVERSION/10); uart_putchar (0x30 + VERSION_NEBENVERSION%10);	341	uart_putchar ('V');uart_putchar (0x30 + VERSION_HAUPTVERSION);uart_putchar ('.');uart_putchar (0x30 + VERSION_NEBENVERSION/10); uart_putchar (0x30 + VERSION_NEBENVERSION%10);
339	uart_putchar ('\n');	342	uart_putchar ('\n');
340	}	343	}
341		344
342		345
343	void BearbeiteRxDaten(void)	346	void BearbeiteRxDaten(void)
344	{	347	{
345	if(!NeuerDatensatzEmpfangen) return;	348	if(!NeuerDatensatzEmpfangen) return;
346	// unsigned int tmp_int_arr1[1];	349	// unsigned int tmp_int_arr1[1];
347	// unsigned int tmp_int_arr2[2];	350	// unsigned int tmp_int_arr2[2];
348	// unsigned int tmp_int_arr3[3];	351	// unsigned int tmp_int_arr3[3];
349	unsigned char tmp_char_arr2[2];	352	unsigned char tmp_char_arr2[2];
350	// unsigned char tmp_char_arr3[3];	353	// unsigned char tmp_char_arr3[3];
351	// unsigned char tmp_char_arr4[4];	354	// unsigned char tmp_char_arr4[4];
352	//if(!MotorenEin)	355	//if(!MotorenEin)
353	PcZugriff = 255;	356	PcZugriff = 255;
354		357
355	switch(RxdBuffer[2])	358	switch(RxdBuffer[2])
356	{	359	{
357	case 'w':// Lagewinkel	360	case 'w':// Lagewinkel
358	Decode64((unsigned char *) &ExternData,sizeof(ExternData),3,AnzahlEmpfangsBytes);	361	Decode64((unsigned char *) &ExternData,sizeof(ExternData),3,AnzahlEmpfangsBytes);
359	DebugOut.Analog[15]++;	362	DebugOut.Analog[15]++;
360	KompassAntwort = 1;	363	KompassAntwort = 1;
361	break;	364	break;
362	case 'c':	365	case 'c':
363	case 'b':	366	case 'b':
364	Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);	367	Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);
365	ExternData.Winkel[0] = ExternControl.Par1;	368	ExternData.Winkel[0] = ExternControl.Par1;
366	ExternData.Winkel[1] = ExternControl.Par2;	369	ExternData.Winkel[1] = ExternControl.Par2;
367	break;	370	break;
368	case 'v': // Version-Anforderung und Ausbaustufe	371	case 'v': // Version-Anforderung und Ausbaustufe
369	GetVersionAnforderung = 1;	372	GetVersionAnforderung = 1;
370	PC_Connected = 255;	373	PC_Connected = 255;
371	break;	374	break;
372		375
373	case 'a':// Texte der Analogwerte	376	case 'a':// Texte der Analogwerte
374	Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);	377	Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
375	DebugTextAnforderung = tmp_char_arr2[0];	378	DebugTextAnforderung = tmp_char_arr2[0];
376	PC_Connected = 255;	379	PC_Connected = 255;
377	break;	380	break;
378	case 'g':// "Get"-Anforderung für Debug-Daten	381	case 'g':// "Get"-Anforderung für Debug-Daten
379	// Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen	382	// Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
380	PC_Connected = 255;	383	PC_Connected = 255;
381	DebugGetAnforderung = 1;	384	DebugGetAnforderung = 1;
382	break;	385	break;
383	case 'h':// x-1 Displayzeilen	386	case 'h':// x-1 Displayzeilen
384	PC_Connected = 255;	387	PC_Connected = 255;
385	break;	388	break;
386	/*	389	/*
387	case 'b':	390	case 'b':
388	Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);	391	Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);
389	RemoteTasten \|= ExternControl.RemoteTasten;	392	RemoteTasten \|= ExternControl.RemoteTasten;
390	ConfirmFrame = ExternControl.Frame;	393	ConfirmFrame = ExternControl.Frame;
391	break;	394	break;
392	case 'c':	395	case 'c':
393	Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);	396	Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);
394	RemoteTasten \|= ExternControl.RemoteTasten;	397	RemoteTasten \|= ExternControl.RemoteTasten;
395	ConfirmFrame = ExternControl.Frame;	398	ConfirmFrame = ExternControl.Frame;
396	DebugDataAnforderung = 1;	399	DebugDataAnforderung = 1;
397	break;	400	break;
398	case 'h':// x-1 Displayzeilen	401	case 'h':// x-1 Displayzeilen
399	Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);	402	Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
400	RemoteTasten \|= tmp_char_arr2[0];	403	RemoteTasten \|= tmp_char_arr2[0];
401	if(tmp_char_arr2[1] == 255) NurKanalAnforderung = 1; else NurKanalAnforderung = 0; // keine Displaydaten	404	if(tmp_char_arr2[1] == 255) NurKanalAnforderung = 1; else NurKanalAnforderung = 0; // keine Displaydaten
402	DebugDisplayAnforderung = 1;	405	DebugDisplayAnforderung = 1;
403	break;	406	break;
404	case 't':// Motortest	407	case 't':// Motortest
405	Decode64((unsigned char *) &MotorTest[0],sizeof(MotorTest),3,AnzahlEmpfangsBytes);	408	Decode64((unsigned char *) &MotorTest[0],sizeof(MotorTest),3,AnzahlEmpfangsBytes);
406	break;	409	break;
407	case 'k':// Keys von DubWise	410	case 'k':// Keys von DubWise
408	Decode64((unsigned char *) &DubWiseKeys[0],sizeof(DubWiseKeys),3,AnzahlEmpfangsBytes);	411	Decode64((unsigned char *) &DubWiseKeys[0],sizeof(DubWiseKeys),3,AnzahlEmpfangsBytes);
409	ConfirmFrame = DubWiseKeys[3];	412	ConfirmFrame = DubWiseKeys[3];
410	break;	413	break;
411	case 'q':// "Get"-Anforderung für Settings	414	case 'q':// "Get"-Anforderung für Settings
412	// Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen	415	// Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
413	Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);	416	Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
414	if(tmp_char_arr2[0] != 0xff)	417	if(tmp_char_arr2[0] != 0xff)
415	{	418	{
416	if(tmp_char_arr2[0] > 5) tmp_char_arr2[0] = 5;	419	if(tmp_char_arr2[0] > 5) tmp_char_arr2[0] = 5;
417	ReadParameterSet(tmp_char_arr2[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);	420	ReadParameterSet(tmp_char_arr2[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
418	SendOutData('L' + tmp_char_arr2[0] -1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);	421	SendOutData('L' + tmp_char_arr2[0] -1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
419	}	422	}
420	else	423	else
421	SendOutData('L' + GetActiveParamSetNumber()-1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);	424	SendOutData('L' + GetActiveParamSetNumber()-1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
422		425
423	break;	426	break;
424		427
425	case 'l':	428	case 'l':
426	case 'm':	429	case 'm':
427	case 'n':	430	case 'n':
428	case 'o':	431	case 'o':
429	case 'p': // Parametersatz speichern	432	case 'p': // Parametersatz speichern
430	Decode64((unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE,3,AnzahlEmpfangsBytes);	433	Decode64((unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE,3,AnzahlEmpfangsBytes);
431	WriteParameterSet(RxdBuffer[2] - 'l' + 1, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);	434	WriteParameterSet(RxdBuffer[2] - 'l' + 1, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
432	eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], RxdBuffer[2] - 'l' + 1); // aktiven Datensatz merken	435	eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], RxdBuffer[2] - 'l' + 1); // aktiven Datensatz merken
433	Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;	436	Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;
434	Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;	437	Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;
435	Piep(GetActiveParamSetNumber());	438	Piep(GetActiveParamSetNumber());
436	break;	439	break;
437	*/	440	*/
438		441
439	}	442	}
440	// DebugOut.AnzahlZyklen = Debug_Timer_Intervall;	443	// DebugOut.AnzahlZyklen = Debug_Timer_Intervall;
441	NeuerDatensatzEmpfangen = 0;	444	NeuerDatensatzEmpfangen = 0;
442	}	445	}
443		446
444		447
445	//---------------------------------------------------------------------------------------------	448	//---------------------------------------------------------------------------------------------
446	void DatenUebertragung(void)	449	void DatenUebertragung(void)
447	{	450	{
448	if((CheckDelay(Debug_Timer) && UebertragungAbgeschlossen)) // im Singlestep-Betrieb in jedem Schtitt senden	451	if((CheckDelay(Debug_Timer) && UebertragungAbgeschlossen)) // im Singlestep-Betrieb in jedem Schtitt senden
449	{	452	{
450	SetDebugValues();	453	SetDebugValues();
451	SendOutData('D',MeineSlaveAdresse,(unsigned char *) &DebugOut,sizeof(DebugOut));	454	SendOutData('D',MeineSlaveAdresse,(unsigned char *) &DebugOut,sizeof(DebugOut));
452	Debug_Timer = SetDelay(250); // Sendeintervall	455	Debug_Timer = SetDelay(250); // Sendeintervall
453	}	456	}
454	if(GetVersionAnforderung && UebertragungAbgeschlossen)	457	if(GetVersionAnforderung && UebertragungAbgeschlossen)
455	{	458	{
456	SendOutData('V',MeineSlaveAdresse,(unsigned char *) &VersionInfo,sizeof(VersionInfo));	459	SendOutData('V',MeineSlaveAdresse,(unsigned char *) &VersionInfo,sizeof(VersionInfo));
457	GetVersionAnforderung = 0;	460	GetVersionAnforderung = 0;
458	}	461	}
459	if(DebugTextAnforderung != 255) // Texte für die Analogdaten	462	if(DebugTextAnforderung != 255) // Texte für die Analogdaten
460	{	463	{
461	SendOutData('A',DebugTextAnforderung + '0',(unsigned char *) ANALOG_TEXT[DebugTextAnforderung],16);	464	SendOutData('A',DebugTextAnforderung + '0',(unsigned char *) ANALOG_TEXT[DebugTextAnforderung],16);
462	DebugTextAnforderung = 255;	465	DebugTextAnforderung = 255;
463	}	466	}
464	if(DebugGetAnforderung && UebertragungAbgeschlossen) // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen	467	if(DebugGetAnforderung && UebertragungAbgeschlossen) // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
465	{	468	{
466	SendOutData('G',MeineSlaveAdresse,(unsigned char *) &ExternControl,sizeof(ExternControl));	469	SendOutData('G',MeineSlaveAdresse,(unsigned char *) &ExternControl,sizeof(ExternControl));
467	DebugGetAnforderung = 0;	470	DebugGetAnforderung = 0;
468	}	471	}
469	if(KompassAntwort && UebertragungAbgeschlossen) // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen	472	if(KompassAntwort && UebertragungAbgeschlossen) // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
470	{	473	{
471	SendOutData('K',MeineSlaveAdresse,(unsigned char *) &I2C_Heading,sizeof(I2C_Heading));	474	SendOutData('K',MeineSlaveAdresse,(unsigned char *) &I2C_Heading,sizeof(I2C_Heading));
472	KompassAntwort = 0;	475	KompassAntwort = 0;
473	}	476	}
474	}	477	}
475		478
476		479

Subversion Repositories MK3Mag

(root)/tags/V0.14/uart.c - Rev 13 → 62