WebSVN - FlightCtrl - Diff - Rev 395 and 492 - /branches/V0.68d J16J17/uart.c


// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Copyright (c) 04.2007 Holger Buss
// + only for non-profit use
// + www.MikroKopter.com
// + see the File "License.txt" for further Informations
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
#include "main.h"
#include "uart.h"
 
unsigned char DebugGetAnforderung = 0,DebugDisplayAnforderung = 0,DebugDataAnforderung = 0,GetVersionAnforderung = 0;
unsigned volatile char SioTmp = 0;
unsigned volatile char SendeBuffer[MAX_SENDE_BUFF];
unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF];
unsigned volatile char NMEABuffer[MAX_EMPFANGS_BUFF];
unsigned volatile char NeuerDatensatzEmpfangen = 0;
unsigned volatile char NeueKoordinateEmpfangen = 0;
unsigned volatile char UebertragungAbgeschlossen = 1;
unsigned volatile char CntCrcError = 0;
unsigned volatile char AnzahlEmpfangsBytes = 0;
unsigned volatile char PC_DebugTimeout = 0;
unsigned char NurKanalAnforderung = 0;
unsigned char PcZugriff = 100;
unsigned char MotorTest[4] = {0,0,0,0};
unsigned char DubWiseKeys[3] = {0,0,0};
unsigned char MeineSlaveAdresse;
struct str_DebugOut    DebugOut;
struct str_Debug       DebugIn;
struct str_VersionInfo VersionInfo;
int Debug_Timer;
 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++ Sende-Part der Datenübertragung
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
SIGNAL(INT_VEC_TX)
{
 static unsigned int ptr = 0;
 unsigned char tmp_tx;
 if(!UebertragungAbgeschlossen)  
  {
   ptr++;                    // die [0] wurde schon gesendet
   tmp_tx = SendeBuffer[ptr];  
   if((tmp_tx == '\r') || (ptr == MAX_SENDE_BUFF))
    {
     ptr = 0;
     UebertragungAbgeschlossen = 1;
    }
   UDR = tmp_tx;
  }
  else ptr = 0;
}
 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++ Empfangs-Part der Datenübertragung, incl. CRC-Auswertung
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
SIGNAL(INT_VEC_RX)
{
 static unsigned int crc;
 static unsigned char crc1,crc2,buf_ptr;
 static unsigned char UartState = 0;
 unsigned char CrcOkay = 0;
 
 SioTmp = UDR;
 if(buf_ptr >= MAX_EMPFANGS_BUFF)    UartState = 0;
 if(SioTmp == '\r' && UartState == 2)
  {
   UartState = 0;
   crc -= RxdBuffer[buf_ptr-2];
   crc -= RxdBuffer[buf_ptr-1];
   crc %= 4096;
   crc1 = '=' + crc / 64;
   crc2 = '=' + crc % 64;
   CrcOkay = 0;
   if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; CntCrcError++;};
   if(!NeuerDatensatzEmpfangen && CrcOkay) // Datensatz schon verarbeitet
    {
     NeuerDatensatzEmpfangen = 1;
         AnzahlEmpfangsBytes = buf_ptr;
     RxdBuffer[buf_ptr] = '\r';
         if(RxdBuffer[2] == 'R') wdt_enable(WDTO_250MS); // Reset-Commando
        }                                
  }
  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);
}
 
 
// --------------------------------------------------------------------------
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;
  }
 
}
 
// --------------------------------------------------------------------------
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 'c':// Debugdaten incl. Externe IOs usw 
                        Decode64((unsigned char *) &DebugIn,sizeof(DebugIn),3,AnzahlEmpfangsBytes);
/*              for(unsigned char i=0; i<4;i++)
                         {
              EE_CheckAndWrite(&EE_Buffer[EE_DEBUGWERTE + i*2],     DebugIn.Analog[i]);
                          EE_CheckAndWrite(&EE_Buffer[EE_DEBUGWERTE + i*2 + 1], DebugIn.Analog[i] >> 8);       
                         }*/
                        RemoteTasten |= DebugIn.RemoteTasten;
            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);
                        break;
   case 'v': // Version-Anforderung     und Ausbaustufe
            GetVersionAnforderung = 1;
            break;                                                               
   case 'g':// "Get"-Anforderung für Debug-Daten 
            // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
            DebugGetAnforderung = 1;
            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;
}
 
//############################################################################
//Routine für die Serielle Ausgabe
int uart_putchar (char c)
//############################################################################
{
        if (c == '\n')
                uart_putchar('\r');
        //Warten solange bis Zeichen gesendet wurde
        loop_until_bit_is_set(USR, UDRE);
        //Ausgabe des Zeichens
        UDR = c;
       
        return (0);
}
 
// --------------------------------------------------------------------------
void WriteProgramData(unsigned int pos, unsigned char wert)
{
  //if (ProgramLocation == IN_RAM) Buffer[pos] = wert;
  // else eeprom_write_byte(&EE_Buffer[pos], wert);
  // Buffer[pos] = wert;
}
 
//############################################################################
//INstallation der Seriellen Schnittstelle
void UART_Init (void)
//############################################################################
{
        //Enable TXEN im Register UCR TX-Data Enable & RX Enable
 
        UCR=(1 << TXEN) | (1 << RXEN);
    // UART Double Speed (U2X)
        USR   |= (1<<U2X);          
        // RX-Interrupt Freigabe
        UCSRB |= (1<<RXCIE);          
        // TX-Interrupt Freigabe
        UCSRB |= (1<<TXCIE);          
 
        //Teiler wird gesetzt 
        UBRR=(SYSCLK / (BAUD_RATE * 8L) - 1);
        //UBRR = 33;
        //öffnet einen Kanal für printf (STDOUT)
        //fdevopen (uart_putchar, 0);
        //sbi(PORTD,4);
  Debug_Timer = SetDelay(200);  
}
 
//---------------------------------------------------------------------------------------------
void DatenUebertragung(void)  
{
 static char dis_zeile = 0;
 if(!UebertragungAbgeschlossen) return;
 
   if(DebugGetAnforderung && UebertragungAbgeschlossen)               // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
   {
      SendOutData('G',MeineSlaveAdresse,(unsigned char *) &DebugIn,sizeof(DebugIn));
          DebugGetAnforderung = 0;
   }
 
    if((CheckDelay(Debug_Timer) || DebugDataAnforderung) && UebertragungAbgeschlossen)  
         {
          SendOutData('D',MeineSlaveAdresse,(unsigned char *) &DebugOut,sizeof(DebugOut));
          DebugDataAnforderung = 0;
          Debug_Timer = SetDelay(MIN_DEBUG_INTERVALL);  
         }
 
     if(DebugDisplayAnforderung && UebertragungAbgeschlossen)
         {
      Menu();
          DebugDisplayAnforderung = 0;
      if(++dis_zeile == 4 || NurKanalAnforderung)
      {
       SendOutData('4',0,(unsigned char *)&PPM_in,sizeof(PPM_in));   // DisplayZeile übertragen
       dis_zeile = -1;
      }
      else  SendOutData('0' + dis_zeile,0,(unsigned char *)&DisplayBuff[20 * dis_zeile],20);   // DisplayZeile übertragen
         }
    if(GetVersionAnforderung && UebertragungAbgeschlossen)
     {
      SendOutData('V',MeineSlaveAdresse,(unsigned char *) &VersionInfo,sizeof(VersionInfo));
          GetVersionAnforderung = 0;
     }
 
}
 
 

Rev 395	Rev 492
1	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	1	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2	// + Copyright (c) 04.2007 Holger Buss	2	// + Copyright (c) 04.2007 Holger Buss
3	// + only for non-profit use	3	// + only for non-profit use
4	// + www.MikroKopter.com	4	// + www.MikroKopter.com
5	// + see the File "License.txt" for further Informations	5	// + see the File "License.txt" for further Informations
6	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	6	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
7		7
8	#include "main.h"	8	#include "main.h"
9	#include "uart.h"	9	#include "uart.h"
10		10
11	unsigned char DebugGetAnforderung = 0,DebugDisplayAnforderung = 0,DebugDataAnforderung = 0,GetVersionAnforderung = 0;	11	unsigned char DebugGetAnforderung = 0,DebugDisplayAnforderung = 0,DebugDataAnforderung = 0,GetVersionAnforderung = 0;
12	unsigned volatile char SioTmp = 0;	12	unsigned volatile char SioTmp = 0;
13	unsigned volatile char SendeBuffer[MAX_SENDE_BUFF];	13	unsigned volatile char SendeBuffer[MAX_SENDE_BUFF];
14	unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF];	14	unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF];
15	unsigned volatile char NMEABuffer[MAX_EMPFANGS_BUFF];	15	unsigned volatile char NMEABuffer[MAX_EMPFANGS_BUFF];
16	unsigned volatile char NeuerDatensatzEmpfangen = 0;	16	unsigned volatile char NeuerDatensatzEmpfangen = 0;
17	unsigned volatile char NeueKoordinateEmpfangen = 0;	17	unsigned volatile char NeueKoordinateEmpfangen = 0;
18	unsigned volatile char UebertragungAbgeschlossen = 1;	18	unsigned volatile char UebertragungAbgeschlossen = 1;
19	unsigned volatile char CntCrcError = 0;	19	unsigned volatile char CntCrcError = 0;
20	unsigned volatile char AnzahlEmpfangsBytes = 0;	20	unsigned volatile char AnzahlEmpfangsBytes = 0;
21	unsigned volatile char PC_DebugTimeout = 0;	21	unsigned volatile char PC_DebugTimeout = 0;
22	unsigned char NurKanalAnforderung = 0;	22	unsigned char NurKanalAnforderung = 0;
23	unsigned char PcZugriff = 100;	23	unsigned char PcZugriff = 100;
24	unsigned char MotorTest[4] = {0,0,0,0};	24	unsigned char MotorTest[4] = {0,0,0,0};
-		25	unsigned char DubWiseKeys[3] = {0,0,0};
25	unsigned char MeineSlaveAdresse;	26	unsigned char MeineSlaveAdresse;
26	struct str_DebugOut DebugOut;	27	struct str_DebugOut DebugOut;
27	struct str_Debug DebugIn;	28	struct str_Debug DebugIn;
28	struct str_VersionInfo VersionInfo;	29	struct str_VersionInfo VersionInfo;
29	int Debug_Timer;	30	int Debug_Timer;
30		31
31	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	32	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
32	//++ Sende-Part der Datenübertragung	33	//++ Sende-Part der Datenübertragung
33	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	34	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
34	SIGNAL(INT_VEC_TX)	35	SIGNAL(INT_VEC_TX)
35	{	36	{
36	static unsigned int ptr = 0;	37	static unsigned int ptr = 0;
37	unsigned char tmp_tx;	38	unsigned char tmp_tx;
38	if(!UebertragungAbgeschlossen)	39	if(!UebertragungAbgeschlossen)
39	{	40	{
40	ptr++; // die [0] wurde schon gesendet	41	ptr++; // die [0] wurde schon gesendet
41	tmp_tx = SendeBuffer[ptr];	42	tmp_tx = SendeBuffer[ptr];
42	if((tmp_tx == '\r') \|\| (ptr == MAX_SENDE_BUFF))	43	if((tmp_tx == '\r') \|\| (ptr == MAX_SENDE_BUFF))
43	{	44	{
44	ptr = 0;	45	ptr = 0;
45	UebertragungAbgeschlossen = 1;	46	UebertragungAbgeschlossen = 1;
46	}	47	}
47	UDR = tmp_tx;	48	UDR = tmp_tx;
48	}	49	}
49	else ptr = 0;	50	else ptr = 0;
50	}	51	}
51		52
52	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	53	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
53	//++ Empfangs-Part der Datenübertragung, incl. CRC-Auswertung	54	//++ Empfangs-Part der Datenübertragung, incl. CRC-Auswertung
54	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	55	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
55	SIGNAL(INT_VEC_RX)	56	SIGNAL(INT_VEC_RX)
56	{	57	{
57	static unsigned int crc;	58	static unsigned int crc;
58	static unsigned char crc1,crc2,buf_ptr;	59	static unsigned char crc1,crc2,buf_ptr;
59	static unsigned char UartState = 0;	60	static unsigned char UartState = 0;
60	unsigned char CrcOkay = 0;	61	unsigned char CrcOkay = 0;
61		62
62	SioTmp = UDR;	63	SioTmp = UDR;
63	if(buf_ptr >= MAX_EMPFANGS_BUFF) UartState = 0;	64	if(buf_ptr >= MAX_EMPFANGS_BUFF) UartState = 0;
64	if(SioTmp == '\r' && UartState == 2)	65	if(SioTmp == '\r' && UartState == 2)
65	{	66	{
66	UartState = 0;	67	UartState = 0;
67	crc -= RxdBuffer[buf_ptr-2];	68	crc -= RxdBuffer[buf_ptr-2];
68	crc -= RxdBuffer[buf_ptr-1];	69	crc -= RxdBuffer[buf_ptr-1];
69	crc %= 4096;	70	crc %= 4096;
70	crc1 = '=' + crc / 64;	71	crc1 = '=' + crc / 64;
71	crc2 = '=' + crc % 64;	72	crc2 = '=' + crc % 64;
72	CrcOkay = 0;	73	CrcOkay = 0;
73	if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; CntCrcError++;};	74	if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; CntCrcError++;};
74	if(!NeuerDatensatzEmpfangen && CrcOkay) // Datensatz schon verarbeitet	75	if(!NeuerDatensatzEmpfangen && CrcOkay) // Datensatz schon verarbeitet
75	{	76	{
76	NeuerDatensatzEmpfangen = 1;	77	NeuerDatensatzEmpfangen = 1;
77	AnzahlEmpfangsBytes = buf_ptr;	78	AnzahlEmpfangsBytes = buf_ptr;
78	RxdBuffer[buf_ptr] = '\r';	79	RxdBuffer[buf_ptr] = '\r';
79	if(RxdBuffer[2] == 'R') wdt_enable(WDTO_250MS); // Reset-Commando	80	if(RxdBuffer[2] == 'R') wdt_enable(WDTO_250MS); // Reset-Commando
80	}	81	}
81	}	82	}
82	else	83	else
83	switch(UartState)	84	switch(UartState)
84	{	85	{
85	case 0:	86	case 0:
86	if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1; // Startzeichen und Daten schon verarbeitet	87	if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1; // Startzeichen und Daten schon verarbeitet
87	buf_ptr = 0;	88	buf_ptr = 0;
88	RxdBuffer[buf_ptr++] = SioTmp;	89	RxdBuffer[buf_ptr++] = SioTmp;
89	crc = SioTmp;	90	crc = SioTmp;
90	break;	91	break;
91	case 1: // Adresse auswerten	92	case 1: // Adresse auswerten
92	UartState++;	93	UartState++;
93	RxdBuffer[buf_ptr++] = SioTmp;	94	RxdBuffer[buf_ptr++] = SioTmp;
94	crc += SioTmp;	95	crc += SioTmp;
95	break;	96	break;
96	case 2: // Eingangsdaten sammeln	97	case 2: // Eingangsdaten sammeln
97	RxdBuffer[buf_ptr] = SioTmp;	98	RxdBuffer[buf_ptr] = SioTmp;
98	if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;	99	if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;
99	else UartState = 0;	100	else UartState = 0;
100	crc += SioTmp;	101	crc += SioTmp;
101	break;	102	break;
102	default:	103	default:
103	UartState = 0;	104	UartState = 0;
104	break;	105	break;
105	}	106	}
106	}	107	}
107		108
108		109
109	// --------------------------------------------------------------------------	110	// --------------------------------------------------------------------------
110	void AddCRC(unsigned int wieviele)	111	void AddCRC(unsigned int wieviele)
111	{	112	{
112	unsigned int tmpCRC = 0,i;	113	unsigned int tmpCRC = 0,i;
113	for(i = 0; i < wieviele;i++)	114	for(i = 0; i < wieviele;i++)
114	{	115	{
115	tmpCRC += SendeBuffer[i];	116	tmpCRC += SendeBuffer[i];
116	}	117	}
117	tmpCRC %= 4096;	118	tmpCRC %= 4096;
118	SendeBuffer[i++] = '=' + tmpCRC / 64;	119	SendeBuffer[i++] = '=' + tmpCRC / 64;
119	SendeBuffer[i++] = '=' + tmpCRC % 64;	120	SendeBuffer[i++] = '=' + tmpCRC % 64;
120	SendeBuffer[i++] = '\r';	121	SendeBuffer[i++] = '\r';
121	UebertragungAbgeschlossen = 0;	122	UebertragungAbgeschlossen = 0;
122	UDR = SendeBuffer[0];	123	UDR = SendeBuffer[0];
123	}	124	}
124		125
125		126
126		127
127	// --------------------------------------------------------------------------	128	// --------------------------------------------------------------------------
128	void SendOutData(unsigned char cmd,unsigned char modul, unsigned char *snd, unsigned char len)	129	void SendOutData(unsigned char cmd,unsigned char modul, unsigned char *snd, unsigned char len)
129	{	130	{
130	unsigned int pt = 0;	131	unsigned int pt = 0;
131	unsigned char a,b,c;	132	unsigned char a,b,c;
132	unsigned char ptr = 0;	133	unsigned char ptr = 0;
133		134
134	SendeBuffer[pt++] = '#'; // Startzeichen	135	SendeBuffer[pt++] = '#'; // Startzeichen
135	SendeBuffer[pt++] = modul; // Adresse (a=0; b=1,...)	136	SendeBuffer[pt++] = modul; // Adresse (a=0; b=1,...)
136	SendeBuffer[pt++] = cmd; // Commando	137	SendeBuffer[pt++] = cmd; // Commando
137		138
138	while(len)	139	while(len)
139	{	140	{
140	if(len) { a = snd[ptr++]; len--;} else a = 0;	141	if(len) { a = snd[ptr++]; len--;} else a = 0;
141	if(len) { b = snd[ptr++]; len--;} else b = 0;	142	if(len) { b = snd[ptr++]; len--;} else b = 0;
142	if(len) { c = snd[ptr++]; len--;} else c = 0;	143	if(len) { c = snd[ptr++]; len--;} else c = 0;
143	SendeBuffer[pt++] = '=' + (a >> 2);	144	SendeBuffer[pt++] = '=' + (a >> 2);
144	SendeBuffer[pt++] = '=' + (((a & 0x03) << 4) \| ((b & 0xf0) >> 4));	145	SendeBuffer[pt++] = '=' + (((a & 0x03) << 4) \| ((b & 0xf0) >> 4));
145	SendeBuffer[pt++] = '=' + (((b & 0x0f) << 2) \| ((c & 0xc0) >> 6));	146	SendeBuffer[pt++] = '=' + (((b & 0x0f) << 2) \| ((c & 0xc0) >> 6));
146	SendeBuffer[pt++] = '=' + ( c & 0x3f);	147	SendeBuffer[pt++] = '=' + ( c & 0x3f);
147	}	148	}
148	AddCRC(pt);	149	AddCRC(pt);
149	}	150	}
150		151
151		152
152	// --------------------------------------------------------------------------	153	// --------------------------------------------------------------------------
153	void Decode64(unsigned char *ptrOut, unsigned char len, unsigned char ptrIn,unsigned char max) // Wohin mit den Daten; Wie lang; Wo im RxdBuffer	154	void Decode64(unsigned char *ptrOut, unsigned char len, unsigned char ptrIn,unsigned char max) // Wohin mit den Daten; Wie lang; Wo im RxdBuffer
154	{	155	{
155	unsigned char a,b,c,d;	156	unsigned char a,b,c,d;
156	unsigned char ptr = 0;	157	unsigned char ptr = 0;
157	unsigned char x,y,z;	158	unsigned char x,y,z;
158	while(len)	159	while(len)
159	{	160	{
160	a = RxdBuffer[ptrIn++] - '=';	161	a = RxdBuffer[ptrIn++] - '=';
161	b = RxdBuffer[ptrIn++] - '=';	162	b = RxdBuffer[ptrIn++] - '=';
162	c = RxdBuffer[ptrIn++] - '=';	163	c = RxdBuffer[ptrIn++] - '=';
163	d = RxdBuffer[ptrIn++] - '=';	164	d = RxdBuffer[ptrIn++] - '=';
164	if(ptrIn > max - 2) break; // nicht mehr Daten verarbeiten, als empfangen wurden	165	if(ptrIn > max - 2) break; // nicht mehr Daten verarbeiten, als empfangen wurden
165		166
166	x = (a << 2) \| (b >> 4);	167	x = (a << 2) \| (b >> 4);
167	y = ((b & 0x0f) << 4) \| (c >> 2);	168	y = ((b & 0x0f) << 4) \| (c >> 2);
168	z = ((c & 0x03) << 6) \| d;	169	z = ((c & 0x03) << 6) \| d;
169		170
170	if(len--) ptrOut[ptr++] = x; else break;	171	if(len--) ptrOut[ptr++] = x; else break;
171	if(len--) ptrOut[ptr++] = y; else break;	172	if(len--) ptrOut[ptr++] = y; else break;
172	if(len--) ptrOut[ptr++] = z; else break;	173	if(len--) ptrOut[ptr++] = z; else break;
173	}	174	}
174		175
175	}	176	}
176		177
177	// --------------------------------------------------------------------------	178	// --------------------------------------------------------------------------
178	void BearbeiteRxDaten(void)	179	void BearbeiteRxDaten(void)
179	{	180	{
180	if(!NeuerDatensatzEmpfangen) return;	181	if(!NeuerDatensatzEmpfangen) return;
181		182
182	// unsigned int tmp_int_arr1[1];	183	// unsigned int tmp_int_arr1[1];
183	// unsigned int tmp_int_arr2[2];	184	// unsigned int tmp_int_arr2[2];
184	// unsigned int tmp_int_arr3[3];	185	// unsigned int tmp_int_arr3[3];
185	unsigned char tmp_char_arr2[2];	186	unsigned char tmp_char_arr2[2];
186	// unsigned char tmp_char_arr3[3];	187	// unsigned char tmp_char_arr3[3];
187	// unsigned char tmp_char_arr4[4];	188	// unsigned char tmp_char_arr4[4];
188	//if(!MotorenEin)	189	//if(!MotorenEin)
189	PcZugriff = 255;	190	PcZugriff = 255;
190	switch(RxdBuffer[2])	191	switch(RxdBuffer[2])
191	{	192	{
192	case 'c':// Debugdaten incl. Externe IOs usw	193	case 'c':// Debugdaten incl. Externe IOs usw
193	Decode64((unsigned char *) &DebugIn,sizeof(DebugIn),3,AnzahlEmpfangsBytes);	194	Decode64((unsigned char *) &DebugIn,sizeof(DebugIn),3,AnzahlEmpfangsBytes);
194	/* for(unsigned char i=0; i<4;i++)	195	/* for(unsigned char i=0; i<4;i++)
195	{	196	{
196	EE_CheckAndWrite(&EE_Buffer[EE_DEBUGWERTE + i*2], DebugIn.Analog[i]);	197	EE_CheckAndWrite(&EE_Buffer[EE_DEBUGWERTE + i*2], DebugIn.Analog[i]);
197	EE_CheckAndWrite(&EE_Buffer[EE_DEBUGWERTE + i*2 + 1], DebugIn.Analog[i] >> 8);	198	EE_CheckAndWrite(&EE_Buffer[EE_DEBUGWERTE + i*2 + 1], DebugIn.Analog[i] >> 8);
198	}*/	199	}*/
199	RemoteTasten \|= DebugIn.RemoteTasten;	200	RemoteTasten \|= DebugIn.RemoteTasten;
200	DebugDataAnforderung = 1;	201	DebugDataAnforderung = 1;
201	break;	202	break;
202	case 'h':// x-1 Displayzeilen	203	case 'h':// x-1 Displayzeilen
203	Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);	204	Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
204	RemoteTasten \|= tmp_char_arr2[0];	205	RemoteTasten \|= tmp_char_arr2[0];
205	if(tmp_char_arr2[1] == 255) NurKanalAnforderung = 1; else NurKanalAnforderung = 0; // keine Displaydaten	206	if(tmp_char_arr2[1] == 255) NurKanalAnforderung = 1; else NurKanalAnforderung = 0; // keine Displaydaten
206	DebugDisplayAnforderung = 1;	207	DebugDisplayAnforderung = 1;
207	break;	208	break;
208	case 't':// Motortest	209	case 't':// Motortest
209	Decode64((unsigned char *) &MotorTest[0],sizeof(MotorTest),3,AnzahlEmpfangsBytes);	210	Decode64((unsigned char *) &MotorTest[0],sizeof(MotorTest),3,AnzahlEmpfangsBytes);
210	break;	211	break;
-		212	case 'k':// Keys von DubWise
-		213	Decode64((unsigned char *) &DubWiseKeys[0],sizeof(DubWiseKeys),3,AnzahlEmpfangsBytes);
-		214	break;
211	case 'v': // Version-Anforderung und Ausbaustufe	215	case 'v': // Version-Anforderung und Ausbaustufe
212	GetVersionAnforderung = 1;	216	GetVersionAnforderung = 1;
213	break;	217	break;
214	case 'g':// "Get"-Anforderung für Debug-Daten	218	case 'g':// "Get"-Anforderung für Debug-Daten
215	// Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen	219	// Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
216	DebugGetAnforderung = 1;	220	DebugGetAnforderung = 1;
217	break;	221	break;
218	case 'q':// "Get"-Anforderung für Settings	222	case 'q':// "Get"-Anforderung für Settings
219	// Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen	223	// Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
220	Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);	224	Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
221	if(tmp_char_arr2[0] != 0xff)	225	if(tmp_char_arr2[0] != 0xff)
222	{	226	{
223	if(tmp_char_arr2[0] > 5) tmp_char_arr2[0] = 5;	227	if(tmp_char_arr2[0] > 5) tmp_char_arr2[0] = 5;
224	ReadParameterSet(tmp_char_arr2[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);	228	ReadParameterSet(tmp_char_arr2[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
225	SendOutData('L' + tmp_char_arr2[0] -1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);	229	SendOutData('L' + tmp_char_arr2[0] -1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
226	}	230	}
227	else	231	else
228	SendOutData('L' + GetActiveParamSetNumber()-1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);	232	SendOutData('L' + GetActiveParamSetNumber()-1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
229		233
230	break;	234	break;
231		235
232	case 'l':	236	case 'l':
233	case 'm':	237	case 'm':
234	case 'n':	238	case 'n':
235	case 'o':	239	case 'o':
236	case 'p': // Parametersatz speichern	240	case 'p': // Parametersatz speichern
237	Decode64((unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE,3,AnzahlEmpfangsBytes);	241	Decode64((unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE,3,AnzahlEmpfangsBytes);
238	WriteParameterSet(RxdBuffer[2] - 'l' + 1, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);	242	WriteParameterSet(RxdBuffer[2] - 'l' + 1, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
239	eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], RxdBuffer[2] - 'l' + 1); // aktiven Datensatz merken	243	eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], RxdBuffer[2] - 'l' + 1); // aktiven Datensatz merken
240	Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;	244	Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;
241	Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;	245	Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;
242	Piep(GetActiveParamSetNumber());	246	Piep(GetActiveParamSetNumber());
243	break;	247	break;
244		248
245		249
246	}	250	}
247	// DebugOut.AnzahlZyklen = Debug_Timer_Intervall;	251	// DebugOut.AnzahlZyklen = Debug_Timer_Intervall;
248	NeuerDatensatzEmpfangen = 0;	252	NeuerDatensatzEmpfangen = 0;
249	}	253	}
250		254
251	//############################################################################	255	//############################################################################
252	//Routine für die Serielle Ausgabe	256	//Routine für die Serielle Ausgabe
253	int uart_putchar (char c)	257	int uart_putchar (char c)
254	//############################################################################	258	//############################################################################
255	{	259	{
256	if (c == '\n')	260	if (c == '\n')
257	uart_putchar('\r');	261	uart_putchar('\r');
258	//Warten solange bis Zeichen gesendet wurde	262	//Warten solange bis Zeichen gesendet wurde
259	loop_until_bit_is_set(USR, UDRE);	263	loop_until_bit_is_set(USR, UDRE);
260	//Ausgabe des Zeichens	264	//Ausgabe des Zeichens
261	UDR = c;	265	UDR = c;
262		266
263	return (0);	267	return (0);
264	}	268	}
265		269
266	// --------------------------------------------------------------------------	270	// --------------------------------------------------------------------------
267	void WriteProgramData(unsigned int pos, unsigned char wert)	271	void WriteProgramData(unsigned int pos, unsigned char wert)
268	{	272	{
269	//if (ProgramLocation == IN_RAM) Buffer[pos] = wert;	273	//if (ProgramLocation == IN_RAM) Buffer[pos] = wert;
270	// else eeprom_write_byte(&EE_Buffer[pos], wert);	274	// else eeprom_write_byte(&EE_Buffer[pos], wert);
271	// Buffer[pos] = wert;	275	// Buffer[pos] = wert;
272	}	276	}
273		277
274	//############################################################################	278	//############################################################################
275	//INstallation der Seriellen Schnittstelle	279	//INstallation der Seriellen Schnittstelle
276	void UART_Init (void)	280	void UART_Init (void)
277	//############################################################################	281	//############################################################################
278	{	282	{
279	//Enable TXEN im Register UCR TX-Data Enable & RX Enable	283	//Enable TXEN im Register UCR TX-Data Enable & RX Enable
280		284
281	UCR=(1 << TXEN) \| (1 << RXEN);	285	UCR=(1 << TXEN) \| (1 << RXEN);
282	// UART Double Speed (U2X)	286	// UART Double Speed (U2X)
283	USR \|= (1<<U2X);	287	USR \|= (1<<U2X);
284	// RX-Interrupt Freigabe	288	// RX-Interrupt Freigabe
285	UCSRB \|= (1<<RXCIE);	289	UCSRB \|= (1<<RXCIE);
286	// TX-Interrupt Freigabe	290	// TX-Interrupt Freigabe
287	UCSRB \|= (1<<TXCIE);	291	UCSRB \|= (1<<TXCIE);
288		292
289	//Teiler wird gesetzt	293	//Teiler wird gesetzt
290	UBRR=(SYSCLK / (BAUD_RATE * 8L) - 1);	294	UBRR=(SYSCLK / (BAUD_RATE * 8L) - 1);
291	//UBRR = 33;	295	//UBRR = 33;
292	//öffnet einen Kanal für printf (STDOUT)	296	//öffnet einen Kanal für printf (STDOUT)
293	//fdevopen (uart_putchar, 0);	297	//fdevopen (uart_putchar, 0);
294	//sbi(PORTD,4);	298	//sbi(PORTD,4);
295	Debug_Timer = SetDelay(200);	299	Debug_Timer = SetDelay(200);
296	}	300	}
297		301
298	//---------------------------------------------------------------------------------------------	302	//---------------------------------------------------------------------------------------------
299	void DatenUebertragung(void)	303	void DatenUebertragung(void)
300	{	304	{
301	static char dis_zeile = 0;	305	static char dis_zeile = 0;
302	if(!UebertragungAbgeschlossen) return;	306	if(!UebertragungAbgeschlossen) return;
303		307
304	if(DebugGetAnforderung && UebertragungAbgeschlossen) // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen	308	if(DebugGetAnforderung && UebertragungAbgeschlossen) // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
305	{	309	{
306	SendOutData('G',MeineSlaveAdresse,(unsigned char *) &DebugIn,sizeof(DebugIn));	310	SendOutData('G',MeineSlaveAdresse,(unsigned char *) &DebugIn,sizeof(DebugIn));
307	DebugGetAnforderung = 0;	311	DebugGetAnforderung = 0;
308	}	312	}
309		313
310	if((CheckDelay(Debug_Timer) \|\| DebugDataAnforderung) && UebertragungAbgeschlossen)	314	if((CheckDelay(Debug_Timer) \|\| DebugDataAnforderung) && UebertragungAbgeschlossen)
311	{	315	{
312	SendOutData('D',MeineSlaveAdresse,(unsigned char *) &DebugOut,sizeof(DebugOut));	316	SendOutData('D',MeineSlaveAdresse,(unsigned char *) &DebugOut,sizeof(DebugOut));
313	DebugDataAnforderung = 0;	317	DebugDataAnforderung = 0;
314	Debug_Timer = SetDelay(MIN_DEBUG_INTERVALL);	318	Debug_Timer = SetDelay(MIN_DEBUG_INTERVALL);
315	}	319	}
316		320
317	if(DebugDisplayAnforderung && UebertragungAbgeschlossen)	321	if(DebugDisplayAnforderung && UebertragungAbgeschlossen)
318	{	322	{
319	Menu();	323	Menu();
320	DebugDisplayAnforderung = 0;	324	DebugDisplayAnforderung = 0;
321	if(++dis_zeile == 4 \|\| NurKanalAnforderung)	325	if(++dis_zeile == 4 \|\| NurKanalAnforderung)
322	{	326	{
323	SendOutData('4',0,(unsigned char *)&PPM_in,sizeof(PPM_in)); // DisplayZeile übertragen	327	SendOutData('4',0,(unsigned char *)&PPM_in,sizeof(PPM_in)); // DisplayZeile übertragen
324	dis_zeile = -1;	328	dis_zeile = -1;
325	}	329	}
326	else SendOutData('0' + dis_zeile,0,(unsigned char )&DisplayBuff[20 dis_zeile],20); // DisplayZeile übertragen	330	else SendOutData('0' + dis_zeile,0,(unsigned char )&DisplayBuff[20 dis_zeile],20); // DisplayZeile übertragen
327	}	331	}
328	if(GetVersionAnforderung && UebertragungAbgeschlossen)	332	if(GetVersionAnforderung && UebertragungAbgeschlossen)
329	{	333	{
330	SendOutData('V',MeineSlaveAdresse,(unsigned char *) &VersionInfo,sizeof(VersionInfo));	334	SendOutData('V',MeineSlaveAdresse,(unsigned char *) &VersionInfo,sizeof(VersionInfo));
331	GetVersionAnforderung = 0;	335	GetVersionAnforderung = 0;
332	}	336	}
333		337
334	}	338	}
335		339
336		340

Subversion Repositories FlightCtrl

(root)/branches/V0.68d J16J17/uart.c @ 1079 - Rev 395 → 492