Subversion Repositories FlightCtrl

Rev

Rev 838 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 838 Rev 966
Line 35... Line 35...
35 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 35 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
36 
//++ Sende-Part der Datenübertragung
 36 
//++ Sende-Part der Datenübertragung
37 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 37 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
38 
SIGNAL(INT_VEC_TX)
 38 
SIGNAL(INT_VEC_TX)
39 
{
 39 
{
40 
 static unsigned int ptr = 0;
 40 
  static unsigned int ptr = 0;
41 
 unsigned char tmp_tx;
 41 
  unsigned char tmp_tx;
42 
 if(!UebertragungAbgeschlossen)  
 42 
  if(!UebertragungAbgeschlossen)  
43 
  {
 43 
  {
44 
   ptr++;                    // die [0] wurde schon gesendet
 44 
    ptr++;                    // die [0] wurde schon gesendet
45 
   tmp_tx = SendeBuffer[ptr];  
 45 
    tmp_tx = SendeBuffer[ptr];  
46 
   if((tmp_tx == '\r') || (ptr == MAX_SENDE_BUFF))
 46 
    if((tmp_tx == '\r') || (ptr == MAX_SENDE_BUFF))
47 
    {
 47 
    {
48 
     ptr = 0;
 48 
      ptr = 0;
49 
     UebertragungAbgeschlossen = 1;
 49 
      UebertragungAbgeschlossen = 1;
50 
    }
 50 
    }
51 
   UDR = tmp_tx;
 51 
    UDR = tmp_tx;
52 
  }
 52 
  }
53 
  else ptr = 0;
 53 
  else ptr = 0;
54 
}
 54 
}
Line 55... Line 55...
55 
 
 55 
 
56 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 56 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
57 
//++ Empfangs-Part der Datenübertragung, incl. CRC-Auswertung
 57 
//++ Empfangs-Part der Datenübertragung, incl. CRC-Auswertung
58 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 58 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
59 
SIGNAL(INT_VEC_RX)
 59 
SIGNAL(INT_VEC_RX)
60 
{
 60 
{
61 
 static unsigned int crc;
 61 
  static unsigned int crc;
62 
 static unsigned char crc1,crc2,buf_ptr;
 62 
  static unsigned char crc1,crc2,buf_ptr;
63 
 static unsigned char UartState = 0;
 63 
  static unsigned char UartState = 0;
64 
 unsigned char CrcOkay = 0;
 64 
  unsigned char CrcOkay = 0;
65 
 
 65 
 
66 
 SioTmp = UDR;
 66 
  SioTmp = UDR;
67 
 if(buf_ptr >= MAX_EMPFANGS_BUFF)    UartState = 0;
 67 
  if(buf_ptr >= MAX_EMPFANGS_BUFF)    UartState = 0;
68 
 if(SioTmp == '\r' && UartState == 2)
 68 
  if(SioTmp == '\r' && UartState == 2)
69 
  {
 69 
  {
70 
   UartState = 0;
 70 
    UartState = 0;
71 
   crc -= RxdBuffer[buf_ptr-2];
 71 
    crc -= RxdBuffer[buf_ptr-2];
72 
   crc -= RxdBuffer[buf_ptr-1];
 72 
    crc -= RxdBuffer[buf_ptr-1];
73 
   crc %= 4096;
 73 
    crc %= 4096;
74 
   crc1 = '=' + crc / 64;
 74 
    crc1 = '=' + crc / 64;
75 
   crc2 = '=' + crc % 64;
 75 
    crc2 = '=' + crc % 64;
76 
   CrcOkay = 0;
 76 
    CrcOkay = 0;
77 
   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++;};
78 
   if(!NeuerDatensatzEmpfangen && CrcOkay) // Datensatz schon verarbeitet
 78 
    if(!NeuerDatensatzEmpfangen && CrcOkay) // Datensatz schon verarbeitet
79 
    {
 79 
    {
80 
     NeuerDatensatzEmpfangen = 1;
 80 
      NeuerDatensatzEmpfangen = 1;
81 
         AnzahlEmpfangsBytes = buf_ptr;
 81 
      AnzahlEmpfangsBytes = buf_ptr;
82 
     RxdBuffer[buf_ptr] = '\r';
 82 
      RxdBuffer[buf_ptr] = '\r';
83 
         if(RxdBuffer[2] == 'R') wdt_enable(WDTO_250MS); // Reset-Commando
 83 
      if(RxdBuffer[2] == 'R') wdt_enable(WDTO_250MS); // Reset-Commando
84 
        }                                
 84 
    }                            
85 
  }
 85 
  }
86 
  else
 86 
  else
87 
  switch(UartState)
 87 
    switch(UartState)
88 
  {
 88 
  {
89 
   case 0:
 89 
case 0:
90 
          if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1;  // Startzeichen und Daten schon verarbeitet
 90 
  if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1;  // Startzeichen und Daten schon verarbeitet
91 
                  buf_ptr = 0;
 91 
  buf_ptr = 0;
92 
                  RxdBuffer[buf_ptr++] = SioTmp;
 92 
  RxdBuffer[buf_ptr++] = SioTmp;
93 
                  crc = SioTmp;
 93 
  crc = SioTmp;
94 
          break;
 94 
  break;
95 
   case 1: // Adresse auswerten
 95 
case 1: // Adresse auswerten
96 
                  UartState++;
 96 
  UartState++;
97 
                  RxdBuffer[buf_ptr++] = SioTmp;
 97 
  RxdBuffer[buf_ptr++] = SioTmp;
98 
                  crc += SioTmp;
 98 
  crc += SioTmp;
99 
                  break;
 99 
  break;
100 
   case 2: //  Eingangsdaten sammeln
 100 
case 2: //  Eingangsdaten sammeln
101 
                  RxdBuffer[buf_ptr] = SioTmp;
 101 
  RxdBuffer[buf_ptr] = SioTmp;
102 
                  if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;
 102 
  if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;
103 
                  else UartState = 0;
 103 
  else UartState = 0;
104 
                  crc += SioTmp;
 104 
  crc += SioTmp;
105 
                  break;
 105 
  break;
106 
   default:
 106 
default:
107 
          UartState = 0;
 107 
  UartState = 0;
108 
          break;
 108 
  break;
109 
  }
 109 
  }
Line 110... Line 110...
110 
}
 110 
}
Line 135... Line 135...
135 
 unsigned char a,b,c;
 135 
 unsigned char a,b,c;
136 
 unsigned char ptr = 0;
 136 
 unsigned char ptr = 0;
Line 137... Line 137...
137 
 
 137 
 
138 
 SendeBuffer[pt++] = '#';               // Startzeichen
 138 
 SendeBuffer[pt++] = '#';               // Startzeichen
139 
 SendeBuffer[pt++] = modul;             // Adresse (a=0; b=1,...)
 139 
 SendeBuffer[pt++] = modul;             // Adresse (a=0; b=1,...)
Line 140... Line 140...
140 
 SendeBuffer[pt++] = cmd;                       // Commando
 140 
 SendeBuffer[pt++] = cmd;               // Commando
141 
 
 141 
 
142 
 while(len)
 142 
 while(len)
143 
  {
 143 
  {
Line 178... Line 178...
178 
}
 178 
}
Line 179... Line 179...
179 
 
 179 
 
180 
// --------------------------------------------------------------------------
 180 
// --------------------------------------------------------------------------
181 
void BearbeiteRxDaten(void)
 181 
void BearbeiteRxDaten(void)
182 
{
 182 
{
183 
 if(!NeuerDatensatzEmpfangen) return;
 183 
  if(!NeuerDatensatzEmpfangen) return;
184 
 unsigned char tmp_char_arr2[2]  ={0,0};
 184 
  unsigned char tmp_char_arr2[2]  ={0,0};
185 
 PcZugriff = 255;
 185 
  PcZugriff = 255;
186 
  switch(RxdBuffer[2])
 186 
  switch(RxdBuffer[2])
187 
  {
 187 
  {
188 
   case 'c':// Debugdaten incl. Externe IOs usw
188 
  case 'c':// Debugdaten incl. Externe IOs usw
189 
                        Decode64((unsigned char *) &DebugIn,sizeof(DebugIn),3,AnzahlEmpfangsBytes);
 189 
    Decode64((unsigned char *) &DebugIn,sizeof(DebugIn),3,AnzahlEmpfangsBytes);
190 
            DebugDataAnforderung = 1;
 190 
    DebugDataAnforderung = 1;
191 
            break;
 191 
    break;
192 
   case 'h':// x-1 Displayzeilen
 192 
  case 'h':// x-1 Displayzeilen
193 
            Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
 193 
    Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
194 
                        if(tmp_char_arr2[1] == 255) NurKanalAnforderung = 1; else NurKanalAnforderung = 0; // keine Displaydaten
 194 
    if(tmp_char_arr2[1] == 255) NurKanalAnforderung = 1; else NurKanalAnforderung = 0; // keine Displaydaten
195 
                        DebugDisplayAnforderung = 1;
 195 
    DebugDisplayAnforderung = 1;
196 
                        break;
 196 
    break;
197 
   case 't':// Motortest
 197 
  case 't':// Motortest
198 
            Decode64((unsigned char *) &MotorTest[0],sizeof(MotorTest),3,AnzahlEmpfangsBytes);
 198 
    Decode64((unsigned char *) &MotorTest[0],sizeof(MotorTest),3,AnzahlEmpfangsBytes);
199 
                        break;
 199 
    break;
200 
   case 'v': // Version-Anforderung     und Ausbaustufe
 200 
  case 'v': // Version-Anforderung      und Ausbaustufe
201 
            GetVersionAnforderung = 1;
 201 
    GetVersionAnforderung = 1;
202 
            break;                                                               
 202 
    break;                                                               
203 
   case 'g':// "Get"-Anforderung für Debug-Daten
203 
  case 'g':// "Get"-Anforderung für Debug-Daten
204 
            // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
 204 
    // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
205 
            DebugGetAnforderung = 1;
 205 
    DebugGetAnforderung = 1;
206 
            break;
 206 
    break;
207 
   case 'q':// "Get"-Anforderung für Settings
 207 
  case 'q':// "Get"-Anforderung für Settings
208 
            // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
 208 
    // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
209 
            Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
 209 
    Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
210 
            if(tmp_char_arr2[0] != 0xff)
 210 
    if(tmp_char_arr2[0] != 0xff)
211 
             {
 211 
    {
212 
                          if(tmp_char_arr2[0] > 5) tmp_char_arr2[0] = 5;
 212 
      if(tmp_char_arr2[0] > 5) tmp_char_arr2[0] = 5;
213 
                  ReadParameterSet(tmp_char_arr2[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);                   
 213 
      ReadParameterSet(tmp_char_arr2[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);                       
214 
                  SendOutData('L' + tmp_char_arr2[0] -1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
 214 
      SendOutData('L' + tmp_char_arr2[0] -1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
215 
             }
 215 
    }
216 
             else
 216 
    else
217 
                  SendOutData('L' + GetActiveParamSetNumber()-1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
 217 
      SendOutData('L' + GetActiveParamSetNumber()-1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
218 
            break;
 218 
    break;
219 
   case 'l':
 219 
  case 'l':
220 
   case 'm':
 220 
  case 'm':
221 
   case 'n':
 221 
  case 'n':
222 
   case 'o':
 222 
  case 'o':
223 
   case 'p': // Parametersatz speichern
 223 
  case 'p': // Parametersatz speichern
224 
            Decode64((unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE,3,AnzahlEmpfangsBytes);
 224 
    Decode64((unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE,3,AnzahlEmpfangsBytes);
225 
                        WriteParameterSet(RxdBuffer[2] - 'l' + 1, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
 225 
    WriteParameterSet(RxdBuffer[2] - 'l' + 1, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
- 
 
 226 
    eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], RxdBuffer[2] - 'l' + 1);  // aktiven Datensatz merken
- 
 
 227 
    beeptime = 10000;
226 
            eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], RxdBuffer[2] - 'l' + 1);  // aktiven Datensatz merken
 228 
    BeepMuster = 0x0080;
227 
         break;
 229 
    break;
228 
  }
 230 
  }
229 
 NeuerDatensatzEmpfangen = 0;
 231 
  NeuerDatensatzEmpfangen = 0;
Line 230... Line 232...
230 
}
 232 
}
231 
 
 233 
 
232 
 
 234 
 
233 
//############################################################################
 235 
//############################################################################
234 
//Routine für die Serielle Ausgabe
 236 
//Routine für die Serielle Ausgabe
235 
int uart_putchar (char c)
 237 
int uart_putchar (char c)
236 
//############################################################################
 238 
//############################################################################
237 
{
 239 
{
238 
        if (c == '\n')
 240 
  if (c == '\n')
239 
                uart_putchar('\r');
 241 
    uart_putchar('\r');
240 
        //Warten solange bis Zeichen gesendet wurde
 242 
  //Warten solange bis Zeichen gesendet wurde
241 
        loop_until_bit_is_set(USR, UDRE);
 243 
  loop_until_bit_is_set(USR, UDRE);
242 
        //Ausgabe des Zeichens
 244 
  //Ausgabe des Zeichens
Line 243... Line 245...
243 
        UDR = c;       
 245 
  UDR = c;     
244 
        return (0);
 246 
  return (0);
245 
}
 247 
}
Line 255... Line 257...
255 
//############################################################################
 257 
//############################################################################
256 
//INstallation der Seriellen Schnittstelle
 258 
//INstallation der Seriellen Schnittstelle
257 
void UART_Init (void)
 259 
void UART_Init (void)
258 
//############################################################################
 260 
//############################################################################
259 
{
 261 
{
260 
        //Enable TXEN im Register UCR TX-Data Enable & RX Enable
 262 
  //Enable TXEN im Register UCR TX-Data Enable & RX Enable
261 
 
 263 
 
262 
        UCR=(1 << TXEN) | (1 << RXEN);
 264 
  UCR=(1 << TXEN) | (1 << RXEN);
263 
    // UART Double Speed (U2X)
 265 
  // UART Double Speed (U2X)
264 
        USR   |= (1<<U2X);          
 266 
  USR   |= (1<<U2X);          
265 
        // RX-Interrupt Freigabe
 267 
  // RX-Interrupt Freigabe
266 
        UCSRB |= (1<<RXCIE);          
 268 
  UCSRB |= (1<<RXCIE);          
267 
        // TX-Interrupt Freigabe
 269 
  // TX-Interrupt Freigabe
268 
        UCSRB |= (1<<TXCIE);          
 270 
  UCSRB |= (1<<TXCIE);          
269 
 
 271 
 
270 
        //Teiler wird gesetzt
272 
  //Teiler wird gesetzt
271 
        UBRR=(SYSCLK / (BAUD_RATE * 8L) - 1);
 273 
  UBRR=(SYSCLK / (BAUD_RATE * 8L) - 1);
272 
        //UBRR = 33;
 274 
  //UBRR = 33;
273 
        //öffnet einen Kanal für printf (STDOUT)
 275 
  //öffnet einen Kanal für printf (STDOUT)
274 
        //fdevopen (uart_putchar, 0);
 276 
  //fdevopen (uart_putchar, 0);
275 
        //sbi(PORTD,4);
 277 
  //sbi(PORTD,4);
276 
  Debug_Timer = SetDelay(400);  
 278 
  Debug_Timer = SetDelay(400);  
277 
}
 279 
}
Line 278... Line 280...
278 
 
 280 
 
279 
//---------------------------------------------------------------------------------------------
 281 
//---------------------------------------------------------------------------------------------
280 
void DatenUebertragung(void)  
 282 
void DatenUebertragung(void)  
281 
{
 283 
{
282 
 if(!UebertragungAbgeschlossen) return;
 284 
  if(!UebertragungAbgeschlossen) return;
283 
 
 285 
 
284 
   if(DebugGetAnforderung && UebertragungAbgeschlossen)               // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
 286 
  if(DebugGetAnforderung && UebertragungAbgeschlossen)        // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
285 
   {
 287 
  {
286 
      SendOutData('G',MeineSlaveAdresse,(unsigned char *) &DebugIn,sizeof(DebugIn));
 288 
    SendOutData('G',MeineSlaveAdresse,(unsigned char *) &DebugIn,sizeof(DebugIn));
287 
          DebugGetAnforderung = 0;
 289 
    DebugGetAnforderung = 0;
288 
   }
 290 
  }
289 
 
 291 
 
290 
    if((CheckDelay(Debug_Timer) || DebugDataAnforderung) && UebertragungAbgeschlossen)  
 292 
  if((CheckDelay(Debug_Timer) || DebugDataAnforderung) && UebertragungAbgeschlossen)    
291 
    {
 293 
  {
292 
                SendOutData('D',MeineSlaveAdresse,(unsigned char *) &DebugOut,sizeof(DebugOut));
 294 
    SendOutData('D',MeineSlaveAdresse,(unsigned char *) &DebugOut,sizeof(DebugOut));
293 
                DebugDataAnforderung = 0;
 295 
    DebugDataAnforderung = 0;
294 
                Debug_Timer = SetDelay(2 * MIN_DEBUG_INTERVALL);  
 296 
    Debug_Timer = SetDelay(2 * MIN_DEBUG_INTERVALL);  
295 
    }
 297 
  }
296 
       
 298 
 
297 
    if(GetVersionAnforderung && UebertragungAbgeschlossen)
 299 
  if(GetVersionAnforderung && UebertragungAbgeschlossen)
298 
     {
 300 
  {
299 
      SendOutData('V',MeineSlaveAdresse,(unsigned char *) &VersionInfo,sizeof(VersionInfo));
 301 
    SendOutData('V',MeineSlaveAdresse,(unsigned char *) &VersionInfo,sizeof(VersionInfo));
300 
          GetVersionAnforderung = 0;
 302 
    GetVersionAnforderung = 0;
301 
     }
 303 
  }