Subversion Repositories BL-Ctrl

Rev

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

Rev 82 Rev 116
Line 82... Line 82...
82
//############################################################################
82
//############################################################################
83
//
83
//
84
void SetPWM(void)
84
void SetPWM(void)
85
//############################################################################
85
//############################################################################
86
{
86
{
87
    unsigned char tmp_pwm;
87
        unsigned char tmp_pwm;
88
    tmp_pwm = PWM;
88
        tmp_pwm = PWM;
89
    if(tmp_pwm > MaxPWM)    // Strombegrenzung
89
        if(tmp_pwm > MaxPWM)    // Strombegrenzung
90
        {
90
        {
91
        tmp_pwm = MaxPWM;
91
                tmp_pwm = MaxPWM;
92
        PORTC |= ROT;
92
                PORTC |= ROT;
93
        }
93
        }
94
    if(Strom > MAX_STROM)   // Strombegrenzung
94
        if(Strom > MAX_STROM)   // Strombegrenzung
95
        {
95
        {
96
        OCR1A = 0; OCR1B = 0; OCR2 = 0;
96
                OCR1A = 0; OCR1B = 0; OCR2 = 0;
97
        PORTD &= ~0x38;
97
                PORTD &= ~0x38;
98
        PORTC |= ROT;
98
                PORTC |= ROT;
99
        DebugOut.Analog[6]++;
99
                DebugOut.Analog[6]++;
100
        Strom--;
100
                Strom--;
101
        }
101
        }
102
    else
102
        else
103
        {
103
        {
104
        #ifdef  _32KHZ 
104
#ifdef  _32KHZ 
105
        OCR1A =  tmp_pwm; OCR1B =  tmp_pwm; OCR2  = tmp_pwm;
105
                OCR1A =  tmp_pwm; OCR1B =  tmp_pwm; OCR2  = tmp_pwm;
106
        #endif 
106
#endif 
107
 
107
 
108
        #ifdef  _16KHZ 
108
#ifdef  _16KHZ 
109
        //OCR1A = 2 * (int)tmp_pwm; OCR1B = 2 * (int)tmp_pwm; OCR2  = tmp_pwm;
109
                //OCR1A = 2 * (int)tmp_pwm; OCR1B = 2 * (int)tmp_pwm; OCR2  = tmp_pwm;
110
        OCR1A =  tmp_pwm; OCR1B =  tmp_pwm; OCR2  = tmp_pwm;
110
                OCR1A =  tmp_pwm; OCR1B =  tmp_pwm; OCR2  = tmp_pwm;
111
        #endif 
111
#endif 
112
        }
112
        }
113
}
113
}
114
 
114
 
115
void DebugAusgaben(void)
115
void DebugAusgaben(void)
116
{
116
{
117
    DebugOut.Analog[0] = Strom;
117
        DebugOut.Analog[0] = Strom;
118
    DebugOut.Analog[1] = Mittelstrom;
118
        DebugOut.Analog[1] = Mittelstrom;
119
    DebugOut.Analog[2] = SIO_Drehzahl;
119
        DebugOut.Analog[2] = SIO_Drehzahl;
120
    DebugOut.Analog[3] = PPM_Signal;
120
        DebugOut.Analog[3] = PPM_Signal;
121
    DebugOut.Analog[4] = OCR2;
121
        DebugOut.Analog[4] = OCR2;
122
//    DebugOut.Analog[5] = PWM;
122
        //    DebugOut.Analog[5] = PWM;
123
}
123
}
124
 
124
 
125
//############################################################################
125
//############################################################################
126
//
126
//
127
void PWM_Init(void)
127
void PWM_Init(void)
128
//############################################################################
128
//############################################################################
129
{
129
{
130
    PWM_OFF;
130
        PWM_OFF;
131
    TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (0 << WGM12) |
131
        TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (0 << WGM12) |
132
             (0 << WGM13) | (0<< ICES1) | (0 << ICNC1);
132
                (0 << WGM13) | (0<< ICES1) | (0 << ICNC1);
133
/*    TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (1 << WGM12) |
133
        /*    TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (1 << WGM12) |
134
             (0 << WGM13) | (0<< ICES1) | (0 << ICNC1);
134
        (0 << WGM13) | (0<< ICES1) | (0 << ICNC1);
135
*/
135
        */
136
}
136
}
137
 
137
 
138
//############################################################################
138
//############################################################################
139
//
139
//
140
void Wait(unsigned char dauer)
140
void Wait(unsigned char dauer)
141
//############################################################################
141
//############################################################################
142
{
142
{
143
    dauer = (unsigned char)TCNT0 + dauer;
143
        dauer = (unsigned char)TCNT0 + dauer;
144
    while((TCNT0 - dauer) & 0x80);
144
        while((TCNT0 - dauer) & 0x80);
145
}
145
}
146
 
146
 
147
void RotBlink(unsigned char anz)
147
void RotBlink(unsigned char anz)
148
{
148
{
149
sei(); // Interrupts ein
149
        sei(); // Interrupts ein
150
 while(anz--)
150
        while(anz--)
151
  {
151
        {
152
   PORTC |= ROT;
152
                PORTC |= ROT;
153
   Delay_ms(300);    
153
                Delay_ms(300);    
154
   PORTC &= ~ROT;
154
                PORTC &= ~ROT;
155
   Delay_ms(300);    
155
                Delay_ms(300);    
156
  }
156
        }
157
   Delay_ms(1000);    
157
        Delay_ms(1000);    
158
}
158
}
159
 
159
 
160
//############################################################################
160
//############################################################################
161
//
161
//
162
char Anwerfen(unsigned char pwm)
162
char Anwerfen(unsigned char pwm)
163
//############################################################################
163
//############################################################################
164
{
164
{
165
    unsigned long timer = 300,i;
165
        unsigned long timer = 300,i;
166
    DISABLE_SENSE_INT;
166
        DISABLE_SENSE_INT;
167
    PWM = 5;
167
        PWM = 5;
168
    SetPWM();
168
        SetPWM();
169
    Manuell();
169
        Manuell();
170
//    Delay_ms(200);
170
        //    Delay_ms(200);
171
                    MinUpmPulse = SetDelay(300);
171
        MinUpmPulse = SetDelay(300);
172
                    while(!CheckDelay(MinUpmPulse))
172
        while(!CheckDelay(MinUpmPulse))
173
                    {
173
        {
174
                     FastADConvert();
174
                FastADConvert();
175
                      if(Strom > 120)
175
                if(Strom > 120)
176
                      {
176
                {
177
                        STEUER_OFF; // Abschalten wegen Kurzschluss
177
                        STEUER_OFF; // Abschalten wegen Kurzschluss
178
                        RotBlink(10);
178
                        RotBlink(10);
179
                        return(0);
179
                        return(0);
180
                      }  
180
                }  
181
                    }
181
        }
182
    PWM = pwm;
182
        PWM = pwm;
183
    while(1)
183
        while(1)
184
        {
184
        {
185
        for(i=0;i<timer; i++)
185
                for(i=0;i<timer; i++)
186
            {
186
                {
187
            if(!UebertragungAbgeschlossen)  SendUart();
187
                        if(!UebertragungAbgeschlossen)  SendUart();
188
            else DatenUebertragung();
188
                        else DatenUebertragung();
189
            Wait(100);  // warten
189
                        Wait(100);  // warten
190
            }
190
                }
191
        DebugAusgaben();
191
                DebugAusgaben();
192
        FastADConvert();
192
                FastADConvert();
193
        if(Strom > 60)
193
                if(Strom > 60)
194
          {
194
                {
195
            STEUER_OFF; // Abschalten wegen Kurzschluss
195
                        STEUER_OFF; // Abschalten wegen Kurzschluss
196
            RotBlink(10);
196
                        RotBlink(10);
197
            return(0);
197
                        return(0);
198
          }  
198
                }  
199
         
199
 
200
        timer-= timer/15+1;
200
                timer-= timer/15+1;
201
        if(timer < 25) { if(TEST_MANUELL) timer = 25; else return(1); }
201
                if(timer < 25) { if(TEST_MANUELL) timer = 25; else return(1); }
202
        Manuell();
202
                Manuell();
203
        Phase++;
203
                Phase++;
204
        Phase %= 6;
204
                Phase %= 6;
205
        AdConvert();
205
                AdConvert();
206
        PWM = pwm;
206
                PWM = pwm;
207
        SetPWM();
207
                SetPWM();
208
        if(SENSE)
208
                if(SENSE)
209
            {
209
                {
210
            PORTD ^= GRUEN;
210
                        PORTD ^= GRUEN;
211
            }
211
                }
212
        }
212
        }
213
}
213
}
214
 
214
 
215
/*
215
/*
216
#define SENSE_A ADMUX = 0;
216
#define SENSE_A ADMUX = 0;
217
#define SENSE_B ADMUX = 1;
217
#define SENSE_B ADMUX = 1;
Line 225... Line 225...
225
 
225
 
226
 
226
 
227
#define TEST_STROMGRENZE 120
227
#define TEST_STROMGRENZE 120
228
unsigned char DelayM(unsigned int timer)
228
unsigned char DelayM(unsigned int timer)
229
{
229
{
230
 while(timer--)
230
        while(timer--)
231
  {
231
        {
232
   FastADConvert();
232
                FastADConvert();
233
   if(Strom > (TEST_STROMGRENZE + RuheStrom))
233
                if(Strom > (TEST_STROMGRENZE + RuheStrom))
234
       {
234
                {
235
        FETS_OFF;
235
                        FETS_OFF;
236
        return(1);
236
                        return(1);
237
       }
237
                }
238
  }
238
        }
239
 return(0);  
239
        return(0);  
240
}
240
}
241
 
241
 
242
unsigned char Delay(unsigned int timer)
242
unsigned char Delay(unsigned int timer)
243
{
243
{
244
 while(timer--)
244
        while(timer--)
245
  {
245
        {
246
//   if(SENSE_H) { PORTC |= ROT; } else { PORTC &= ~ROT;}
246
                //   if(SENSE_H) { PORTC |= ROT; } else { PORTC &= ~ROT;}
247
        asm volatile("");
247
                asm volatile("");
248
  }
248
        }
249
 return(0);  
249
        return(0);  
250
}
250
}
251
 
251
 
252
/*
252
/*
253
void ShowSense(void)
253
void ShowSense(void)
254
{
254
{
255
 if(SENSE_H) { PORTC |= ROT; } else { PORTC &= ~ROT;}
255
if(SENSE_H) { PORTC |= ROT; } else { PORTC &= ~ROT;}
256
 
256
 
257
}
257
}
258
*/
258
*/
259
#define HIGH_A_EIN PORTB |= 0x08
259
#define HIGH_A_EIN PORTB |= 0x08
260
#define HIGH_B_EIN PORTB |= 0x04
260
#define HIGH_B_EIN PORTB |= 0x04
Line 264... Line 264...
264
#define LOW_C_EIN  PORTD |= 0x20
264
#define LOW_C_EIN  PORTD |= 0x20
265
 
265
 
266
void MotorTon(void)
266
void MotorTon(void)
267
//############################################################################
267
//############################################################################
268
{
268
{
389
#define TONDAUER  40000    
389
#define TONDAUER  40000    
390
#define SOUND_E 1  // 1
390
#define SOUND_E 1  // 1
391
#define SOUND1_A 300
391
#define SOUND1_A 300
392
#define SOUND2_A 330
392
#define SOUND2_A 330
393
#define SOUND3_A 360
393
#define SOUND3_A 360
394
 
394
 
395
    for(i=0; i< (TONDAUER / SOUND2_A) ; i++)
395
        for(i=0; i< (TONDAUER / SOUND2_A) ; i++)
396
     {
396
        {
397
      HIGH_A_EIN; // Test A
397
                HIGH_A_EIN; // Test A
398
      Delay(SOUND_E);
398
                Delay(SOUND_E);
399
      if(MessAD(0) > 50) { MosfetOkay |= 0x01; } else { MosfetOkay &= ~0x01;};
399
                if(MessAD(0) > 50) { MosfetOkay |= 0x01; } else { MosfetOkay &= ~0x01;};
400
      PORTB = 0;
400
                PORTB = 0;
401
      Delay(SOUND1_A);
401
                Delay(SOUND1_A);
402
     }
402
        }
403
    FETS_OFF;
403
        FETS_OFF;
404
 
404
 
405
    LOW_A_EIN; // Low A ein
405
        LOW_A_EIN; // Low A ein
406
    LOW_C_EIN; // Low C ein
406
        LOW_C_EIN; // Low C ein
407
    for(i=0; i<(TONDAUER / SOUND1_A); i++)
407
        for(i=0; i<(TONDAUER / SOUND1_A); i++)
408
     {
408
        {
409
      HIGH_B_EIN; // Test B
409
                HIGH_B_EIN; // Test B
410
      Delay(SOUND_E);
410
                Delay(SOUND_E);
411
      if(MessAD(1) > 50) { MosfetOkay |= 0x02; } else { MosfetOkay &= ~0x02;};
411
                if(MessAD(1) > 50) { MosfetOkay |= 0x02; } else { MosfetOkay &= ~0x02;};
412
      PORTB = 0;
412
                PORTB = 0;
413
      Delay(SOUND1_A);
413
                Delay(SOUND1_A);
414
     }
414
        }
415
 
415
 
416
    FETS_OFF;
416
        FETS_OFF;
417
    LOW_A_EIN; // Low A ein
417
        LOW_A_EIN; // Low A ein
418
    LOW_B_EIN; // Low B ein
418
        LOW_B_EIN; // Low B ein
419
    for(i=0; i<(TONDAUER / SOUND3_A); i++)
419
        for(i=0; i<(TONDAUER / SOUND3_A); i++)
420
     {
420
        {
421
      HIGH_C_EIN; // Test C
421
                HIGH_C_EIN; // Test C
422
      Delay(SOUND_E);
422
                Delay(SOUND_E);
423
      if(MessAD(2) > 50) { MosfetOkay |= 0x04; } else { MosfetOkay &= ~0x04;};
423
                if(MessAD(2) > 50) { MosfetOkay |= 0x04; } else { MosfetOkay &= ~0x04;};
424
      PORTB = 0;
424
                PORTB = 0;
425
      Delay(SOUND2_A);
425
                Delay(SOUND2_A);
426
     }
426
        }
427
    FETS_OFF;
427
        FETS_OFF;
428
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
428
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
429
//+ Low-Mosfets auf Schalten testen
429
        //+ Low-Mosfets auf Schalten testen
430
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
430
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
431
//    SENSE_B;
431
        //    SENSE_B;
432
    LOW_A_EIN; // Low A ein
432
        LOW_A_EIN; // Low A ein
433
    for(i=0; i< (TONDAUER / SOUND2_A) ; i++)
433
        for(i=0; i< (TONDAUER / SOUND2_A) ; i++)
434
     {
434
        {
435
      HIGH_B_EIN; // Test B
435
                HIGH_B_EIN; // Test B
436
      Delay(SOUND_E);
436
                Delay(SOUND_E);
437
      if(MessAD(0) > 128) { MosfetOkay &= ~0x08;} else { MosfetOkay |= 0x08;};
437
                if(MessAD(0) > 128) { MosfetOkay &= ~0x08;} else { MosfetOkay |= 0x08;};
438
      PORTB = 0;
438
                PORTB = 0;
439
      Delay(SOUND2_A);
439
                Delay(SOUND2_A);
440
     }
440
        }
441
 
441
 
442
//++++++++++++++++++++++++++++++++++++
442
        //++++++++++++++++++++++++++++++++++++
443
    LOW_C_EIN; // Low C ein
443
        LOW_C_EIN; // Low C ein
444
    for(i=0; i<(TONDAUER / SOUND1_A); i++)
444
        for(i=0; i<(TONDAUER / SOUND1_A); i++)
445
     {
445
        {
446
      HIGH_B_EIN; // Test B
446
                HIGH_B_EIN; // Test B
447
      Delay(SOUND_E);
447
                Delay(SOUND_E);
448
      if(MessAD(2) > 128) { MosfetOkay &= ~0x20;} else { MosfetOkay |= 0x20;};
448
                if(MessAD(2) > 128) { MosfetOkay &= ~0x20;} else { MosfetOkay |= 0x20;};
449
      PORTB = 0;
449
                PORTB = 0;
450
      Delay(SOUND3_A);
450
                Delay(SOUND3_A);
451
     }
451
        }
452
    FETS_OFF;
452
        FETS_OFF;
453
//++++++++++++++++++++++++++++++++++++
453
        //++++++++++++++++++++++++++++++++++++
454
    FETS_OFF;
454
        FETS_OFF;
455
    LOW_B_EIN; // Low B ein
455
        LOW_B_EIN; // Low B ein
456
    for(i=0; i<(TONDAUER / SOUND3_A); i++)
456
        for(i=0; i<(TONDAUER / SOUND3_A); i++)
457
     {
457
        {
458
      HIGH_C_EIN; // Test C
458
                HIGH_C_EIN; // Test C
459
      Delay(SOUND_E);
459
                Delay(SOUND_E);
460
      if(MessAD(1) > 128) { MosfetOkay &= ~0x10;} else { MosfetOkay |= 0x10;};
460
                if(MessAD(1) > 128) { MosfetOkay &= ~0x10;} else { MosfetOkay |= 0x10;};
461
      PORTB = 0;
461
                PORTB = 0;
462
      Delay(SOUND3_A);
462
                Delay(SOUND3_A);
463
     }
463
        }
464
    FETS_OFF;
464
        FETS_OFF;
465
//++++++++++++++++++++++++++++++++++++
465
        //++++++++++++++++++++++++++++++++++++
466
 
466
 
467
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
467
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
468
    sei();//Globale Interrupts Einschalten
468
        sei();//Globale Interrupts Einschalten
469
//    Delay_ms(250 * MotorAdresse);    
469
        //    Delay_ms(250 * MotorAdresse);    
470
/*
470
        /*
471
    LOW_A_EIN; // Low B ein
471
        LOW_A_EIN; // Low B ein
472
#define SOUND8_A 650
472
        #define SOUND8_A 650
473
    for(i=0; i<(TONDAUER / SOUND8_A); i++)
473
        for(i=0; i<(TONDAUER / SOUND8_A); i++)
474
     {
474
        {
475
      HIGH_B_EIN; // Test B
475
        HIGH_B_EIN; // Test B
476
      Delay(SOUND_E);
476
        Delay(SOUND_E);
477
      PORTB = 0;
477
        PORTB = 0;
478
      Delay(SOUND8_A);
478
        Delay(SOUND8_A);
479
     }
479
        }
480
*/
480
        */
481
 Delay_ms(300 * (3-ADR_TAB[MotorAdresse]));    
481
        Delay_ms(300 * (3-ADR_TAB[MotorAdresse]));    
482
 if(!(MosfetOkay & 0x01))  { anz = 1; UDR='A'; } else
482
        if(!(MosfetOkay & 0x01))  { anz = 1; UDR='A'; } else
483
 if(!(MosfetOkay & 0x02))  { anz = 2; UDR='B'; } else
483
                if(!(MosfetOkay & 0x02))  { anz = 2; UDR='B'; } else
484
 if(!(MosfetOkay & 0x04))  { anz = 3; UDR='C'; } else
484
                        if(!(MosfetOkay & 0x04))  { anz = 3; UDR='C'; } else
485
 if(!(MosfetOkay & 0x08))  { anz = 4; UDR='a'; } else
485
                                if(!(MosfetOkay & 0x08))  { anz = 4; UDR='a'; } else
486
 if(!(MosfetOkay & 0x10))  { anz = 5; UDR='b'; } else
486
                                        if(!(MosfetOkay & 0x10))  { anz = 5; UDR='b'; } else
487
 if(!(MosfetOkay & 0x20))  { anz = 6; UDR='c'; }  
487
                                                if(!(MosfetOkay & 0x20))  { anz = 6; UDR='c'; }  
488
 
488
 
489
// if(anz) Delay_ms(1000); 
489
                                                // if(anz) Delay_ms(1000); 
490
 if(anz) while(1) RotBlink(anz);  // bei Kurzschluss nicht starten
490
                                                if(anz) while(1) RotBlink(anz);  // bei Kurzschluss nicht starten
491
 RotBlink(anz);
491
                                                RotBlink(anz);
492
 uart_putchar('.');
492
                                                uart_putchar('.');
493
}
493
}
494
 
494
 
495
//############################################################################
495
//############################################################################
496
//
496
//
497
unsigned char SollwertErmittlung(void)
497
unsigned char SollwertErmittlung(void)
498
//############################################################################
498
//############################################################################
499
{
499
{
500
    static unsigned int sollwert = 0;
500
        static unsigned int sollwert = 0;
501
    unsigned int ppm;
501
        unsigned int ppm;
502
    if(!I2C_Timeout)   // bei Erreichen von 0 ist der Wert ungültig
502
        if(!I2C_Timeout)   // bei Erreichen von 0 ist der Wert ungültig
503
        {
503
        {
504
        if(SIO_Timeout)  // es gibt gültige SIO-Daten
504
                if(SIO_Timeout)  // es gibt gültige SIO-Daten
505
            {
505
                {
506
             sollwert =  (MAX_PWM * (unsigned int) SIO_Sollwert) / 200;  // skalieren auf 0-200 = 0-255
506
                        sollwert =  (MAX_PWM * (unsigned int) SIO_Sollwert) / 200;  // skalieren auf 0-200 = 0-255
507
             PPM_Betrieb = 0;
507
                        PPM_Betrieb = 0;
508
             ICP_INT_DISABLE;
508
                        ICP_INT_DISABLE;
509
             PORTC &= ~ROT;
509
                        PORTC &= ~ROT;
510
            }
510
                }
511
        else
511
                else
512
            if(anz_ppm_werte > 20)  // es gibt gültige PPM-Daten
512
                        if(anz_ppm_werte > 20)  // es gibt gültige PPM-Daten
513
                {
513
                        {
514
                PPM_Betrieb = 1;
514
                                PPM_Betrieb = 1;
515
                ppm = PPM_Signal;
515
                                ppm = PPM_Signal;
516
                if(ppm > 300) ppm =   0;  // ungültiges Signal
516
                                if(ppm > 300) ppm =   0;  // ungültiges Signal
517
                if(ppm > 200) ppm = 200;
517
                                if(ppm > 200) ppm = 200;
518
                if(ppm <= MIN_PPM) sollwert = 0;
518
                                if(ppm <= MIN_PPM) sollwert = 0;
519
                else
519
                                else
520
                    {
520
                                {
521
                    sollwert = (int) MIN_PWM + ((MAX_PWM - MIN_PWM) * (ppm - MIN_PPM)) / (190 - MIN_PPM);
521
                                        sollwert = (int) MIN_PWM + ((MAX_PWM - MIN_PWM) * (ppm - MIN_PPM)) / (190 - MIN_PPM);
522
                    }
522
                                }
523
                PORTC &= ~ROT;
523
                                PORTC &= ~ROT;
524
                }
524
                        }
525
            else   // Kein gültiger Sollwert
525
                        else   // Kein gültiger Sollwert
526
                {
526
                        {
527
                 if(!TEST_SCHUB) { if(sollwert) sollwert--; }  
527
                                if(!TEST_SCHUB) { if(sollwert) sollwert--; }  
528
                 PORTC |= ROT;
528
                                PORTC |= ROT;
529
                }
529
                        }
530
        }
530
        }
531
    else // I2C-Daten sind gültig
531
        else // I2C-Daten sind gültig
532
        {
532
        {
533
        sollwert = I2C_RXBuffer;
533
                sollwert = I2C_RXBuffer;
534
        PPM_Betrieb = 0;
534
                PPM_Betrieb = 0;
535
        PORTC &= ~ROT;
535
                PORTC &= ~ROT;
536
        ICP_INT_DISABLE;
536
                ICP_INT_DISABLE;
537
        }
537
        }
538
    if(sollwert > MAX_PWM) sollwert = MAX_PWM;
538
        if(sollwert > MAX_PWM) sollwert = MAX_PWM;
539
    return(sollwert);
539
        return(sollwert);
540
}
540
}
541
 
541
 
542
 
542
 
543
 
543
 
544
//############################################################################
544
//############################################################################
545
//Hauptprogramm
545
//Hauptprogramm
546
int main (void)
546
int main (void)
547
//############################################################################
547
//############################################################################
548
{
548
{
549
    char altPhase = 0;
549
        char altPhase = 0;
550
    int test = 0;
550
        int test = 0;
551
    unsigned int Blink,TestschubTimer;
551
        unsigned int Blink,TestschubTimer;
552
    unsigned int Blink2,MittelstromTimer,DrehzahlMessTimer,MotorGestopptTimer;
552
        unsigned int Blink2,MittelstromTimer,DrehzahlMessTimer,MotorGestopptTimer;
553
 
553
 
554
    DDRC  = 0x08;
554
        DDRC  = 0x08;
555
    PORTC = 0x08;
555
        PORTC = 0x08;
556
    DDRD  = 0x3A;
556
        DDRD  = 0x3A;
557
    PORTD = 0x00;
557
        PORTD = 0x00;
558
    DDRB  = 0x0E;
558
        DDRB  = 0x0E;
559
    PORTB = 0x31;
559
        PORTB = 0x31;
560
       
560
 
561
#if (MOTORADRESSE == 0)
561
#if (MOTORADRESSE == 0)
562
    PORTB |= (ADR1 + ADR2);   // Pullups für Adresswahl
562
        PORTB |= (ADR1 + ADR2);   // Pullups für Adresswahl
563
    for(test=0;test<500;test++);
563
        for(test=0;test<500;test++);
564
    if(PINB & ADR1)
564
        if(PINB & ADR1)
565
         {
565
        {
566
           if (PINB & ADR2) MotorAdresse = 1;
566
                if (PINB & ADR2) MotorAdresse = 1;
567
            else MotorAdresse = 2;
567
                else MotorAdresse = 2;
568
         }
568
        }
569
         else
569
        else
570
         {
570
        {
571
           if (PINB & ADR2) MotorAdresse = 3;
571
                if (PINB & ADR2) MotorAdresse = 3;
572
            else MotorAdresse = 4;
572
                else MotorAdresse = 4;
573
         }
573
        }
574
    HwVersion = 11;
574
        HwVersion = 11;
575
#else
575
#else
576
    MotorAdresse  = MOTORADRESSE;
576
        MotorAdresse  = MOTORADRESSE;
577
    HwVersion = 10;
577
        HwVersion = 10;
578
#endif
578
#endif
710
 
710
 
711
#if TEST_SCHUB == 1
711
#if TEST_SCHUB == 1
712
           {
712
                        {
713
            if(CheckDelay(TestschubTimer))  
713
                                if(CheckDelay(TestschubTimer))  
714
                {
714
                                {
715
                TestschubTimer = SetDelay(1500);
715
                                        TestschubTimer = SetDelay(1500);
716
                    switch(test)
716
                                        switch(test)
717
                        {
717
                                        {
718
                        case 0: PWM = 50; test++; break;
718
                                        case 0: PWM = 50; test++; break;
719
                        case 1: PWM = 130; test++; break;
719
                                        case 1: PWM = 130; test++; break;
720
                        case 2: PWM = 60;  test++; break;
720
                                        case 2: PWM = 60;  test++; break;
721
                        case 3: PWM = 140; test++; break;
721
                                        case 3: PWM = 140; test++; break;
722
                        case 4: PWM = 150; test = 0; break;
722
                                        case 4: PWM = 150; test = 0; break;
723
                        default: test = 0;
723
                                        default: test = 0;
724
                        }
724
                                        }
725
                }
725
                                }
726
            }  
726
                        }  
727
#endif
727
#endif
728
          // Motor Stehen geblieben
728
                        // Motor Stehen geblieben
729
            if((CheckDelay(MinUpmPulse) && SIO_Drehzahl == 0) || MotorAnwerfen)
729
                        if((CheckDelay(MinUpmPulse) && SIO_Drehzahl == 0) || MotorAnwerfen)
730
                {
730
                        {
731
                MotorGestoppt = 1;    
731
                                MotorGestoppt = 1;    
732
                DISABLE_SENSE_INT;
732
                                DISABLE_SENSE_INT;
733
                MinUpmPulse = SetDelay(100);        
733
                                MinUpmPulse = SetDelay(100);        
734
                if(MotorAnwerfen)
734
                                if(MotorAnwerfen)
735
                  {
735
                                {
736
                   PORTC &= ~ROT;
736
                                        PORTC &= ~ROT;
737
                   Strom_max = 0;
737
                                        Strom_max = 0;
738
                   MotorAnwerfen = 0;
738
                                        MotorAnwerfen = 0;
739
                   if(Anwerfen(10))
739
                                        if(Anwerfen(10))
740
                   {  
740
                                        {  
741
                    GRN_ON;
741
                                                GRN_ON;
742
                    MotorGestoppt = 0;    
742
                                                MotorGestoppt = 0;    
743
                    Phase--;
743
                                                Phase--;
744
                    PWM = 1;
744
                                                PWM = 1;
745
                    SetPWM();
745
                                                SetPWM();
746
                    SENSE_TOGGLE_INT;
746
                                                SENSE_TOGGLE_INT;
747
                    ENABLE_SENSE_INT;
747
                                                ENABLE_SENSE_INT;
748
                    MinUpmPulse = SetDelay(20);
748
                                                MinUpmPulse = SetDelay(20);
749
                    while(!CheckDelay(MinUpmPulse)); // kurz Synchronisieren
749
                                                while(!CheckDelay(MinUpmPulse)); // kurz Synchronisieren
750
                    PWM = 15;
750
                                                PWM = 15;
751
                    SetPWM();
751
                                                SetPWM();
752
                    MinUpmPulse = SetDelay(300);
752
                                                MinUpmPulse = SetDelay(300);
753
                    while(!CheckDelay(MinUpmPulse)) // kurz Durchstarten
753
                                                while(!CheckDelay(MinUpmPulse)) // kurz Durchstarten
754
                    {
754
                                                {
755
                      if(Strom > LIMIT_STROM/2)
755
                                                        if(Strom > LIMIT_STROM/2)
756
                      {
756
                                                        {
757
                        STEUER_OFF; // Abschalten wegen Kurzschluss
757
                                                                STEUER_OFF; // Abschalten wegen Kurzschluss
758
                        RotBlink(10);
758
                                                                RotBlink(10);
759
                        MotorAnwerfen = 1;
759
                                                                MotorAnwerfen = 1;
760
                      }  
760
                                                        }  
761
                    }
761
                                                }
762
                                    // Drehzahlmessung wieder aufsetzen
762
                                                // Drehzahlmessung wieder aufsetzen
763
                    DrehzahlMessTimer = SetDelay(50);
763
                                                DrehzahlMessTimer = SetDelay(50);
764
                    altPhase = 7;
764
                                                altPhase = 7;
765
                   }
765
                                        }
766
                   else if(SollwertErmittlung()) MotorAnwerfen = 1;
766
                                        else if(SollwertErmittlung()) MotorAnwerfen = 1;
767
                  }
767
                                }
768
                }
768
                        }
769
            } // ZeitFuerBerechnungen
769
                } // ZeitFuerBerechnungen
770
        } // while(1) - Hauptschleife
770
        } // while(1) - Hauptschleife
771
}
771
}
772
 
772