WebSVN - FlightCtrl - Diff - Rev 189 and 352 - /branches/salvo_gps/Basis


// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + 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 PcZugriff = 100;
unsigned char MotorTest[4] = {0,0,0,0};
unsigned char MeineSlaveAdresse;
struct str_DebugOut    DebugOut;
struct str_Debug       DebugIn;
struct str_VersionInfo VersionInfo;
int Debug_Timer;
//Salvo 26.10.2007
int dataset_cnt=0; //Zahelt die uebertragenen Debugdaten
//Salvo End
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++ 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;
 //Salvo 11.9.2007 GPS Daten holen
 Get_Ublox_Msg(SioTmp); // Daten vom GPS Modul holen
 // Salvo End
 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];
                        DebugDisplayAnforderung = 1;
                        break;
   case 't':// Motortest
            Decode64((unsigned char *) &MotorTest[0],sizeof(MotorTest),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
            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;
                  //Salvo 26.10.2007  Counter fuer Erkennung von fehlenden Daten per Bluetoothuebertragung
                  dataset_cnt++;
                  // Salvo End
          Debug_Timer = SetDelay(MIN_DEBUG_INTERVALL);  
         }
 
     if(DebugDisplayAnforderung && UebertragungAbgeschlossen)
         {
      Menu();
          DebugDisplayAnforderung = 0;
      if(++dis_zeile == 4)
      {
       SendOutData('4',0,&PPM_in,sizeof(PPM_in));   // DisplayZeile übertragen
       dis_zeile = -1;
      }
      else  SendOutData('0' + dis_zeile,0,&DisplayBuff[20 * dis_zeile],20);   // DisplayZeile übertragen
         }
    if(GetVersionAnforderung && UebertragungAbgeschlossen)
     {
      SendOutData('V',MeineSlaveAdresse,(unsigned char *) &VersionInfo,sizeof(VersionInfo));
          GetVersionAnforderung = 0;
     }
 
}
 
 

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

Subversion Repositories FlightCtrl

(root)/branches/salvo_gps/Basis_V0064/tags/V0001/uart.c - Rev 189 → 352