main.c

遥控电子玩具电动机的调节转动的速度文件包

     {
      HIGH_C_EIN; // Test C
      Delay(SOUND_E);
      if(MessAD(2) > 50) { MosfetOkay |= 0x04; } else { MosfetOkay &= ~0x04;};
      PORTB = 0;
      Delay(SOUND2_A);
     }
    FETS_OFF;
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+ 低端功率管开关测试
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    SENSE_B;
    LOW_A_EIN; // Low A ein
    for(i=0; i< (TONDAUER / SOUND2_A) ; i++)
     {
      HIGH_B_EIN; // Test B
      Delay(SOUND_E);
      if(MessAD(0) > 50) { MosfetOkay &= ~0x08;} else { MosfetOkay |= 0x08;};
      PORTB = 0;
      Delay(SOUND2_A);
     }

//++++++++++++++++++++++++++++++++++++
    LOW_C_EIN; // Low C ein
    for(i=0; i<(TONDAUER / SOUND1_A); i++)
     {
      HIGH_B_EIN; // Test B
      Delay(SOUND_E);
      if(MessAD(2) > 50) { MosfetOkay &= ~0x20;} else { MosfetOkay |= 0x20;};
      PORTB = 0;
      Delay(SOUND3_A);
     }
    FETS_OFF;
//++++++++++++++++++++++++++++++++++++
    FETS_OFF;
    LOW_B_EIN; // Low B ein
    for(i=0; i<(TONDAUER / SOUND3_A); i++)
     {
      HIGH_C_EIN; // Test C
      Delay(SOUND_E);
      if(MessAD(1) > 50) { MosfetOkay &= ~0x10;} else { MosfetOkay |= 0x10;};
      PORTB = 0;
      Delay(SOUND3_A);
     }
    FETS_OFF;

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 sei();
 Delay_ms(300 * (4-ADR_TAB[MotorAdresse]));    
 if(!(MosfetOkay & 0x01))  { anz = 1; UDR='A'; } else
 if(!(MosfetOkay & 0x02))  { anz = 2; UDR='B'; } else
 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); 

 RotBlink(anz);
 uart_putchar('.');
}

//############################################################################
//
unsigned char SollwertErmittlung(void)
//############################################################################
{
    static unsigned int sollwert = 0;
    unsigned int ppm;
    if(!I2C_Timeout)   // 等待过零点
        {
        if(SIO_Timeout)  
            {
             sollwert =  (MAX_PWM * (unsigned int) SIO_Sollwert) / 200;  // skalieren auf 0-200 = 0-255
             PPM_Betrieb = 0;
             ICP_INT_DISABLE;
             PORTC &= ~ROT;
            }
        else
            if(anz_ppm_werte > 20)  //PPM
                {
                PPM_Betrieb = 1;
                ppm = PPM_Signal;
                if(ppm > 300) ppm =   0;  
                if(ppm > 200) ppm = 200;
                if(ppm <= MIN_PPM) sollwert = 0;
                else 
                    {
                    sollwert = (int) MIN_PWM + ((MAX_PWM - MIN_PWM) * (ppm - MIN_PPM)) / (190 - MIN_PPM);
                    }
                PORTC &= ~ROT;
                }
            else   
                {
                 if(!TEST_SCHUB) { if(sollwert) sollwert--; }   
                 PORTC |= ROT; 
                }
        }
    else 
        {
        sollwert = I2C_RXBuffer; 
        PPM_Betrieb = 0;
        PORTC &= ~ROT;
        ICP_INT_DISABLE;
        }
    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;
}


//############################################################################
//Hauptprogramm
int main (void)
//############################################################################
{
    char altPhase = 0;
    int test = 0;
    unsigned int MinUpmPulse,Blink,TestschubTimer;
    unsigned int Blink2,MittelstromTimer,DrehzahlMessTimer,MotorGestopptTimer;

    DDRC  = 0x08;
    PORTC = 0x08;
    DDRD  = 0xBA;
    PORTD = 0x00;
    DDRB  = 0x0E;
    PORTB = 0x31;
	
#if (MOTORADRESSE == 0)
    PORTB |= (ADR1 + ADR2);   // 地址码
    for(test=0;test<500;test++);
    if (PINB & ADR1)
	 {
	   if (PINB & ADR2) MotorAdresse = 1;
	    else MotorAdresse = 2;
	 }
	 else
	 {
	   if (PINB & ADR2) MotorAdresse = 3;
	    else MotorAdresse = 4;
	 }
#else
    MotorAdresse  = MOTORADRESSE;
#endif
    
    UART_Init();
    Timer0_Init();
    sei();//全局中断打开
    
    
    PWM_Init();	

    InitIC2_Slave(0x50);			    
    InitPPM();

    Blink             = SetDelay(101);    
    Blink2            = SetDelay(102);
    MinUpmPulse       = SetDelay(103);
    MittelstromTimer  = SetDelay(254);
    DrehzahlMessTimer = SetDelay(1005);
    TestschubTimer    = SetDelay(1006);
    while(!CheckDelay(MinUpmPulse))
    {
     if(SollwertErmittlung()) break;
    }
    ;
    PORTD |= GRUEN;
    PWM = 0;

    SetPWM();

    SFIOR = 0x08;  // Analog Comperator ein
    ADMUX = 1; 

    MinUpmPulse = SetDelay(10);
    DebugOut.Analog[1] = 1;
    PPM_Signal = 0;

    if(!SollwertErmittlung()) MotorTon();
//MotorTon();    
    PORTB = 0x31; // Pullups wieder einschalten

    // zum Test der Hardware; Motor dreht mit konstanter Drehzahl ohne Regelung
    if(TEST_MANUELL)    Anwerfen(TEST_MANUELL);  // kommt von dort nicht wieder

    while (1)
        {
//ShowSense();

        if(!TEST_SCHUB)   PWM = SollwertErmittlung();
        //I2C_TXBuffer = PWM; // Antwort 黚er I2C-Bus
        if(MANUELL_PWM)   PWM = MANUELL_PWM;

        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        if(Phase != altPhase)   
            {
            MotorGestoppt = 0;
            ZeitFuerBerechnungen = 0;     
            MinUpmPulse = SetDelay(250);  
            altPhase = Phase;
            }
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        if(!PWM)    // Sollwert == 0
            {
            MotorAnwerfen = 0;      // kein Startversuch
            ZeitFuerBerechnungen = 0;
            // nach 1,5 Sekunden den Motor als gestoppt betrachten 
            if(CheckDelay(MotorGestopptTimer)) 
                {
                DISABLE_SENSE_INT;
                MotorGestoppt = 1;  
                STEUER_OFF;
                } 
            }
        else 
            {
            if(MotorGestoppt) MotorAnwerfen = 1;	// Startversuch
            MotorGestopptTimer = SetDelay(1500);
            }

        if(MotorGestoppt && !TEST_SCHUB) PWM = 0;
        SetPWM();
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        if(!ZeitFuerBerechnungen++)
            {
            if(MotorGestoppt) PORTD |= GRUEN; 
            if(SIO_DEBUG)
                {
                DebugAusgaben();  
                if(!UebertragungAbgeschlossen)  SendUart(); 
                else DatenUebertragung();
                }
            
            if(CheckDelay(MittelstromTimer))   
                {
                MittelstromTimer = SetDelay(50); //  50ms
                if(Mittelstrom <  Strom) Mittelstrom++;// 设置平均电流值
                else if(Mittelstrom >  Strom) Mittelstrom--;
                if(Strom > MAX_STROM) MaxPWM -= MaxPWM / 32;               
                if((Mittelstrom > LIMIT_STROM))// 限流
                    {
                    if(MaxPWM) MaxPWM--;
                    PORTC |= ROT; 
                    }
                else 
                    {
                    if(MaxPWM < MAX_PWM) MaxPWM++;
                    }
                }

            if(CheckDelay(DrehzahlMessTimer))   // 转速
                {
                DrehzahlMessTimer = SetDelay(10);
                SIO_Drehzahl = CntKommutierungen;//(6 * CntKommutierungen) / (POLANZAHL / 2);
                CntKommutierungen = 0;
                if(PPM_Timeout == 0) // 无PPM信号
                ZeitZumAdWandeln = 1;
                }

          if(TEST_SCHUB)
           {
            if(CheckDelay(TestschubTimer))  
                {
                TestschubTimer = SetDelay(1500);
                    switch(test) 
                        {
                        case 0: PWM = 50; test++; break;
                        case 1: PWM = 130; test++; break;
                        case 2: PWM = 60;  test++; break;
                        case 3: PWM = 140; test++; break;
                        case 4: PWM = 150; test = 0; break;
                        default: test = 0;
                        } 
                }
            }  
          // Motor Stehen geblieben
            if((CheckDelay(MinUpmPulse) && SIO_Drehzahl == 0) || MotorAnwerfen) 
                {
                MotorGestoppt = 1;    
                DISABLE_SENSE_INT;
                MinUpmPulse = SetDelay(100);         
                if(MotorAnwerfen)
                    {
                    PORTC &= ~ROT;
                    MotorAnwerfen = 0;
                    Anwerfen(10);
                    PORTD |= GRUEN;
                    MotorGestoppt = 0;    
                    Phase--;
                    PWM = 1;
                    SetPWM();
                    SENSE_TOGGLE_INT;
                    ENABLE_SENSE_INT;
                    MinUpmPulse = SetDelay(20);
                    while(!CheckDelay(MinUpmPulse)); 
                    PWM = 15;
                    SetPWM();
                    MinUpmPulse = SetDelay(300);
                    while(!CheckDelay(MinUpmPulse)); 
                   
				    
                    DrehzahlMessTimer = SetDelay(50);
                    altPhase = 7;
                    }
                }
            } 
        } // while(1) 
}