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 
}
Line 114... Line 114...
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;
Line 123... Line 123...
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);
Line 135... Line 135...
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 
{
Line 143... Line 143...
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;
Line 155... Line 155...
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)
Line 209... Line 209...
209 
            {
 209 
                {
210 
            PORTD ^= GRUEN;
 210 
                        PORTD ^= GRUEN;
211 
            }
 211 
                }
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 
        }
Line 239... Line 239...
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("");
Line 248... Line 248...
248 
  }
 248 
        }
249 
 return(0);  
 249 
        return(0);  
250 
}
 250 
}
251 
 
 251 
 
Line 252... Line 252...
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;}
Line 264... Line 264...
264 
#define LOW_C_EIN  PORTD |= 0x20
 264 
#define LOW_C_EIN  PORTD |= 0x20
Line 265... Line 265...
265 
 
 265 
 
266 
void MotorTon(void)
 266 
void MotorTon(void)
267 
//############################################################################
 267 
//############################################################################
388 
    Strom = 0;
 388 
        Strom = 0;
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
Line 393... Line 393...
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);
Line 492... Line 492...
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 
        }
Line 538... Line 538...
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;
Line 704... Line 704...
704 
                DrehzahlMessTimer = SetDelay(10);
 704 
                                DrehzahlMessTimer = SetDelay(10);
705 
                SIO_Drehzahl = CntKommutierungen;//(6 * CntKommutierungen) / (POLANZAHL / 2);
 705 
                                SIO_Drehzahl = CntKommutierungen;//(6 * CntKommutierungen) / (POLANZAHL / 2);
706 
                CntKommutierungen = 0;
 706 
                                CntKommutierungen = 0;
707 
               // if(PPM_Timeout == 0) // keine PPM-Signale
 707 
                                // if(PPM_Timeout == 0) // keine PPM-Signale
708 
                ZeitZumAdWandeln = 1;
 708 
                                ZeitZumAdWandeln = 1;
709 
                }
 709 
                        }
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;