WebSVN - MK3Mag - Diff - Rev 7 and 12 - /branches/MK3Mag V0.14 Code Redesign Killagreg/uart.c


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

Subversion Repositories MK3Mag

(root)/branches/MK3Mag V0.14 Code Redesign Killagreg/uart.c @ 26 - Rev 7 → 12