Subversion Repositories BL-Ctrl

Rev

Rev 51 | Rev 60 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1 ingob 1
/*############################################################################
2
 + Regler für Brushless-Motoren
3
 + ATMEGA8 mit 8MHz
4
 + (c) 01.2007 Holger Buss
5
 + Nur für den privaten Gebrauch
6
 + Keine Garantie auf Fehlerfreiheit
7
 + Kommerzielle Nutzung nur mit meiner Zustimmung
8
 + Der Code ist für die Hardware BL_Ctrl V1.0 entwickelt worden
9
 + www.mikrocontroller.com
10
/############################################################################*/
11
 
12
#include "main.h"
13
 
14
unsigned int  PWM = 0;
58 hbuss 15
unsigned int  Strom = 0,RuheStrom; //ca. in 0,1A
1 ingob 16
unsigned char Strom_max = 0;
51 holgerb 17
unsigned char Mittelstrom = 0;
1 ingob 18
unsigned int  Drehzahl = 0;  // in 100UPM  60 = 6000
19
unsigned int  KommutierDelay = 10;
20
unsigned int  I2C_Timeout = 0;
23 ingob 21
unsigned int SIO_Timeout = 0;
1 ingob 22
unsigned int  SollDrehzahl = 0;
23
unsigned int  IstDrehzahl = 0;
24
unsigned int  DrehZahlTabelle[256];//vorberechnete Werte zur Drehzahlerfassung
25
unsigned char ZeitFuerBerechnungen = 1;
26
unsigned char MotorAnwerfen = 0;
27
unsigned char MotorGestoppt = 1;
28
unsigned char MaxPWM = MAX_PWM;
29
unsigned int  CntKommutierungen = 0;
30
unsigned int  SIO_Drehzahl = 0;
31
unsigned char ZeitZumAdWandeln = 1;
24 ingob 32
unsigned char MotorAdresse = 1;
50 holgerb 33
unsigned char PPM_Betrieb = 1;
1 ingob 34
 
35
//############################################################################
36
//
37
void SetPWM(void)
38
//############################################################################
39
{
40
    unsigned char tmp_pwm;
41
    tmp_pwm = PWM;
42
    if(tmp_pwm > MaxPWM)    // Strombegrenzung
43
        {
44
        tmp_pwm = MaxPWM;
45
        PORTC |= ROT;
46
        }
47
    if(Strom > MAX_STROM)   // Strombegrenzung
48
        {
49
        OCR1A = 0; OCR1B = 0; OCR2  = 0;
50
        PORTC |= ROT;
51
        Strom--;
52
        }
53
    else
54
        {
55
        #ifdef  _32KHZ 
56
        OCR1A =  tmp_pwm; OCR1B =  tmp_pwm; OCR2  = tmp_pwm;
57
        #endif 
58
 
59
        #ifdef  _16KHZ 
50 holgerb 60
        //OCR1A = 2 * (int)tmp_pwm; OCR1B = 2 * (int)tmp_pwm; OCR2  = tmp_pwm;
61
        OCR1A =  tmp_pwm; OCR1B =  tmp_pwm; OCR2  = tmp_pwm;
1 ingob 62
        #endif 
63
        }
64
}
65
 
66
//############################################################################
67
//
68
void PWM_Init(void)
69
//############################################################################
70
{
71
    PWM_OFF;
50 holgerb 72
    TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (0 << WGM12) |
1 ingob 73
             (0 << WGM13) | (0<< ICES1) | (0 << ICNC1);
50 holgerb 74
/*    TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (1 << WGM12) |
75
             (0 << WGM13) | (0<< ICES1) | (0 << ICNC1);
76
*/
1 ingob 77
}
78
 
79
//############################################################################
80
//
81
void Wait(unsigned char dauer)
82
//############################################################################
83
{
84
    dauer = (unsigned char)TCNT0 + dauer;
85
    while((TCNT0 - dauer) & 0x80);
86
}
87
 
88
//############################################################################
89
//
90
void Anwerfen(unsigned char pwm)
91
//############################################################################
92
{
93
    unsigned long timer = 300,i;
94
    DISABLE_SENSE_INT;
95
    PWM = 5;
96
    SetPWM();
97
    Manuell();
98
    Delay_ms(200);
99
    PWM = pwm;
100
    while(1)
101
        {
102
        for(i=0;i<timer; i++)
103
            {
104
            if(!UebertragungAbgeschlossen)  SendUart();
105
            else DatenUebertragung();
106
            Wait(100);  // warten
107
            }
108
        timer-= timer/15+1;
109
        if(timer < 25) { if(TEST_MANUELL) timer = 25; else return; }
110
 
111
        Manuell();
112
        Phase++;
113
        Phase %= 6;
114
        AdConvert();
115
        PWM = pwm;
116
        SetPWM();
117
        if(SENSE)
118
            {
119
            PORTD ^= GRUEN;
120
            }
121
        }
122
}
123
 
50 holgerb 124
/*
125
#define SENSE_A ADMUX = 0;
126
#define SENSE_B ADMUX = 1;
127
#define SENSE_C ADMUX = 2;
128
 
129
#define ClrSENSE            ACSR |= 0x10
130
#define SENSE               ((ACSR & 0x10))
131
#define SENSE_L             (!(ACSR & 0x20))
132
#define SENSE_H             ((ACSR & 0x20))
133
*/
134
 
135
void RotBlink(unsigned char anz)
136
{
137
sei(); // Interrupts ein
138
 while(anz--)
139
  {
140
   PORTC |= ROT;
141
   Delay_ms(300);    
142
   PORTC &= ~ROT;
143
   Delay_ms(300);    
144
  }
145
   Delay_ms(1000);    
146
}
147
 
58 hbuss 148
#define TEST_STROMGRENZE 120
50 holgerb 149
unsigned char DelayM(unsigned int timer)
150
{
151
 while(timer--)
152
  {
153
   FastADConvert();
58 hbuss 154
   if(Strom > (TEST_STROMGRENZE + RuheStrom))
50 holgerb 155
       {
51 holgerb 156
        FETS_OFF;
50 holgerb 157
        return(1);
158
       }
159
  }
160
 return(0);  
161
}
162
 
163
unsigned char Delay(unsigned int timer)
164
{
165
 while(timer--)
166
  {
51 holgerb 167
//   if(SENSE_H) { PORTC |= ROT; } else { PORTC &= ~ROT;}
50 holgerb 168
  }
169
 return(0);  
170
}
171
 
58 hbuss 172
/*
51 holgerb 173
void ShowSense(void)
174
{
175
 if(SENSE_H) { PORTC |= ROT; } else { PORTC &= ~ROT;}
50 holgerb 176
 
51 holgerb 177
}
58 hbuss 178
*/
51 holgerb 179
#define HIGH_A_EIN PORTB |= 0x08
180
#define HIGH_B_EIN PORTB |= 0x04
181
#define HIGH_C_EIN PORTB |= 0x02
182
#define LOW_A_EIN  PORTD |= 0x08
183
#define LOW_B_EIN  PORTD |= 0x10
184
#define LOW_C_EIN  PORTD |= 0x20
185
 
50 holgerb 186
void MotorTon(void)
1 ingob 187
//############################################################################
50 holgerb 188
{
51 holgerb 189
    unsigned char ADR_TAB[5] = {0,0,2,1,3};
50 holgerb 190
    unsigned int timer = 300,i;
51 holgerb 191
    unsigned int t = 0;
58 hbuss 192
    unsigned char anz = 0,MosfetOkay = 0, grenze = 50;
51 holgerb 193
 
194
    PORTC &= ~ROT;
195
    Delay_ms(300 * ADR_TAB[MotorAdresse]);    
50 holgerb 196
    DISABLE_SENSE_INT;
197
    cli();//Globale Interrupts Ausschalten
198
    uart_putchar('\n');
199
    STEUER_OFF;
58 hbuss 200
    Strom_max = 0;
201
    DelayM(50);
202
    RuheStrom = Strom_max;
203
//    uart_putchar(RuheStrom + 'A');
50 holgerb 204
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
205
//+ High-Mosfets auf Kurzschluss testen
206
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
207
    Strom = 0;
51 holgerb 208
    LOW_B_EIN;
209
    HIGH_A_EIN;
50 holgerb 210
    if(DelayM(3))
211
       {
212
        anz = 1;
51 holgerb 213
        uart_putchar('1');
50 holgerb 214
       }
51 holgerb 215
    FETS_OFF;
216
    Delay(1000);
50 holgerb 217
    Strom = 0;
51 holgerb 218
    LOW_A_EIN;
219
    HIGH_B_EIN;
50 holgerb 220
    if(DelayM(3))
221
       {
222
        anz = 2;
51 holgerb 223
        uart_putchar('2');
50 holgerb 224
       }
51 holgerb 225
    FETS_OFF;
226
    Delay(1000);
50 holgerb 227
    Strom = 0;
51 holgerb 228
    LOW_B_EIN; // Low C ein
229
    HIGH_C_EIN; // High B ein
50 holgerb 230
    if(DelayM(3))
231
       {
232
        anz = 3;
51 holgerb 233
        uart_putchar('3');
50 holgerb 234
       }
51 holgerb 235
    FETS_OFF;
236
    Delay(1000);
237
    LOW_A_EIN; // Low  A ein; und A gegen C
238
    HIGH_C_EIN; // High C ein
50 holgerb 239
    if(DelayM(3))
240
       {
241
        anz = 3;
51 holgerb 242
        uart_putchar('7');
50 holgerb 243
       }
51 holgerb 244
    FETS_OFF;
245
    DelayM(10000);
246
if(anz) while(1) RotBlink(anz);  // bei Kurzschluss nicht starten
247
 
50 holgerb 248
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
51 holgerb 249
//+ LOW-Mosfets auf Schalten und Kurzschluss testen
50 holgerb 250
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
58 hbuss 251
 if(UDR == ' ') {t = 65535; grenze = 40; uart_putchar('_');} else t = 1000; // Ausführlicher Test
51 holgerb 252
 Strom = 0;
253
 for(i=0;i<t;i++)
254
 {
255
  LOW_A_EIN;
256
  DelayM(1);
257
  FETS_OFF;
258
  Delay(5);
259
  HIGH_A_EIN;
260
  DelayM(1);
261
  FETS_OFF;
58 hbuss 262
  if(Strom > grenze + RuheStrom) {anz = 4; uart_putchar('4'); break;}
51 holgerb 263
  Delay(5);
264
 }
265
 Delay(10000);
50 holgerb 266
 
51 holgerb 267
 Strom = 0;
268
 for(i=0;i<t;i++)
269
 {
270
  LOW_B_EIN;
271
  DelayM(1);
272
  FETS_OFF;
273
  Delay(5);
274
  HIGH_B_EIN;
275
  DelayM(1);
276
  FETS_OFF;
58 hbuss 277
  if(Strom > grenze + RuheStrom) {anz = 5; uart_putchar('5'); break;}
51 holgerb 278
  Delay(5);
279
 }
50 holgerb 280
 
51 holgerb 281
 Strom = 0;
282
 Delay(10000);
283
 
284
 for(i=0;i<t;i++)
285
 {
286
  LOW_C_EIN;
287
  DelayM(1);
288
  FETS_OFF;
289
  Delay(5);
290
  HIGH_C_EIN;
291
  DelayM(1);
292
  FETS_OFF;
58 hbuss 293
  if(Strom > grenze + RuheStrom) {anz = 6; uart_putchar('6'); break;}
51 holgerb 294
  Delay(5);
295
 }
296
 
50 holgerb 297
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
298
//+ High-Mosfets auf Schalten testen
299
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
300
    SENSE_A;
51 holgerb 301
    FETS_OFF;
302
    LOW_B_EIN; // Low B ein
303
    LOW_C_EIN; // Low C ein
50 holgerb 304
    Strom = 0;
51 holgerb 305
#define TONDAUER  40000    
306
#define SOUND_E 2
307
#define SOUND1_A 300
308
#define SOUND2_A 330
309
#define SOUND3_A 360
310
 
50 holgerb 311
    for(i=0; i< (TONDAUER / SOUND2_A) ; i++)
312
     {
51 holgerb 313
      HIGH_A_EIN; // Test A
50 holgerb 314
      Delay(SOUND_E);
51 holgerb 315
      if(MessAD(0) > 50) { MosfetOkay |= 0x01; } else { MosfetOkay &= ~0x01;};
50 holgerb 316
      PORTB = 0;
51 holgerb 317
      Delay(SOUND1_A);
50 holgerb 318
     }
51 holgerb 319
    FETS_OFF;
320
 
321
    LOW_A_EIN; // Low A ein
322
    LOW_C_EIN; // Low C ein
50 holgerb 323
    for(i=0; i<(TONDAUER / SOUND1_A); i++)
324
     {
51 holgerb 325
      HIGH_B_EIN; // Test B
50 holgerb 326
      Delay(SOUND_E);
51 holgerb 327
      if(MessAD(1) > 50) { MosfetOkay |= 0x02; } else { MosfetOkay &= ~0x02;};
50 holgerb 328
      PORTB = 0;
329
      Delay(SOUND1_A);
330
     }
331
 
51 holgerb 332
    FETS_OFF;
333
    LOW_A_EIN; // Low A ein
334
    LOW_B_EIN; // Low B ein
50 holgerb 335
    for(i=0; i<(TONDAUER / SOUND3_A); i++)
336
     {
51 holgerb 337
      HIGH_C_EIN; // Test C
50 holgerb 338
      Delay(SOUND_E);
51 holgerb 339
      if(MessAD(2) > 50) { MosfetOkay |= 0x04; } else { MosfetOkay &= ~0x04;};
50 holgerb 340
      PORTB = 0;
51 holgerb 341
      Delay(SOUND2_A);
50 holgerb 342
     }
51 holgerb 343
    FETS_OFF;
50 holgerb 344
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
345
//+ Low-Mosfets auf Schalten testen
346
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
347
    SENSE_B;
51 holgerb 348
    LOW_A_EIN; // Low A ein
50 holgerb 349
    for(i=0; i< (TONDAUER / SOUND2_A) ; i++)
350
     {
51 holgerb 351
      HIGH_B_EIN; // Test B
50 holgerb 352
      Delay(SOUND_E);
51 holgerb 353
      if(MessAD(0) > 50) { MosfetOkay &= ~0x08;} else { MosfetOkay |= 0x08;};
50 holgerb 354
      PORTB = 0;
355
      Delay(SOUND2_A);
356
     }
51 holgerb 357
 
358
//++++++++++++++++++++++++++++++++++++
359
    LOW_C_EIN; // Low C ein
360
    for(i=0; i<(TONDAUER / SOUND1_A); i++)
50 holgerb 361
     {
51 holgerb 362
      HIGH_B_EIN; // Test B
50 holgerb 363
      Delay(SOUND_E);
51 holgerb 364
      if(MessAD(2) > 50) { MosfetOkay &= ~0x20;} else { MosfetOkay |= 0x20;};
50 holgerb 365
      PORTB = 0;
366
      Delay(SOUND3_A);
367
     }
51 holgerb 368
    FETS_OFF;
369
//++++++++++++++++++++++++++++++++++++
370
    FETS_OFF;
371
    LOW_B_EIN; // Low B ein
372
    for(i=0; i<(TONDAUER / SOUND3_A); i++)
50 holgerb 373
     {
51 holgerb 374
      HIGH_C_EIN; // Test C
50 holgerb 375
      Delay(SOUND_E);
51 holgerb 376
      if(MessAD(1) > 50) { MosfetOkay &= ~0x10;} else { MosfetOkay |= 0x10;};
50 holgerb 377
      PORTB = 0;
51 holgerb 378
      Delay(SOUND3_A);
50 holgerb 379
     }
51 holgerb 380
    FETS_OFF;
381
//++++++++++++++++++++++++++++++++++++
50 holgerb 382
 
51 holgerb 383
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
50 holgerb 384
    sei();//Globale Interrupts Einschalten
51 holgerb 385
//    Delay_ms(250 * MotorAdresse);    
386
/*
387
    LOW_A_EIN; // Low B ein
50 holgerb 388
#define SOUND8_A 650
389
    for(i=0; i<(TONDAUER / SOUND8_A); i++)
390
     {
51 holgerb 391
      HIGH_B_EIN; // Test B
392
      Delay(SOUND_E);
393
      PORTB = 0;
394
      Delay(SOUND8_A);
50 holgerb 395
     }
51 holgerb 396
*/
397
 Delay_ms(300 * (4-ADR_TAB[MotorAdresse]));    
58 hbuss 398
 if(!(MosfetOkay & 0x01))  { anz = 1; UDR='A'; } else
399
 if(!(MosfetOkay & 0x02))  { anz = 2; UDR='B'; } else
400
 if(!(MosfetOkay & 0x04))  { anz = 3; UDR='C'; } else
401
 if(!(MosfetOkay & 0x08))  { anz = 4; UDR='a'; } else
402
 if(!(MosfetOkay & 0x10))  { anz = 5; UDR='b'; } else
403
 if(!(MosfetOkay & 0x20))  { anz = 6; UDR='c'; }  
50 holgerb 404
 
58 hbuss 405
 if(anz) Delay_ms(1000);
50 holgerb 406
 
51 holgerb 407
 RotBlink(anz);
408
 uart_putchar('.');
50 holgerb 409
}
410
 
411
//############################################################################
1 ingob 412
//
413
unsigned char SollwertErmittlung(void)
414
//############################################################################
415
{
416
    static unsigned int sollwert = 0;
417
    unsigned int ppm;
418
    if(!I2C_Timeout)   // bei Erreichen von 0 ist der Wert ungültig
419
        {
420
        if(SIO_Timeout)  // es gibt gültige SIO-Daten
421
            {
50 holgerb 422
             sollwert =  (MAX_PWM * (unsigned int) SIO_Sollwert) / 200;  // skalieren auf 0-200 = 0-255
423
             PPM_Betrieb = 0;
424
             ICP_INT_DISABLE;
425
             PORTC &= ~ROT;
1 ingob 426
            }
427
        else
50 holgerb 428
            if(anz_ppm_werte > 20)  // es gibt gültige PPM-Daten
1 ingob 429
                {
50 holgerb 430
                PPM_Betrieb = 1;
1 ingob 431
                ppm = PPM_Signal;
432
                if(ppm > 300) ppm =   0;  // ungültiges Signal
433
                if(ppm > 200) ppm = 200;
434
                if(ppm <= MIN_PPM) sollwert = 0;
435
                else
436
                    {
437
                    sollwert = (int) MIN_PWM + ((MAX_PWM - MIN_PWM) * (ppm - MIN_PPM)) / (190 - MIN_PPM);
438
                    }
439
                PORTC &= ~ROT;
440
                }
441
            else   // Kein gültiger Sollwert
442
                {
50 holgerb 443
                 if(!TEST_SCHUB) { if(sollwert) sollwert--; }  
444
                 PORTC |= ROT;
1 ingob 445
                }
446
        }
447
    else // I2C-Daten sind gültig
448
        {
449
        sollwert = I2C_RXBuffer;
50 holgerb 450
        PPM_Betrieb = 0;
1 ingob 451
        PORTC &= ~ROT;
50 holgerb 452
        ICP_INT_DISABLE;
1 ingob 453
        }
454
    if(sollwert > MAX_PWM) sollwert = MAX_PWM;
455
    return(sollwert);
456
}
457
 
458
void DebugAusgaben(void)
459
{
460
    DebugOut.Analog[0] = Strom;
461
    DebugOut.Analog[1] = Mittelstrom;
462
    DebugOut.Analog[2] = SIO_Drehzahl;
463
    DebugOut.Analog[3] = PPM_Signal;
464
}
465
 
466
 
467
//############################################################################
468
//Hauptprogramm
469
int main (void)
470
//############################################################################
471
{
472
    char altPhase = 0;
473
    int test = 0;
474
    unsigned int MinUpmPulse,Blink,TestschubTimer;
475
    unsigned int Blink2,MittelstromTimer,DrehzahlMessTimer,MotorGestopptTimer;
476
 
477
    DDRC  = 0x08;
478
    PORTC = 0x08;
479
    DDRD  = 0xBA;
26 ingob 480
    PORTD = 0x00;
1 ingob 481
    DDRB  = 0x0E;
482
    PORTB = 0x31;
24 ingob 483
 
484
#if (MOTORADRESSE == 0)
485
    PORTB |= (ADR1 + ADR2);   // Pullups für Adresswahl
43 holgerb 486
    for(test=0;test<500;test++);
24 ingob 487
    if (PINB & ADR1)
488
         {
489
           if (PINB & ADR2) MotorAdresse = 1;
490
            else MotorAdresse = 2;
491
         }
492
         else
493
         {
494
           if (PINB & ADR2) MotorAdresse = 3;
495
            else MotorAdresse = 4;
496
         }
497
#else
498
    MotorAdresse  = MOTORADRESSE;
499
#endif
1 ingob 500
 
501
    UART_Init();
502
    Timer0_Init();
50 holgerb 503
    sei();//Globale Interrupts Einschalten
1 ingob 504
 
505
    // Am Blinken erkennt man die richtige Motoradresse
50 holgerb 506
/*
1 ingob 507
    for(test=0;test<5;test++)
508
        {
24 ingob 509
        if(test == MotorAdresse) PORTD |= GRUEN;
1 ingob 510
        Delay_ms(150);
511
        PORTD &= ~GRUEN;
512
        Delay_ms(250);
513
        }      
514
 
515
    Delay_ms(500);
50 holgerb 516
*/  
18 ingob 517
   // UART_Init();  // war doppelt
1 ingob 518
    PWM_Init();
519
 
520
    InitIC2_Slave(0x50);                           
521
    InitPPM();
522
 
523
    Blink             = SetDelay(101);    
524
    Blink2            = SetDelay(102);
525
    MinUpmPulse       = SetDelay(103);
526
    MittelstromTimer  = SetDelay(254);
527
    DrehzahlMessTimer = SetDelay(1005);
528
    TestschubTimer    = SetDelay(1006);
50 holgerb 529
    while(!CheckDelay(MinUpmPulse))
530
    {
531
     if(SollwertErmittlung()) break;
532
    }
533
    ;
1 ingob 534
    PORTD |= GRUEN;
535
    PWM = 0;
536
 
537
    SetPWM();
538
 
539
    SFIOR = 0x08;  // Analog Comperator ein
540
    ADMUX = 1;
541
 
542
    MinUpmPulse = SetDelay(10);
543
    DebugOut.Analog[1] = 1;
544
    PPM_Signal = 0;
545
 
50 holgerb 546
    if(!SollwertErmittlung()) MotorTon();
58 hbuss 547
//MotorTon();    
548
    PORTB = 0x31; // Pullups wieder einschalten
50 holgerb 549
 
1 ingob 550
    // zum Test der Hardware; Motor dreht mit konstanter Drehzahl ohne Regelung
551
    if(TEST_MANUELL)    Anwerfen(TEST_MANUELL);  // kommt von dort nicht wieder
552
 
553
    while (1)
554
        {
51 holgerb 555
//ShowSense();
556
 
1 ingob 557
        if(!TEST_SCHUB)   PWM = SollwertErmittlung();
558
        //I2C_TXBuffer = PWM; // Antwort über I2C-Bus
559
        if(MANUELL_PWM)   PWM = MANUELL_PWM;
560
 
561
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
562
        if(Phase != altPhase)   // es gab eine Kommutierung im Interrupt
563
            {
564
            MotorGestoppt = 0;
565
            ZeitFuerBerechnungen = 0;    // direkt nach einer Kommutierung ist Zeit 
58 hbuss 566
            MinUpmPulse = SetDelay(250);  // Timeout, falls ein Motor stehen bleibt
1 ingob 567
            altPhase = Phase;
568
            }
569
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
570
        if(!PWM)    // Sollwert == 0
571
            {
572
            MotorAnwerfen = 0;      // kein Startversuch
573
            ZeitFuerBerechnungen = 0;
574
            // nach 1,5 Sekunden den Motor als gestoppt betrachten 
18 ingob 575
            if(CheckDelay(MotorGestopptTimer))
1 ingob 576
                {
577
                DISABLE_SENSE_INT;
578
                MotorGestoppt = 1;  
579
                STEUER_OFF;
580
                }
581
            }
582
        else
583
            {
584
            if(MotorGestoppt) MotorAnwerfen = 1;        // Startversuch
585
            MotorGestopptTimer = SetDelay(1500);
586
            }
587
 
588
        if(MotorGestoppt && !TEST_SCHUB) PWM = 0;
589
        SetPWM();
590
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
591
        if(!ZeitFuerBerechnungen++)
592
            {
593
            if(MotorGestoppt) PORTD |= GRUEN; //else PORTD &= ~GRUEN;
594
            if(SIO_DEBUG)
595
                {
596
                DebugAusgaben();  // welche Werte sollen angezeigt werden?
597
                if(!UebertragungAbgeschlossen)  SendUart();
598
                else DatenUebertragung();
599
                }
600
            // Berechnen des Mittleren Stroms zur (langsamen) Strombegrenzung
601
            if(CheckDelay(MittelstromTimer))  
602
                {
603
                MittelstromTimer = SetDelay(50); // alle 50ms
604
                if(Mittelstrom <  Strom) Mittelstrom++;// Mittelwert des Stroms bilden
605
                else if(Mittelstrom >  Strom) Mittelstrom--;
58 hbuss 606
                if(Strom > MAX_STROM) MaxPWM -= MaxPWM / 32;              
607
                if((Mittelstrom > LIMIT_STROM))// Strom am Limit?
1 ingob 608
                    {
58 hbuss 609
                    if(MaxPWM) MaxPWM--;// dann die Maximale PWM herunterfahren
1 ingob 610
                    PORTC |= ROT;
611
                    }
612
                else
613
                    {
614
                    if(MaxPWM < MAX_PWM) MaxPWM++;
615
                    }
616
                }
617
 
618
            if(CheckDelay(DrehzahlMessTimer))   // Ist-Drehzahl bestimmen
619
                {
620
                DrehzahlMessTimer = SetDelay(10);
58 hbuss 621
                SIO_Drehzahl = CntKommutierungen;//(6 * CntKommutierungen) / (POLANZAHL / 2);
1 ingob 622
                CntKommutierungen = 0;
623
                if(PPM_Timeout == 0) // keine PPM-Signale
624
                ZeitZumAdWandeln = 1;
625
                }
626
 
58 hbuss 627
          if(TEST_SCHUB)
628
           {
1 ingob 629
            if(CheckDelay(TestschubTimer))  
630
                {
631
                TestschubTimer = SetDelay(1500);
632
                    switch(test)
633
                        {
634
                        case 0: PWM = 50; test++; break;
635
                        case 1: PWM = 130; test++; break;
636
                        case 2: PWM = 60;  test++; break;
637
                        case 3: PWM = 140; test++; break;
638
                        case 4: PWM = 150; test = 0; break;
639
                        default: test = 0;
640
                        }
641
                }
58 hbuss 642
            }  
643
          // Motor Stehen geblieben
1 ingob 644
            if((CheckDelay(MinUpmPulse) && SIO_Drehzahl == 0) || MotorAnwerfen)
645
                {
646
                MotorGestoppt = 1;    
647
                DISABLE_SENSE_INT;
648
                MinUpmPulse = SetDelay(100);        
649
                if(MotorAnwerfen)
650
                    {
651
                    PORTC &= ~ROT;
652
                    MotorAnwerfen = 0;
653
                    Anwerfen(10);
654
                    PORTD |= GRUEN;
655
                    MotorGestoppt = 0;    
656
                    Phase--;
657
                    PWM = 1;
658
                    SetPWM();
659
                    SENSE_TOGGLE_INT;
660
                    ENABLE_SENSE_INT;
43 holgerb 661
                    MinUpmPulse = SetDelay(20);
1 ingob 662
                    while(!CheckDelay(MinUpmPulse)); // kurz Synchronisieren
43 holgerb 663
                    PWM = 15;
1 ingob 664
                    SetPWM();
43 holgerb 665
                    MinUpmPulse = SetDelay(300);
1 ingob 666
                    while(!CheckDelay(MinUpmPulse)); // kurz Durchstarten
18 ingob 667
 
668
                                    // Drehzahlmessung wieder aufsetzen
669
                    DrehzahlMessTimer = SetDelay(50);
1 ingob 670
                    altPhase = 7;
671
                    }
672
                }
673
            } // ZeitFuerBerechnungen
674
        } // while(1) - Hauptschleife
675
}
676