WebSVN - MK3Mag - Diff - Rev 5 and 7


// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + MK3Mag 3D-Compass
// + ATMEGA168 mit 8MHz
// + (c) 05.2008 Holger Buss
// + Nur für den privaten Gebrauch
// + Keine Garantie auf Fehlerfreiheit
// + Kommerzielle Nutzung nur mit meiner Zustimmung
// + Der Code ist für die Hardware MK3Mag entwickelt worden
// + www.mikrokopter.com
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
#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 5	Rev 7
1	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	1	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2	// + Regler für Brushless-Motoren	2	// + MK3Mag 3D-Compass
3	// + ATMEGA8 mit 8MHz	3	// + ATMEGA168 mit 8MHz
4	// + (c) 01.2007 Holger Buss	4	// + (c) 05.2008 Holger Buss
5	// + Nur für den privaten Gebrauch	5	// + Nur für den privaten Gebrauch
6	// + Keine Garantie auf Fehlerfreiheit	6	// + Keine Garantie auf Fehlerfreiheit
7	// + Kommerzielle Nutzung nur mit meiner Zustimmung	7	// + Kommerzielle Nutzung nur mit meiner Zustimmung
8	// + Der Code ist für die Hardware BL_Ctrl V1.0 entwickelt worden	8	// + Der Code ist für die Hardware MK3Mag entwickelt worden
9	// + www.mikrocontroller.com	9	// + www.mikrokopter.com
10	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	10	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11		11
12	#include "main.h"	12	#include "main.h"
13	#include "uart.h"	13	#include "uart.h"
14		14
15	#define MAX_SENDE_BUFF 100	15	#define MAX_SENDE_BUFF 100
16	#define MAX_EMPFANGS_BUFF 100	16	#define MAX_EMPFANGS_BUFF 100
17		17
18	unsigned volatile char SIO_Sollwert = 0;	18	unsigned volatile char SIO_Sollwert = 0;
19	unsigned volatile char SioTmp = 0;	19	unsigned volatile char SioTmp = 0;
20	unsigned volatile char SendeBuffer[MAX_SENDE_BUFF];	20	unsigned volatile char SendeBuffer[MAX_SENDE_BUFF];
21	unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF];	21	unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF];
22	unsigned volatile char NeuerDatensatzEmpfangen = 0;	22	unsigned volatile char NeuerDatensatzEmpfangen = 0;
23	unsigned volatile char UebertragungAbgeschlossen = 1;	23	unsigned volatile char UebertragungAbgeschlossen = 1;
24	unsigned char GetVersionAnforderung = 0,DebugTextAnforderung = 0,DebugGetAnforderung = 0, KompassAntwort = 0;	24	unsigned char GetVersionAnforderung = 0,DebugTextAnforderung = 0,DebugGetAnforderung = 0, KompassAntwort = 0;
25	unsigned char MeineSlaveAdresse;	25	unsigned char MeineSlaveAdresse;
26	unsigned char MotorTest[4] = {0,0,0,0};	26	unsigned char MotorTest[4] = {0,0,0,0};
27	unsigned volatile char AnzahlEmpfangsBytes = 0;	27	unsigned volatile char AnzahlEmpfangsBytes = 0;
28	unsigned char PcZugriff;	28	unsigned char PcZugriff;
29		29
30	struct str_DebugOut DebugOut;	30	struct str_DebugOut DebugOut;
31	struct str_WinkelOut WinkelOut;	31	struct str_ExternData ExternData;
32	struct str_ExternControl ExternControl;	32	struct str_ExternControl ExternControl;
33	struct str_VersionInfo VersionInfo;	33	struct str_VersionInfo VersionInfo;
34		34
35		35
36		36
37	int Debug_Timer;	37	int Debug_Timer;
38		38
39	const unsigned char ANALOG_TEXT[32][16] =	39	const unsigned char ANALOG_TEXT[32][16] =
40	{	40	{
41	//1234567890123456	41	//1234567890123456
42	"Magnet N ", //0	42	"Magnet N ", //0
43	"Magnet R ",	43	"Magnet R ",
44	"Magnet Z ",	44	"Magnet Z ",
45	"Roh N ",	45	"Raw N ",
46	"Roh R ",	46	"Raw R ",
47	"Roh Z ", //5	47	"Raw Z ", //5
48	"Lage N ",	48	"Lage N ",
49	"Lage R ",	49	"Lage R ",
-		50	"Xmin ",
-		51	"Xmax ",
-		52	"Ymin ", //10
-		53	"Ymax ",
-		54	"Zmin ",
-		55	"ZMax ",
-		56	"Calstate ",
-		57	"Kompass ", //15
50	"User0 ",	58	"User0 ",
51	"User1 ",	59	"User1 ",
52	"User2 ", //10	-
53	"User3 ",	60	"Analog18 ",
54	" ",	61	"Analog19 ",
55	" ",	62	"Analog20 ", //20
56	"Kompass ",	63	"Analog21 ",
57	" ", //15	-
58	"Acc_Z ",	64	"Analog22 ",
59	"MittelAccNick ",	-
60	"MittelAccRoll ",	-
61	"IntegralErrNick ",	-
62	"IntegralErrRoll ", //20	-
63	"MittelIntNick ",	-
64	"MittelIntRoll ",	-
65	"NeutralNick ",	65	"Analog23 ",
66	"RollOffset ",	66	"Analog24 ",
67	"IntRoll*Faktor ", //25	67	"Analog25 ", //25
68	"Analog26 ",	68	"Analog26 ",
69	"DirektAusglRoll ",	69	"Analog27 ",
70	"MesswertRoll ",	70	"Analog28 ",
71	"AusgleichRoll ",	71	"Analog29 ",
72	"I-LageRoll ", //30	72	"Analog30 ", //30
73	"StickRoll "	73	"Analog31 "
74	};	74	};
75		75
-		76
76		77
77	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	78	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
78	//++ Sende-Part der Datenübertragung	79	//++ Sende-Part der Datenübertragung
79	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	80	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
80	SIGNAL(INT_VEC_TX)	81	SIGNAL(INT_VEC_TX)
81	{	82	{
82	static unsigned int ptr = 0;	83	static unsigned int ptr = 0;
83	unsigned char tmp_tx;	84	unsigned char tmp_tx;
84	if(!UebertragungAbgeschlossen)	85	if(!UebertragungAbgeschlossen)
85	{	86	{
86	ptr++; // die [0] wurde schon gesendet	87	ptr++; // die [0] wurde schon gesendet
87	tmp_tx = SendeBuffer[ptr];	88	tmp_tx = SendeBuffer[ptr];
88	if((tmp_tx == '\r') \|\| (ptr == MAX_SENDE_BUFF))	89	if((tmp_tx == '\r') \|\| (ptr == MAX_SENDE_BUFF))
89	{	90	{
90	ptr = 0;	91	ptr = 0;
91	UebertragungAbgeschlossen = 1;	92	UebertragungAbgeschlossen = 1;
92	}	93	}
93	UDR = tmp_tx;	94	UDR = tmp_tx;
94	}	95	}
95	else ptr = 0;	96	else ptr = 0;
96	}	97	}
97		98
98	void SendUart(void)	99	void SendUart(void)
99	{	100	{
100	static unsigned int ptr = 0;	101	static unsigned int ptr = 0;
101	unsigned char tmp_tx;	102	unsigned char tmp_tx;
102	if(!(USR & 0x40)) return;	103	if(!(USR & 0x40)) return;
103	if(!UebertragungAbgeschlossen)	104	if(!UebertragungAbgeschlossen)
104	{	105	{
105	ptr++; // die [0] wurde schon gesendet	106	ptr++; // die [0] wurde schon gesendet
106	tmp_tx = SendeBuffer[ptr];	107	tmp_tx = SendeBuffer[ptr];
107	if((tmp_tx == '\r') \|\| (ptr == MAX_SENDE_BUFF))	108	if((tmp_tx == '\r') \|\| (ptr == MAX_SENDE_BUFF))
108	{	109	{
109	ptr = 0;	110	ptr = 0;
110	UebertragungAbgeschlossen = 1;	111	UebertragungAbgeschlossen = 1;
111	}	112	}
112	USR \|= (1<TXC0);	113	USR \|= (1<TXC0);
113	UDR = tmp_tx;	114	UDR = tmp_tx;
114	}	115	}
115	else ptr = 0;	116	else ptr = 0;
116	}	117	}
117		118
118	// --------------------------------------------------------------------------	119	// --------------------------------------------------------------------------
119	void Decode64(unsigned char *ptrOut, unsigned char len, unsigned char ptrIn,unsigned char max) // Wohin mit den Daten; Wie lang; Wo im RxdBuffer	120	void Decode64(unsigned char *ptrOut, unsigned char len, unsigned char ptrIn,unsigned char max) // Wohin mit den Daten; Wie lang; Wo im RxdBuffer
120	{	121	{
121	unsigned char a,b,c,d;	122	unsigned char a,b,c,d;
122	unsigned char ptr = 0;	123	unsigned char ptr = 0;
123	unsigned char x,y,z;	124	unsigned char x,y,z;
124	while(len)	125	while(len)
125	{	126	{
126	a = RxdBuffer[ptrIn++] - '=';	127	a = RxdBuffer[ptrIn++] - '=';
127	b = RxdBuffer[ptrIn++] - '=';	128	b = RxdBuffer[ptrIn++] - '=';
128	c = RxdBuffer[ptrIn++] - '=';	129	c = RxdBuffer[ptrIn++] - '=';
129	d = RxdBuffer[ptrIn++] - '=';	130	d = RxdBuffer[ptrIn++] - '=';
130	if(ptrIn > max - 2) break; // nicht mehr Daten verarbeiten, als empfangen wurden	131	if(ptrIn > max - 2) break; // nicht mehr Daten verarbeiten, als empfangen wurden
131		132
132	x = (a << 2) \| (b >> 4);	133	x = (a << 2) \| (b >> 4);
133	y = ((b & 0x0f) << 4) \| (c >> 2);	134	y = ((b & 0x0f) << 4) \| (c >> 2);
134	z = ((c & 0x03) << 6) \| d;	135	z = ((c & 0x03) << 6) \| d;
135		136
136	if(len--) ptrOut[ptr++] = x; else break;	137	if(len--) ptrOut[ptr++] = x; else break;
137	if(len--) ptrOut[ptr++] = y; else break;	138	if(len--) ptrOut[ptr++] = y; else break;
138	if(len--) ptrOut[ptr++] = z; else break;	139	if(len--) ptrOut[ptr++] = z; else break;
139	}	140	}
140		141
141	}	142	}
142		143
143		144
144	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	145	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
145	//++ Empfangs-Part der Datenübertragung	146	//++ Empfangs-Part der Datenübertragung
146	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	147	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
147	SIGNAL(INT_VEC_RX)	148	SIGNAL(INT_VEC_RX)
148	{	149	{
149	static unsigned int crc;	150	static unsigned int crc;
150	static unsigned char crc1,crc2,buf_ptr;	151	static unsigned char crc1,crc2,buf_ptr;
151	static unsigned char UartState = 0;	152	static unsigned char UartState = 0;
152	unsigned char CrcOkay = 0;	153	unsigned char CrcOkay = 0;
153		154
154	SioTmp = UDR;	155	SioTmp = UDR;
155	if(buf_ptr >= MAX_EMPFANGS_BUFF) UartState = 0;	156	if(buf_ptr >= MAX_EMPFANGS_BUFF) UartState = 0;
156	if(SioTmp == '\r' && UartState == 2)	157	if(SioTmp == '\r' && UartState == 2)
157	{	158	{
158	UartState = 0;	159	UartState = 0;
159	crc -= RxdBuffer[buf_ptr-2];	160	crc -= RxdBuffer[buf_ptr-2];
160	crc -= RxdBuffer[buf_ptr-1];	161	crc -= RxdBuffer[buf_ptr-1];
161	crc %= 4096;	162	crc %= 4096;
162	crc1 = '=' + crc / 64;	163	crc1 = '=' + crc / 64;
163	crc2 = '=' + crc % 64;	164	crc2 = '=' + crc % 64;
164	CrcOkay = 0;	165	CrcOkay = 0;
165	if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; };	166	if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; };
166	if(CrcOkay) // Datensatz schon verarbeitet	167	if(CrcOkay) // Datensatz schon verarbeitet
167	{	168	{
168	NeuerDatensatzEmpfangen = 1;	169	NeuerDatensatzEmpfangen = 1;
169	AnzahlEmpfangsBytes = buf_ptr;	170	AnzahlEmpfangsBytes = buf_ptr;
170	RxdBuffer[buf_ptr] = '\r';	171	RxdBuffer[buf_ptr] = '\r';
171	if((RxdBuffer[2] == 'R')) wdt_enable(WDTO_250MS); // Reset-Commando	172	if((RxdBuffer[2] == 'R')) wdt_enable(WDTO_250MS); // Reset-Commando
172	// uart_putchar(RxdBuffer[2]);	173	// uart_putchar(RxdBuffer[2]);
173	}	174	}
174	}	175	}
175	else	176	else
176	switch(UartState)	177	switch(UartState)
177	{	178	{
178	case 0:	179	case 0:
179	if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1; // Startzeichen und Daten schon verarbeitet	180	if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1; // Startzeichen und Daten schon verarbeitet
180	buf_ptr = 0;	181	buf_ptr = 0;
181	RxdBuffer[buf_ptr++] = SioTmp;	182	RxdBuffer[buf_ptr++] = SioTmp;
182	crc = SioTmp;	183	crc = SioTmp;
183	break;	184	break;
184	case 1: // Adresse auswerten	185	case 1: // Adresse auswerten
185	UartState++;	186	UartState++;
186	RxdBuffer[buf_ptr++] = SioTmp;	187	RxdBuffer[buf_ptr++] = SioTmp;
187	crc += SioTmp;	188	crc += SioTmp;
188	break;	189	break;
189	case 2: // Eingangsdaten sammeln	190	case 2: // Eingangsdaten sammeln
190	RxdBuffer[buf_ptr] = SioTmp;	191	RxdBuffer[buf_ptr] = SioTmp;
191	if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;	192	if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;
192	else UartState = 0;	193	else UartState = 0;
193	crc += SioTmp;	194	crc += SioTmp;
194	break;	195	break;
195	default:	196	default:
196	UartState = 0;	197	UartState = 0;
197	break;	198	break;
198	}	199	}
199		200
200	};	201	};
201		202
202		203
203	// --------------------------------------------------------------------------	204	// --------------------------------------------------------------------------
204	void AddCRC(unsigned int wieviele)	205	void AddCRC(unsigned int wieviele)
205	{	206	{
206	unsigned int tmpCRC = 0,i;	207	unsigned int tmpCRC = 0,i;
207	for(i = 0; i < wieviele;i++)	208	for(i = 0; i < wieviele;i++)
208	{	209	{
209	tmpCRC += SendeBuffer[i];	210	tmpCRC += SendeBuffer[i];
210	}	211	}
211	tmpCRC %= 4096;	212	tmpCRC %= 4096;
212	SendeBuffer[i++] = '=' + tmpCRC / 64;	213	SendeBuffer[i++] = '=' + tmpCRC / 64;
213	SendeBuffer[i++] = '=' + tmpCRC % 64;	214	SendeBuffer[i++] = '=' + tmpCRC % 64;
214	SendeBuffer[i++] = '\r';	215	SendeBuffer[i++] = '\r';
215	UebertragungAbgeschlossen = 0;	216	UebertragungAbgeschlossen = 0;
216	UDR = SendeBuffer[0];	217	UDR = SendeBuffer[0];
217	}	218	}
218		219
219		220
220	// --------------------------------------------------------------------------	221	// --------------------------------------------------------------------------
221	void SendOutData(unsigned char cmd,unsigned char modul, unsigned char *snd, unsigned char len)	222	void SendOutData(unsigned char cmd,unsigned char modul, unsigned char *snd, unsigned char len)
222	{	223	{
223	unsigned int pt = 0;	224	unsigned int pt = 0;
224	unsigned char a,b,c;	225	unsigned char a,b,c;
225	unsigned char ptr = 0;	226	unsigned char ptr = 0;
226		227
227	SendeBuffer[pt++] = '#'; // Startzeichen	228	SendeBuffer[pt++] = '#'; // Startzeichen
228	SendeBuffer[pt++] = modul; // Adresse (a=0; b=1,...)	229	SendeBuffer[pt++] = modul; // Adresse (a=0; b=1,...)
229	SendeBuffer[pt++] = cmd; // Commando	230	SendeBuffer[pt++] = cmd; // Commando
230		231
231	while(len)	232	while(len)
232	{	233	{
233	if(len) { a = snd[ptr++]; len--;} else a = 0;	234	if(len) { a = snd[ptr++]; len--;} else a = 0;
234	if(len) { b = snd[ptr++]; len--;} else b = 0;	235	if(len) { b = snd[ptr++]; len--;} else b = 0;
235	if(len) { c = snd[ptr++]; len--;} else c = 0;	236	if(len) { c = snd[ptr++]; len--;} else c = 0;
236	SendeBuffer[pt++] = '=' + (a >> 2);	237	SendeBuffer[pt++] = '=' + (a >> 2);
237	SendeBuffer[pt++] = '=' + (((a & 0x03) << 4) \| ((b & 0xf0) >> 4));	238	SendeBuffer[pt++] = '=' + (((a & 0x03) << 4) \| ((b & 0xf0) >> 4));
238	SendeBuffer[pt++] = '=' + (((b & 0x0f) << 2) \| ((c & 0xc0) >> 6));	239	SendeBuffer[pt++] = '=' + (((b & 0x0f) << 2) \| ((c & 0xc0) >> 6));
239	SendeBuffer[pt++] = '=' + ( c & 0x3f);	240	SendeBuffer[pt++] = '=' + ( c & 0x3f);
240	}	241	}
241	AddCRC(pt);	242	AddCRC(pt);
242	}	243	}
243		244
244		245
245		246
246	//############################################################################	247	//############################################################################
247	//Routine für die Serielle Ausgabe	248	//Routine für die Serielle Ausgabe
248	int uart_putchar (char c)	249	int uart_putchar (char c)
249	//############################################################################	250	//############################################################################
250	{	251	{
-		252	if(!(UCR & (1 << TXEN))) return (0);
251	if (c == '\n')	253	if (c == '\n')
252	uart_putchar('\r');	254	uart_putchar('\r');
253	//Warten solange bis Zeichen gesendet wurde	255	//Warten solange bis Zeichen gesendet wurde
254	loop_until_bit_is_set(USR, UDRE);	256	loop_until_bit_is_set(USR, UDRE);
255	//Ausgabe des Zeichens	257	//Ausgabe des Zeichens
256	UDR = c;	258	UDR = c;
257		259
258	return (0);	260	return (0);
259	}	261	}
260		262
261	// --------------------------------------------------------------------------	263	// --------------------------------------------------------------------------
262	void WriteProgramData(unsigned int pos, unsigned char wert)	264	void WriteProgramData(unsigned int pos, unsigned char wert)
263	{	265	{
264	}	266	}
265		267
266	//############################################################################	268	//############################################################################
267	//INstallation der Seriellen Schnittstelle	269	//INstallation der Seriellen Schnittstelle
268	void UART_Init (void)	270	void UART_Init (void)
269	//############################################################################	271	//############################################################################
270	{	272	{
271	//Enable TXEN im Register UCR TX-Data Enable & RX Enable	273	//Enable TXEN im Register UCR TX-Data Enable & RX Enable
272		274
273	UCR=(1 << TXEN) \| (1 << RXEN);	275	UCR=(1 << TXEN) \| (1 << RXEN);
274	// UART Double Speed (U2X)	276	// UART Double Speed (U2X)
275	USR \|= (1<<U2X);	277	USR \|= (1<<U2X);
276	// RX-Interrupt Freigabe	278	// RX-Interrupt Freigabe
277		279
278	UCSRB \|= (1<<RXCIE); // serieller Empfangsinterrupt	280	UCSRB \|= (1<<RXCIE); // serieller Empfangsinterrupt
279		281
280	// TX-Interrupt Freigabe	282	// TX-Interrupt Freigabe
281	UCSRB \|= (1<<TXCIE);	283	UCSRB \|= (1<<TXCIE);
282		284
283	//Teiler wird gesetzt	285	//Teiler wird gesetzt
284	UBRR= (SYSCLK / (BAUD_RATE * 8L) -1 );	286	UBRR= (SYSCLK / (BAUD_RATE * 8L) -1 );
285	//öffnet einen Kanal für printf (STDOUT)	287	//öffnet einen Kanal für printf (STDOUT)
286	// fdevopen (uart_putchar, NULL);	288	// fdevopen (uart_putchar, NULL);
287	Debug_Timer = SetDelay(200);	289	Debug_Timer = SetDelay(200);
288	// Version beim Start ausgeben (nicht schön, aber geht... )	290	// Version beim Start ausgeben (nicht schön, aber geht... )
289	uart_putchar ('\n');uart_putchar ('C');uart_putchar ('P');uart_putchar (':');	291	uart_putchar ('\n');uart_putchar ('C');uart_putchar ('P');uart_putchar (':');
290	uart_putchar ('V');uart_putchar (0x30 + VERSION_HAUPTVERSION);uart_putchar ('.');uart_putchar (0x30 + VERSION_NEBENVERSION/10); uart_putchar (0x30 + VERSION_NEBENVERSION%10);	292	uart_putchar ('V');uart_putchar (0x30 + VERSION_HAUPTVERSION);uart_putchar ('.');uart_putchar (0x30 + VERSION_NEBENVERSION/10); uart_putchar (0x30 + VERSION_NEBENVERSION%10);
291	uart_putchar ('\n');	293	uart_putchar ('\n');
292	}	294	}
293		295
294		296
295	void BearbeiteRxDaten(void)	297	void BearbeiteRxDaten(void)
296	{	298	{
297	if(!NeuerDatensatzEmpfangen) return;	299	if(!NeuerDatensatzEmpfangen) return;
298	// unsigned int tmp_int_arr1[1];	300	// unsigned int tmp_int_arr1[1];
299	// unsigned int tmp_int_arr2[2];	301	// unsigned int tmp_int_arr2[2];
300	// unsigned int tmp_int_arr3[3];	302	// unsigned int tmp_int_arr3[3];
301	unsigned char tmp_char_arr2[2];	303	unsigned char tmp_char_arr2[2];
302	// unsigned char tmp_char_arr3[3];	304	// unsigned char tmp_char_arr3[3];
303	// unsigned char tmp_char_arr4[4];	305	// unsigned char tmp_char_arr4[4];
304	//if(!MotorenEin)	306	//if(!MotorenEin)
305	PcZugriff = 255;	307	PcZugriff = 255;
306		308
307	switch(RxdBuffer[2])	309	switch(RxdBuffer[2])
308	{	310	{
309	case 'w':// Lagewinkel	311	case 'w':// Lagewinkel
310	Decode64((unsigned char *) &WinkelOut,sizeof(WinkelOut),3,AnzahlEmpfangsBytes);	312	Decode64((unsigned char *) &ExternData,sizeof(ExternData),3,AnzahlEmpfangsBytes);
311	DebugOut.Analog[15]++;	313	DebugOut.Analog[15]++;
312	KompassAntwort = 1;	314	KompassAntwort = 1;
313	LED_ON;	-
314	break;	315	break;
315	case 'c':	316	case 'c':
316	case 'b':	317	case 'b':
317	Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);	318	Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);
318	WinkelOut.Winkel[0] = ExternControl.Par1;	319	ExternData.Winkel[0] = ExternControl.Par1;
319	WinkelOut.Winkel[1] = ExternControl.Par2;	320	ExternData.Winkel[1] = ExternControl.Par2;
320	break;	321	break;
321	case 'v': // Version-Anforderung und Ausbaustufe	322	case 'v': // Version-Anforderung und Ausbaustufe
322	GetVersionAnforderung = 1;	323	GetVersionAnforderung = 1;
323	PC_Connected = 255;	324	PC_Connected = 255;
324	break;	325	break;
325		326
326	case 'a':// Texte der Analogwerte	327	case 'a':// Texte der Analogwerte
327	Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);	328	Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
328	DebugTextAnforderung = tmp_char_arr2[0];	329	DebugTextAnforderung = tmp_char_arr2[0];
329	PC_Connected = 255;	330	PC_Connected = 255;
330	break;	331	break;
331	case 'g':// "Get"-Anforderung für Debug-Daten	332	case 'g':// "Get"-Anforderung für Debug-Daten
332	// Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen	333	// Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
333	PC_Connected = 255;	334	PC_Connected = 255;
334	DebugGetAnforderung = 1;	335	DebugGetAnforderung = 1;
335	break;	336	break;
336	case 'h':// x-1 Displayzeilen	337	case 'h':// x-1 Displayzeilen
337	PC_Connected = 255;	338	PC_Connected = 255;
338	break;	339	break;
339	/*	340	/*
340	case 'b':	341	case 'b':
341	Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);	342	Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);
342	RemoteTasten \|= ExternControl.RemoteTasten;	343	RemoteTasten \|= ExternControl.RemoteTasten;
343	ConfirmFrame = ExternControl.Frame;	344	ConfirmFrame = ExternControl.Frame;
344	break;	345	break;
345	case 'c':	346	case 'c':
346	Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);	347	Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);
347	RemoteTasten \|= ExternControl.RemoteTasten;	348	RemoteTasten \|= ExternControl.RemoteTasten;
348	ConfirmFrame = ExternControl.Frame;	349	ConfirmFrame = ExternControl.Frame;
349	DebugDataAnforderung = 1;	350	DebugDataAnforderung = 1;
350	break;	351	break;
351	case 'h':// x-1 Displayzeilen	352	case 'h':// x-1 Displayzeilen
352	Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);	353	Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
353	RemoteTasten \|= tmp_char_arr2[0];	354	RemoteTasten \|= tmp_char_arr2[0];
354	if(tmp_char_arr2[1] == 255) NurKanalAnforderung = 1; else NurKanalAnforderung = 0; // keine Displaydaten	355	if(tmp_char_arr2[1] == 255) NurKanalAnforderung = 1; else NurKanalAnforderung = 0; // keine Displaydaten
355	DebugDisplayAnforderung = 1;	356	DebugDisplayAnforderung = 1;
356	break;	357	break;
357	case 't':// Motortest	358	case 't':// Motortest
358	Decode64((unsigned char *) &MotorTest[0],sizeof(MotorTest),3,AnzahlEmpfangsBytes);	359	Decode64((unsigned char *) &MotorTest[0],sizeof(MotorTest),3,AnzahlEmpfangsBytes);
359	break;	360	break;
360	case 'k':// Keys von DubWise	361	case 'k':// Keys von DubWise
361	Decode64((unsigned char *) &DubWiseKeys[0],sizeof(DubWiseKeys),3,AnzahlEmpfangsBytes);	362	Decode64((unsigned char *) &DubWiseKeys[0],sizeof(DubWiseKeys),3,AnzahlEmpfangsBytes);
362	ConfirmFrame = DubWiseKeys[3];	363	ConfirmFrame = DubWiseKeys[3];
363	break;	364	break;
364	case 'q':// "Get"-Anforderung für Settings	365	case 'q':// "Get"-Anforderung für Settings
365	// Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen	366	// Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
366	Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);	367	Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
367	if(tmp_char_arr2[0] != 0xff)	368	if(tmp_char_arr2[0] != 0xff)
368	{	369	{
369	if(tmp_char_arr2[0] > 5) tmp_char_arr2[0] = 5;	370	if(tmp_char_arr2[0] > 5) tmp_char_arr2[0] = 5;
370	ReadParameterSet(tmp_char_arr2[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);	371	ReadParameterSet(tmp_char_arr2[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
371	SendOutData('L' + tmp_char_arr2[0] -1,MeineSlaveAdresse,(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);
372	}	373	}
373	else	374	else
374	SendOutData('L' + GetActiveParamSetNumber()-1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);	375	SendOutData('L' + GetActiveParamSetNumber()-1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
375		376
376	break;	377	break;
377		378
378	case 'l':	379	case 'l':
379	case 'm':	380	case 'm':
380	case 'n':	381	case 'n':
381	case 'o':	382	case 'o':
382	case 'p': // Parametersatz speichern	383	case 'p': // Parametersatz speichern
383	Decode64((unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE,3,AnzahlEmpfangsBytes);	384	Decode64((unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE,3,AnzahlEmpfangsBytes);
384	WriteParameterSet(RxdBuffer[2] - 'l' + 1, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);	385	WriteParameterSet(RxdBuffer[2] - 'l' + 1, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
385	eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], RxdBuffer[2] - 'l' + 1); // aktiven Datensatz merken	386	eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], RxdBuffer[2] - 'l' + 1); // aktiven Datensatz merken
386	Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;	387	Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;
387	Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;	388	Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;
388	Piep(GetActiveParamSetNumber());	389	Piep(GetActiveParamSetNumber());
389	break;	390	break;
390	*/	391	*/
391		392
392	}	393	}
393	// DebugOut.AnzahlZyklen = Debug_Timer_Intervall;	394	// DebugOut.AnzahlZyklen = Debug_Timer_Intervall;
394	NeuerDatensatzEmpfangen = 0;	395	NeuerDatensatzEmpfangen = 0;
395	}	396	}
396		397
397		398
398	//---------------------------------------------------------------------------------------------	399	//---------------------------------------------------------------------------------------------
399	void DatenUebertragung(void)	400	void DatenUebertragung(void)
400	{	401	{
401	if((CheckDelay(Debug_Timer) && UebertragungAbgeschlossen)) // im Singlestep-Betrieb in jedem Schtitt senden	402	if((CheckDelay(Debug_Timer) && UebertragungAbgeschlossen)) // im Singlestep-Betrieb in jedem Schtitt senden
402	{	403	{
-		404	SetDebugValues();
403	SendOutData('D',MeineSlaveAdresse,(unsigned char *) &DebugOut,sizeof(DebugOut));	405	SendOutData('D',MeineSlaveAdresse,(unsigned char *) &DebugOut,sizeof(DebugOut));
404	Debug_Timer = SetDelay(250); // Sendeintervall	406	Debug_Timer = SetDelay(250); // Sendeintervall
405	}	407	}
406	if(GetVersionAnforderung && UebertragungAbgeschlossen)	408	if(GetVersionAnforderung && UebertragungAbgeschlossen)
407	{	409	{
408	SendOutData('V',MeineSlaveAdresse,(unsigned char *) &VersionInfo,sizeof(VersionInfo));	410	SendOutData('V',MeineSlaveAdresse,(unsigned char *) &VersionInfo,sizeof(VersionInfo));
409	GetVersionAnforderung = 0;	411	GetVersionAnforderung = 0;
410	}	412	}
411	if(DebugTextAnforderung != 255) // Texte für die Analogdaten	413	if(DebugTextAnforderung != 255) // Texte für die Analogdaten
412	{	414	{
413	SendOutData('A',DebugTextAnforderung + '0',(unsigned char *) ANALOG_TEXT[DebugTextAnforderung],16);	415	SendOutData('A',DebugTextAnforderung + '0',(unsigned char *) ANALOG_TEXT[DebugTextAnforderung],16);
414	DebugTextAnforderung = 255;	416	DebugTextAnforderung = 255;
415	}	417	}
416	if(DebugGetAnforderung && UebertragungAbgeschlossen) // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen	418	if(DebugGetAnforderung && UebertragungAbgeschlossen) // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
417	{	419	{
418	SendOutData('G',MeineSlaveAdresse,(unsigned char *) &ExternControl,sizeof(ExternControl));	420	SendOutData('G',MeineSlaveAdresse,(unsigned char *) &ExternControl,sizeof(ExternControl));
419	DebugGetAnforderung = 0;	421	DebugGetAnforderung = 0;
420	}	422	}
421	if(KompassAntwort && UebertragungAbgeschlossen) // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen	423	if(KompassAntwort && UebertragungAbgeschlossen) // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
422	{	424	{
423	SendOutData('K',MeineSlaveAdresse,(unsigned char *) &I2C_Heading,sizeof(I2C_Heading));	425	SendOutData('K',MeineSlaveAdresse,(unsigned char *) &I2C_Heading,sizeof(I2C_Heading));
424	KompassAntwort = 0;	426	KompassAntwort = 0;
425	}	427	}
426	}	428	}
427		429
428		430

Subversion Repositories MK3Mag

(root)/tags/V0.14/uart.c @ 62 - Rev 5 → 7