WebSVN - BL-Ctrl - Diff - Rev 72 and 73 - /branches/V0.42_addr9-12_fix

 // +     from this software without specific prior written permission.
 // +   * The use of this project (hardware, software, binary files, sources and documentation) is only permittet
 // +     for non-commercial use (directly or indirectly)
 // +     Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted
 // +     with our written permission
-// +   * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be
+// +   * If sources or documentations are redistributet on other webpages, our webpage (http://www.MikroKopter.de) must be
 // +     clearly linked as origin
 // +   * porting to systems other than hardware from www.mikrokopter.de is not allowed
 // +  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 // +  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // +  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 unsigned int  CntKommutierungen = 0;
 unsigned int  SIO_Drehzahl = 0;
 unsigned char ZeitZumAdWandeln = 1;
 unsigned char MotorAdresse = 1;
 unsigned char PPM_Betrieb = 1;
+unsigned char HwVersion;
+unsigned char IntRef = 0;
+unsigned int MinUpmPulse;
 //############################################################################
 //
 void SetPWM(void)
 //############################################################################
+{
         tmp_pwm = MaxPWM;
         PORTC |= ROT;
+        }
     if(Strom > MAX_STROM)   // Strombegrenzung
+        {
-        OCR1A = 0; OCR1B = 0; OCR2  = 0;
+        OCR1A = 0; OCR1B = 0; OCR2 = 0;
+        PORTD &= ~0x38;
         PORTC |= ROT;
+        DebugOut.Analog[6]++;
         Strom--;
+        }
     else
+        {
         #ifdef  _32KHZ
         OCR1A =  tmp_pwm; OCR1B =  tmp_pwm; OCR2  = tmp_pwm;
         #endif
+        }
+}
+void DebugAusgaben(void)
+{
+    DebugOut.Analog[0] = Strom;
+    DebugOut.Analog[1] = Mittelstrom;
+    DebugOut.Analog[2] = SIO_Drehzahl;
+    DebugOut.Analog[3] = PPM_Signal;
+    DebugOut.Analog[4] = OCR2;
+//    DebugOut.Analog[5] = PWM;
+}
 //############################################################################
 //
 void PWM_Init(void)
 //############################################################################
+{
     dauer = (unsigned char)TCNT0 + dauer;
     while((TCNT0 - dauer) & 0x80);
+}
+void RotBlink(unsigned char anz)
+{
+sei(); // Interrupts ein
+ while(anz--)
+  {
+   PORTC |= ROT;
+   Delay_ms(300);
+   PORTC &= ~ROT;
+   Delay_ms(300);
+  }
+   Delay_ms(1000);
+}
 //############################################################################
 //
-void Anwerfen(unsigned char pwm)
+char Anwerfen(unsigned char pwm)
 //############################################################################
+{
     unsigned long timer = 300,i;
     DISABLE_SENSE_INT;
     PWM = 5;
     SetPWM();
     Manuell();
+//    Delay_ms(200);
+                    MinUpmPulse = SetDelay(300);
+                    while(!CheckDelay(MinUpmPulse))
+                    {
+                     FastADConvert();
+                      if(Strom > 120)
+                      {
+                        STEUER_OFF; // Abschalten wegen Kurzschluss
+                        RotBlink(10);
+                        return(0);
+                      }
     Delay_ms(200);
     PWM = pwm;
     while(1)
+        {
         for(i=0;i<timer; i++)
+            {
             if(!UebertragungAbgeschlossen)  SendUart();
             else DatenUebertragung();
             Wait(100);  // warten
+            }
+        DebugAusgaben();
+        FastADConvert();
+        if(Strom > 60)
+          {
+            STEUER_OFF; // Abschalten wegen Kurzschluss
+            RotBlink(10);
+            return(0);
+          }
         timer-= timer/15+1;
-        if(timer < 25) { if(TEST_MANUELL) timer = 25; else return; }
         if(timer < 25) { if(TEST_MANUELL) timer = 25; else return(1); }
         Manuell();
         Phase++;
         Phase %= 6;
         AdConvert();
 #define SENSE               ((ACSR & 0x10))
 #define SENSE_L             (!(ACSR & 0x20))
 #define SENSE_H             ((ACSR & 0x20))
 */
-void RotBlink(unsigned char anz)
-{
-sei(); // Interrupts ein
- while(anz--)
-  {
-   PORTC |= ROT;
-   Delay_ms(300);
-   PORTC &= ~ROT;
-   Delay_ms(300);
-  }
-   Delay_ms(1000);
 #define TEST_STROMGRENZE 120
 unsigned char DelayM(unsigned int timer)
   FETS_OFF;
   Delay(5);
   HIGH_A_EIN;
   DelayM(1);
   FETS_OFF;
-  if(Strom > grenze + RuheStrom) {anz = 4; uart_putchar('4'); break;}
+  if(Strom > grenze + RuheStrom) {anz = 4; uart_putchar('4'); FETS_OFF; break;}
   Delay(5);
+ }
  Delay(10000);
   FETS_OFF;
   Delay(5);
   HIGH_B_EIN;
   DelayM(1);
   FETS_OFF;
-  if(Strom > grenze + RuheStrom) {anz = 5; uart_putchar('5'); break;}
+  if(Strom > grenze + RuheStrom) {anz = 5; uart_putchar('5'); FETS_OFF;break;}
   Delay(5);
+ }
  Strom = 0;
   FETS_OFF;
   Delay(5);
   HIGH_C_EIN;
   DelayM(1);
   FETS_OFF;
-  if(Strom > grenze + RuheStrom) {anz = 6; uart_putchar('6'); break;}
+  if(Strom > grenze + RuheStrom) {anz = 6; uart_putchar('6'); FETS_OFF; break;}
   Delay(5);
+ }
+ if(anz) while(1) RotBlink(anz);  // bei Kurzschluss nicht starten
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //+ High-Mosfets auf Schalten testen
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     SENSE_A;
  if(!(MosfetOkay & 0x04))  { anz = 3; UDR='C'; } else
  if(!(MosfetOkay & 0x08))  { anz = 4; UDR='a'; } else
  if(!(MosfetOkay & 0x10))  { anz = 5; UDR='b'; } else
  if(!(MosfetOkay & 0x20))  { anz = 6; UDR='c'; }
- if(anz) Delay_ms(1000);
+// if(anz) Delay_ms(1000);
  if(anz) while(1) RotBlink(anz);  // bei Kurzschluss nicht starten
  RotBlink(anz);
  uart_putchar('.');
+}
+        }
     if(sollwert > MAX_PWM) sollwert = MAX_PWM;
     return(sollwert);
+}
-void DebugAusgaben(void)
-{
-    DebugOut.Analog[0] = Strom;
-    DebugOut.Analog[1] = Mittelstrom;
-    DebugOut.Analog[2] = SIO_Drehzahl;
-    DebugOut.Analog[3] = PPM_Signal;
-    DebugOut.Analog[4] = OCR2;
 //############################################################################
 //Hauptprogramm
 int main (void)
 //############################################################################
 {
     char altPhase = 0;
     int test = 0;
-    unsigned int MinUpmPulse,Blink,TestschubTimer;
+    unsigned int Blink,TestschubTimer;
     unsigned int Blink2,MittelstromTimer,DrehzahlMessTimer,MotorGestopptTimer;
     DDRC  = 0x08;
     PORTC = 0x08;
-    DDRD  = 0xBA;
+    DDRD  = 0x3A;
     PORTD = 0x00;
     DDRB  = 0x0E;
     PORTB = 0x31;
 #if (MOTORADRESSE == 0)
     PORTB |= (ADR1 + ADR2);   // Pullups für Adresswahl
     for(test=0;test<500;test++);
-    if (PINB & ADR1)
+    if(PINB & ADR1)
+         {
            if (PINB & ADR2) MotorAdresse = 1;
             else MotorAdresse = 2;
+         }
+         else
          else
            if (PINB & ADR2) MotorAdresse = 3;
+            else MotorAdresse = 4;
            if (PINB & ADR2) MotorAdresse = 3;
-            else MotorAdresse = 4;
+    HwVersion = 11;
+#else
     MotorAdresse  = MOTORADRESSE;
-#else
+    HwVersion = 10;
-    MotorAdresse  = MOTORADRESSE;
+#endif
-#endif
+    if(PIND & 0x80) {HwVersion = 12; IntRef = 0xc0;}
     TestschubTimer    = SetDelay(1006);
     while(!CheckDelay(MinUpmPulse))
+    {
      if(SollwertErmittlung()) break;
+    }
-    ;
-    PORTD |= GRUEN;
+    GRN_ON;
     PWM = 0;
     SetPWM();
             if(MotorGestoppt) MotorAnwerfen = 1;        // Startversuch
             MotorGestopptTimer = SetDelay(1500);
+            }
-        if(MotorGestoppt && !TEST_SCHUB) PWM = 0;
-if(SIO_Drehzahl > 120 && PWM > )
+        if(MotorGestoppt && !TEST_SCHUB) PWM = 0;
         SetPWM();
         // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
         if(!ZeitFuerBerechnungen++)
             {
+            if(MotorGestoppt)
+             {
+              GRN_ON;
+              FastADConvert();
             if(MotorGestoppt) PORTD |= GRUEN; //else PORTD &= ~GRUEN;
             if(SIO_DEBUG)
+                {
                 DebugAusgaben();  // welche Werte sollen angezeigt werden?
                 if(!UebertragungAbgeschlossen)  SendUart();
             if(CheckDelay(MittelstromTimer))
+                {
                 MittelstromTimer = SetDelay(50); // alle 50ms
                 if(Mittelstrom <  Strom) Mittelstrom++;// Mittelwert des Stroms bilden
                 else if(Mittelstrom >  Strom) Mittelstrom--;
-                if((Strom > MAX_STROM)) MaxPWM -= MaxPWM / 32;
+                if(Strom > MAX_STROM) MaxPWM -= MaxPWM / 32;
                 if((Mittelstrom > LIMIT_STROM))// Strom am Limit?
+                    {
                     if(MaxPWM) MaxPWM--;// dann die Maximale PWM herunterfahren
                     PORTC |= ROT;
+                    }
                 SIO_Drehzahl = CntKommutierungen;//(6 * CntKommutierungen) / (POLANZAHL / 2);
                 CntKommutierungen = 0;
                // if(PPM_Timeout == 0) // keine PPM-Signale
                 ZeitZumAdWandeln = 1;
+                }
-          if(TEST_SCHUB)
+#if TEST_SCHUB == 1
+           {
             if(CheckDelay(TestschubTimer))
+                {
                 TestschubTimer = SetDelay(1500);
                     switch(test)
                         case 4: PWM = 150; test = 0; break;
                         default: test = 0;
+                        }
+                }
+            }
+#endif
           // Motor Stehen geblieben
             if((CheckDelay(MinUpmPulse) && SIO_Drehzahl == 0) || MotorAnwerfen)
+                {
                 MotorGestoppt = 1;
                 DISABLE_SENSE_INT;
                 MinUpmPulse = SetDelay(100);
                 if(MotorAnwerfen)
-                    {
+                  {
-                    PORTC &= ~ROT;
+                   PORTC &= ~ROT;
+                   Strom_max = 0;
-                    MotorAnwerfen = 0;
+                   MotorAnwerfen = 0;
-                    Anwerfen(10);
+                   if(Anwerfen(10))
+                   {
-                    PORTD |= GRUEN;
+                    GRN_ON;
                     MotorGestoppt = 0;
                     Phase--;
                     PWM = 1;
                     SetPWM();
                     SENSE_TOGGLE_INT;
                     ENABLE_SENSE_INT;
-                    CntKommutierungen = 0;
-                    MinUpmPulse = SetDelay(10); //20
+                    MinUpmPulse = SetDelay(20);
                     while(!CheckDelay(MinUpmPulse)); // kurz Synchronisieren
                     PWM = 15;
                     SetPWM();
                     MinUpmPulse = SetDelay(300);
-                    while(!CheckDelay(MinUpmPulse)); // kurz Durchstarten
+                    while(!CheckDelay(MinUpmPulse)) // kurz Durchstarten
+                    {
+                      if(Strom > LIMIT_STROM/2)
+                      {
+                        STEUER_OFF; // Abschalten wegen Kurzschluss
+                        RotBlink(10);
+                        MotorAnwerfen = 1;
+                      }
+                    }
                                     // Drehzahlmessung wieder aufsetzen
                     DrehzahlMessTimer = SetDelay(50);
                     altPhase = 7;
-                    }
+                   }
+                   else if(SollwertErmittlung()) MotorAnwerfen = 1;
+                  }
+                }
             } // ZeitFuerBerechnungen
         } // while(1) - Hauptschleife
+}

Subversion Repositories BL-Ctrl

(root)/branches/V0.42_addr9-12_fix_ligi/main.c @ 91 - Rev 72 → 73