WebSVN - BL-Ctrl - Diff - Rev 2 and 92


/*############################################################################
 + Regler für Brushless-Motoren
 + ATMEGA8 mit 8MHz
 + (c) 01.2007 Holger Buss
 + Nur für den privaten Gebrauch / NON-COMMERCIAL USE ONLY
 + Keine Garantie auf Fehlerfreiheit
 + Kommerzielle Nutzung nur mit meiner Zustimmung
 + Der Code ist für die Hardware BL_Ctrl V1.0 entwickelt worden
 + www.mikrocontroller.com
/############################################################################*/
 
#include "main.h"
 
unsigned int  PWM = 0;
unsigned int  Strom = 0; //ca. in 0,1A
unsigned char Strom_max = 0;
unsigned char Mittelstrom = 0;
unsigned int  Drehzahl = 0;  // in 100UPM  60 = 6000
unsigned int  KommutierDelay = 10;
unsigned int  I2C_Timeout = 0;
unsigned char SIO_Timeout = 0;
unsigned int  SollDrehzahl = 0;
unsigned int  IstDrehzahl = 0;
unsigned int  DrehZahlTabelle[256];//vorberechnete Werte zur Drehzahlerfassung
unsigned char ZeitFuerBerechnungen = 1;
unsigned char MotorAnwerfen = 0;
unsigned char MotorGestoppt = 1;
unsigned char MaxPWM = MAX_PWM;
unsigned int  CntKommutierungen = 0;
unsigned int  SIO_Drehzahl = 0;
unsigned char ZeitZumAdWandeln = 1;
 
 
//############################################################################
//
void SetPWM(void)
//############################################################################
{
    unsigned char tmp_pwm;
    tmp_pwm = PWM;
    if(tmp_pwm > MaxPWM)    // Strombegrenzung
        {
        tmp_pwm = MaxPWM;
        PORTC |= ROT;
        }
    if(Strom > MAX_STROM)   // Strombegrenzung
        {
        OCR1A = 0; OCR1B = 0; OCR2  = 0;
        PORTC |= ROT;
        Strom--;
        }
    else
        {
        #ifdef  _32KHZ 
        OCR1A =  tmp_pwm; OCR1B =  tmp_pwm; OCR2  = tmp_pwm;
        #endif 
 
        #ifdef  _16KHZ 
        OCR1A = 2 * (int)tmp_pwm; OCR1B = 2 * (int)tmp_pwm; OCR2  = tmp_pwm;
        #endif 
        }
}
 
//############################################################################
//
void PWM_Init(void)
//############################################################################
{
    PWM_OFF;
    TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (1 << WGM12) |
             (0 << WGM13) | (0<< ICES1) | (0 << ICNC1);
}
 
//############################################################################
//
void Wait(unsigned char dauer)
//############################################################################
{
    dauer = (unsigned char)TCNT0 + dauer;
    while((TCNT0 - dauer) & 0x80);
}
 
//############################################################################
//
void Anwerfen(unsigned char pwm)
//############################################################################
{
    unsigned long timer = 300,i;
    DISABLE_SENSE_INT;
    PWM = 5;
    SetPWM();
    Manuell();
    Delay_ms(200);
    PWM = pwm;
    while(1)
        {
        for(i=0;i<timer; i++)
            {
            if(!UebertragungAbgeschlossen)  SendUart();
            else DatenUebertragung();
            Wait(100);  // warten
            }
        timer-= timer/15+1;
        if(timer < 25) { if(TEST_MANUELL) timer = 25; else return; }
 
        Manuell();
        Phase++;
        Phase %= 6;
        AdConvert();
        PWM = pwm;
        SetPWM();
        if(SENSE)
            {
            PORTD ^= GRUEN;
            }
        }
}
 
//############################################################################
//
unsigned char SollwertErmittlung(void)
//############################################################################
{
    static unsigned int sollwert = 0;
    unsigned int ppm;
    if(!I2C_Timeout)   // bei Erreichen von 0 ist der Wert ungültig
        {
        if(SIO_Timeout)  // es gibt gültige SIO-Daten
            {
            sollwert =  (MAX_PWM * (unsigned int) SIO_Sollwert) / 200;  // skalieren auf 0-200 = 0-255
            }
        else
            if(PPM_Timeout)  // es gibt gültige PPM-Daten
                {
                ppm = PPM_Signal;
                if(ppm > 300) ppm =   0;  // ungültiges Signal
                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   // Kein gültiger Sollwert
                {
                if(!TEST_SCHUB) { if(sollwert) sollwert--; }  
                PORTC |= ROT;
                }
        }
    else // I2C-Daten sind gültig
        {
        sollwert = I2C_RXBuffer;
        PORTC &= ~ROT;
        }
    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 = 0x80;
    DDRB  = 0x0E;
    PORTB = 0x31;
   
    UART_Init();
    Timer0_Init();
    sei ();//Globale Interrupts Einschalten
   
    // Am Blinken erkennt man die richtige Motoradresse
    for(test=0;test<5;test++)
        {
        if(test == MOTORADRESSE) PORTD |= GRUEN;
        Delay_ms(150);
        PORTD &= ~GRUEN;
        Delay_ms(250);
        }      
 
    Delay_ms(500);
   
    UART_Init();
    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));
    PORTD |= GRUEN;
    PWM = 0;
 
    SetPWM();
 
    SFIOR = 0x08;  // Analog Comperator ein
    ADMUX = 1;
 
    MinUpmPulse = SetDelay(10);
    DebugOut.Analog[1] = 1;
    PPM_Signal = 0;
 
    // zum Test der Hardware; Motor dreht mit konstanter Drehzahl ohne Regelung
    if(TEST_MANUELL)    Anwerfen(TEST_MANUELL);  // kommt von dort nicht wieder
 
    while (1)
        {
        if(!TEST_SCHUB)   PWM = SollwertErmittlung();
        //I2C_TXBuffer = PWM; // Antwort über I2C-Bus
        if(MANUELL_PWM)   PWM = MANUELL_PWM;
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        if(Phase != altPhase)   // es gab eine Kommutierung im Interrupt
            {
            MotorGestoppt = 0;
            ZeitFuerBerechnungen = 0;    // direkt nach einer Kommutierung ist Zeit 
            MinUpmPulse = SetDelay(50);  // Timeout, falls ein Motor stehen bleibt
            altPhase = Phase;
            }
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        if(!PWM)    // Sollwert == 0
            {
            MotorAnwerfen = 0;      // kein Startversuch
            ZeitFuerBerechnungen = 0;
            // nach 1,5 Sekunden den Motor als gestoppt betrachten 
            if(CheckDelay(DrehzahlMessTimer))
                {
                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; //else PORTD &= ~GRUEN;
            if(SIO_DEBUG)
                {
                DebugAusgaben();  // welche Werte sollen angezeigt werden?
                if(!UebertragungAbgeschlossen)  SendUart();
                else DatenUebertragung();
                }
            // Berechnen des Mittleren Stroms zur (langsamen) Strombegrenzung
            if(CheckDelay(MittelstromTimer))  
                {
                MittelstromTimer = SetDelay(50); // alle 50ms
                if(Mittelstrom <  Strom) Mittelstrom++;// Mittelwert des Stroms bilden
                else if(Mittelstrom >  Strom) Mittelstrom--;
       
                if(Mittelstrom > LIMIT_STROM)// Strom am Limit?
                    {
                    MaxPWM--;// dann die Maximale PWM herunterfahren
                    PORTC |= ROT;
                    }
                else
                    {
                    if(MaxPWM < MAX_PWM) MaxPWM++;
                    }
                }
 
            if(CheckDelay(DrehzahlMessTimer))   // Ist-Drehzahl bestimmen
                {
                DrehzahlMessTimer = SetDelay(10);
                SIO_Drehzahl = (6 * CntKommutierungen) / (POLANZAHL / 2);
                CntKommutierungen = 0;
                if(PPM_Timeout == 0) // keine PPM-Signale
                ZeitZumAdWandeln = 1;
                }
 
 
            if(CheckDelay(TestschubTimer))  
                {
                TestschubTimer = SetDelay(1500);
                if(TEST_SCHUB)
                    {
                    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(100);
                    while(!CheckDelay(MinUpmPulse)); // kurz Synchronisieren
                    PWM = 10;
                    SetPWM();
                    MinUpmPulse = SetDelay(200);
                    while(!CheckDelay(MinUpmPulse)); // kurz Durchstarten
                    MinUpmPulse = SetDelay(1000);
                    altPhase = 7;
                    }
                }
            } // ZeitFuerBerechnungen
        } // while(1) - Hauptschleife
}
 
 

Rev 2	Rev 92
1	/*############################################################################	1	/*############################################################################
2	+ Regler für Brushless-Motoren	2	+ Regler für Brushless-Motoren
3	+ ATMEGA8 mit 8MHz	3	+ ATMEGA8 mit 8MHz
4	+ (c) 01.2007 Holger Buss	4	+ (c) 01.2007 Holger Buss
5	+ Nur für den privaten Gebrauch	5	+ Nur für den privaten Gebrauch / NON-COMMERCIAL USE ONLY
6	+ Keine Garantie auf Fehlerfreiheit	6	+ Keine Garantie auf Fehlerfreiheit
7	+ Kommerzielle Nutzung nur mit meiner Zustimmung	7	+ Kommerzielle Nutzung nur mit meiner Zustimmung
8	+ Der Code ist für die Hardware BL_Ctrl V1.0 entwickelt worden	8	+ Der Code ist für die Hardware BL_Ctrl V1.0 entwickelt worden
9	+ www.mikrocontroller.com	9	+ www.mikrocontroller.com
10	/############################################################################*/	10	/############################################################################*/
11		11
12	#include "main.h"	12	#include "main.h"
13		13
14	unsigned int PWM = 0;	14	unsigned int PWM = 0;
15	unsigned int Strom = 0; //ca. in 0,1A	15	unsigned int Strom = 0; //ca. in 0,1A
16	unsigned char Strom_max = 0;	16	unsigned char Strom_max = 0;
17	unsigned char Mittelstrom = 0;	17	unsigned char Mittelstrom = 0;
18	unsigned int Drehzahl = 0; // in 100UPM 60 = 6000	18	unsigned int Drehzahl = 0; // in 100UPM 60 = 6000
19	unsigned int KommutierDelay = 10;	19	unsigned int KommutierDelay = 10;
20	unsigned int I2C_Timeout = 0;	20	unsigned int I2C_Timeout = 0;
21	unsigned char SIO_Timeout = 0;	21	unsigned char SIO_Timeout = 0;
22	unsigned int SollDrehzahl = 0;	22	unsigned int SollDrehzahl = 0;
23	unsigned int IstDrehzahl = 0;	23	unsigned int IstDrehzahl = 0;
24	unsigned int DrehZahlTabelle[256];//vorberechnete Werte zur Drehzahlerfassung	24	unsigned int DrehZahlTabelle[256];//vorberechnete Werte zur Drehzahlerfassung
25	unsigned char ZeitFuerBerechnungen = 1;	25	unsigned char ZeitFuerBerechnungen = 1;
26	unsigned char MotorAnwerfen = 0;	26	unsigned char MotorAnwerfen = 0;
27	unsigned char MotorGestoppt = 1;	27	unsigned char MotorGestoppt = 1;
28	unsigned char MaxPWM = MAX_PWM;	28	unsigned char MaxPWM = MAX_PWM;
29	unsigned int CntKommutierungen = 0;	29	unsigned int CntKommutierungen = 0;
30	unsigned int SIO_Drehzahl = 0;	30	unsigned int SIO_Drehzahl = 0;
31	unsigned char ZeitZumAdWandeln = 1;	31	unsigned char ZeitZumAdWandeln = 1;
32		32
33		33
34	//############################################################################	34	//############################################################################
35	//	35	//
36	void SetPWM(void)	36	void SetPWM(void)
37	//############################################################################	37	//############################################################################
38	{	38	{
39	unsigned char tmp_pwm;	39	unsigned char tmp_pwm;
40	tmp_pwm = PWM;	40	tmp_pwm = PWM;
41	if(tmp_pwm > MaxPWM) // Strombegrenzung	41	if(tmp_pwm > MaxPWM) // Strombegrenzung
42	{	42	{
43	tmp_pwm = MaxPWM;	43	tmp_pwm = MaxPWM;
44	PORTC \|= ROT;	44	PORTC \|= ROT;
45	}	45	}
46	if(Strom > MAX_STROM) // Strombegrenzung	46	if(Strom > MAX_STROM) // Strombegrenzung
47	{	47	{
48	OCR1A = 0; OCR1B = 0; OCR2 = 0;	48	OCR1A = 0; OCR1B = 0; OCR2 = 0;
49	PORTC \|= ROT;	49	PORTC \|= ROT;
50	Strom--;	50	Strom--;
51	}	51	}
52	else	52	else
53	{	53	{
54	#ifdef _32KHZ	54	#ifdef _32KHZ
55	OCR1A = tmp_pwm; OCR1B = tmp_pwm; OCR2 = tmp_pwm;	55	OCR1A = tmp_pwm; OCR1B = tmp_pwm; OCR2 = tmp_pwm;
56	#endif	56	#endif
57		57
58	#ifdef _16KHZ	58	#ifdef _16KHZ
59	OCR1A = 2 * (int)tmp_pwm; OCR1B = 2 * (int)tmp_pwm; OCR2 = tmp_pwm;	59	OCR1A = 2 * (int)tmp_pwm; OCR1B = 2 * (int)tmp_pwm; OCR2 = tmp_pwm;
60	#endif	60	#endif
61	}	61	}
62	}	62	}
63		63
64	//############################################################################	64	//############################################################################
65	//	65	//
66	void PWM_Init(void)	66	void PWM_Init(void)
67	//############################################################################	67	//############################################################################
68	{	68	{
69	PWM_OFF;	69	PWM_OFF;
70	TCCR1B = (1 << CS10) \| (0 << CS11) \| (0 << CS12) \| (1 << WGM12) \|	70	TCCR1B = (1 << CS10) \| (0 << CS11) \| (0 << CS12) \| (1 << WGM12) \|
71	(0 << WGM13) \| (0<< ICES1) \| (0 << ICNC1);	71	(0 << WGM13) \| (0<< ICES1) \| (0 << ICNC1);
72	}	72	}
73		73
74	//############################################################################	74	//############################################################################
75	//	75	//
76	void Wait(unsigned char dauer)	76	void Wait(unsigned char dauer)
77	//############################################################################	77	//############################################################################
78	{	78	{
79	dauer = (unsigned char)TCNT0 + dauer;	79	dauer = (unsigned char)TCNT0 + dauer;
80	while((TCNT0 - dauer) & 0x80);	80	while((TCNT0 - dauer) & 0x80);
81	}	81	}
82		82
83	//############################################################################	83	//############################################################################
84	//	84	//
85	void Anwerfen(unsigned char pwm)	85	void Anwerfen(unsigned char pwm)
86	//############################################################################	86	//############################################################################
87	{	87	{
88	unsigned long timer = 300,i;	88	unsigned long timer = 300,i;
89	DISABLE_SENSE_INT;	89	DISABLE_SENSE_INT;
90	PWM = 5;	90	PWM = 5;
91	SetPWM();	91	SetPWM();
92	Manuell();	92	Manuell();
93	Delay_ms(200);	93	Delay_ms(200);
94	PWM = pwm;	94	PWM = pwm;
95	while(1)	95	while(1)
96	{	96	{
97	for(i=0;i<timer; i++)	97	for(i=0;i<timer; i++)
98	{	98	{
99	if(!UebertragungAbgeschlossen) SendUart();	99	if(!UebertragungAbgeschlossen) SendUart();
100	else DatenUebertragung();	100	else DatenUebertragung();
101	Wait(100); // warten	101	Wait(100); // warten
102	}	102	}
103	timer-= timer/15+1;	103	timer-= timer/15+1;
104	if(timer < 25) { if(TEST_MANUELL) timer = 25; else return; }	104	if(timer < 25) { if(TEST_MANUELL) timer = 25; else return; }
105		105
106	Manuell();	106	Manuell();
107	Phase++;	107	Phase++;
108	Phase %= 6;	108	Phase %= 6;
109	AdConvert();	109	AdConvert();
110	PWM = pwm;	110	PWM = pwm;
111	SetPWM();	111	SetPWM();
112	if(SENSE)	112	if(SENSE)
113	{	113	{
114	PORTD ^= GRUEN;	114	PORTD ^= GRUEN;
115	}	115	}
116	}	116	}
117	}	117	}
118		118
119	//############################################################################	119	//############################################################################
120	//	120	//
121	unsigned char SollwertErmittlung(void)	121	unsigned char SollwertErmittlung(void)
122	//############################################################################	122	//############################################################################
123	{	123	{
124	static unsigned int sollwert = 0;	124	static unsigned int sollwert = 0;
125	unsigned int ppm;	125	unsigned int ppm;
126	if(!I2C_Timeout) // bei Erreichen von 0 ist der Wert ungültig	126	if(!I2C_Timeout) // bei Erreichen von 0 ist der Wert ungültig
127	{	127	{
128	if(SIO_Timeout) // es gibt gültige SIO-Daten	128	if(SIO_Timeout) // es gibt gültige SIO-Daten
129	{	129	{
130	sollwert = (MAX_PWM * (unsigned int) SIO_Sollwert) / 200; // skalieren auf 0-200 = 0-255	130	sollwert = (MAX_PWM * (unsigned int) SIO_Sollwert) / 200; // skalieren auf 0-200 = 0-255
131	}	131	}
132	else	132	else
133	if(PPM_Timeout) // es gibt gültige PPM-Daten	133	if(PPM_Timeout) // es gibt gültige PPM-Daten
134	{	134	{
135	ppm = PPM_Signal;	135	ppm = PPM_Signal;
136	if(ppm > 300) ppm = 0; // ungültiges Signal	136	if(ppm > 300) ppm = 0; // ungültiges Signal
137	if(ppm > 200) ppm = 200;	137	if(ppm > 200) ppm = 200;
138	if(ppm <= MIN_PPM) sollwert = 0;	138	if(ppm <= MIN_PPM) sollwert = 0;
139	else	139	else
140	{	140	{
141	sollwert = (int) MIN_PWM + ((MAX_PWM - MIN_PWM) * (ppm - MIN_PPM)) / (190 - MIN_PPM);	141	sollwert = (int) MIN_PWM + ((MAX_PWM - MIN_PWM) * (ppm - MIN_PPM)) / (190 - MIN_PPM);
142	}	142	}
143	PORTC &= ~ROT;	143	PORTC &= ~ROT;
144	}	144	}
145	else // Kein gültiger Sollwert	145	else // Kein gültiger Sollwert
146	{	146	{
147	if(!TEST_SCHUB) { if(sollwert) sollwert--; }	147	if(!TEST_SCHUB) { if(sollwert) sollwert--; }
148	PORTC \|= ROT;	148	PORTC \|= ROT;
149	}	149	}
150	}	150	}
151	else // I2C-Daten sind gültig	151	else // I2C-Daten sind gültig
152	{	152	{
153	sollwert = I2C_RXBuffer;	153	sollwert = I2C_RXBuffer;
154	PORTC &= ~ROT;	154	PORTC &= ~ROT;
155	}	155	}
156	if(sollwert > MAX_PWM) sollwert = MAX_PWM;	156	if(sollwert > MAX_PWM) sollwert = MAX_PWM;
157	return(sollwert);	157	return(sollwert);
158	}	158	}
159		159
160	void DebugAusgaben(void)	160	void DebugAusgaben(void)
161	{	161	{
162	DebugOut.Analog[0] = Strom;	162	DebugOut.Analog[0] = Strom;
163	DebugOut.Analog[1] = Mittelstrom;	163	DebugOut.Analog[1] = Mittelstrom;
164	DebugOut.Analog[2] = SIO_Drehzahl;	164	DebugOut.Analog[2] = SIO_Drehzahl;
165	DebugOut.Analog[3] = PPM_Signal;	165	DebugOut.Analog[3] = PPM_Signal;
166	}	166	}
167		167
168		168
169	//############################################################################	169	//############################################################################
170	//Hauptprogramm	170	//Hauptprogramm
171	int main (void)	171	int main (void)
172	//############################################################################	172	//############################################################################
173	{	173	{
174	char altPhase = 0;	174	char altPhase = 0;
175	int test = 0;	175	int test = 0;
176	unsigned int MinUpmPulse,Blink,TestschubTimer;	176	unsigned int MinUpmPulse,Blink,TestschubTimer;
177	unsigned int Blink2,MittelstromTimer,DrehzahlMessTimer,MotorGestopptTimer;	177	unsigned int Blink2,MittelstromTimer,DrehzahlMessTimer,MotorGestopptTimer;
178		178
179	DDRC = 0x08;	179	DDRC = 0x08;
180	PORTC = 0x08;	180	PORTC = 0x08;
181	DDRD = 0xBA;	181	DDRD = 0xBA;
182	PORTD = 0x80;	182	PORTD = 0x80;
183	DDRB = 0x0E;	183	DDRB = 0x0E;
184	PORTB = 0x31;	184	PORTB = 0x31;
185		185
186	UART_Init();	186	UART_Init();
187	Timer0_Init();	187	Timer0_Init();
188	sei ();//Globale Interrupts Einschalten	188	sei ();//Globale Interrupts Einschalten
189		189
190	// Am Blinken erkennt man die richtige Motoradresse	190	// Am Blinken erkennt man die richtige Motoradresse
191	for(test=0;test<5;test++)	191	for(test=0;test<5;test++)
192	{	192	{
193	if(test == MOTORADRESSE) PORTD \|= GRUEN;	193	if(test == MOTORADRESSE) PORTD \|= GRUEN;
194	Delay_ms(150);	194	Delay_ms(150);
195	PORTD &= ~GRUEN;	195	PORTD &= ~GRUEN;
196	Delay_ms(250);	196	Delay_ms(250);
197	}	197	}
198		198
199	Delay_ms(500);	199	Delay_ms(500);
200		200
201	UART_Init();	201	UART_Init();
202	PWM_Init();	202	PWM_Init();
203		203
204	InitIC2_Slave(0x50);	204	InitIC2_Slave(0x50);
205	InitPPM();	205	InitPPM();
206		206
207	Blink = SetDelay(101);	207	Blink = SetDelay(101);
208	Blink2 = SetDelay(102);	208	Blink2 = SetDelay(102);
209	MinUpmPulse = SetDelay(103);	209	MinUpmPulse = SetDelay(103);
210	MittelstromTimer = SetDelay(254);	210	MittelstromTimer = SetDelay(254);
211	DrehzahlMessTimer = SetDelay(1005);	211	DrehzahlMessTimer = SetDelay(1005);
212	TestschubTimer = SetDelay(1006);	212	TestschubTimer = SetDelay(1006);
213	while(!CheckDelay(MinUpmPulse));	213	while(!CheckDelay(MinUpmPulse));
214	PORTD \|= GRUEN;	214	PORTD \|= GRUEN;
215	PWM = 0;	215	PWM = 0;
216		216
217	SetPWM();	217	SetPWM();
218		218
219	SFIOR = 0x08; // Analog Comperator ein	219	SFIOR = 0x08; // Analog Comperator ein
220	ADMUX = 1;	220	ADMUX = 1;
221		221
222	MinUpmPulse = SetDelay(10);	222	MinUpmPulse = SetDelay(10);
223	DebugOut.Analog[1] = 1;	223	DebugOut.Analog[1] = 1;
224	PPM_Signal = 0;	224	PPM_Signal = 0;
225		225
226	// zum Test der Hardware; Motor dreht mit konstanter Drehzahl ohne Regelung	226	// zum Test der Hardware; Motor dreht mit konstanter Drehzahl ohne Regelung
227	if(TEST_MANUELL) Anwerfen(TEST_MANUELL); // kommt von dort nicht wieder	227	if(TEST_MANUELL) Anwerfen(TEST_MANUELL); // kommt von dort nicht wieder
228		228
229	while (1)	229	while (1)
230	{	230	{
231	if(!TEST_SCHUB) PWM = SollwertErmittlung();	231	if(!TEST_SCHUB) PWM = SollwertErmittlung();
232	//I2C_TXBuffer = PWM; // Antwort über I2C-Bus	232	//I2C_TXBuffer = PWM; // Antwort über I2C-Bus
233	if(MANUELL_PWM) PWM = MANUELL_PWM;	233	if(MANUELL_PWM) PWM = MANUELL_PWM;
234		234
235	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	235	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
236	if(Phase != altPhase) // es gab eine Kommutierung im Interrupt	236	if(Phase != altPhase) // es gab eine Kommutierung im Interrupt
237	{	237	{
238	MotorGestoppt = 0;	238	MotorGestoppt = 0;
239	ZeitFuerBerechnungen = 0; // direkt nach einer Kommutierung ist Zeit	239	ZeitFuerBerechnungen = 0; // direkt nach einer Kommutierung ist Zeit
240	MinUpmPulse = SetDelay(50); // Timeout, falls ein Motor stehen bleibt	240	MinUpmPulse = SetDelay(50); // Timeout, falls ein Motor stehen bleibt
241	altPhase = Phase;	241	altPhase = Phase;
242	}	242	}
243	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	243	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
244	if(!PWM) // Sollwert == 0	244	if(!PWM) // Sollwert == 0
245	{	245	{
246	MotorAnwerfen = 0; // kein Startversuch	246	MotorAnwerfen = 0; // kein Startversuch
247	ZeitFuerBerechnungen = 0;	247	ZeitFuerBerechnungen = 0;
248	// nach 1,5 Sekunden den Motor als gestoppt betrachten	248	// nach 1,5 Sekunden den Motor als gestoppt betrachten
249	if(CheckDelay(DrehzahlMessTimer))	249	if(CheckDelay(DrehzahlMessTimer))
250	{	250	{
251	DISABLE_SENSE_INT;	251	DISABLE_SENSE_INT;
252	MotorGestoppt = 1;	252	MotorGestoppt = 1;
253	STEUER_OFF;	253	STEUER_OFF;
254	}	254	}
255	}	255	}
256	else	256	else
257	{	257	{
258	if(MotorGestoppt) MotorAnwerfen = 1; // Startversuch	258	if(MotorGestoppt) MotorAnwerfen = 1; // Startversuch
259	MotorGestopptTimer = SetDelay(1500);	259	MotorGestopptTimer = SetDelay(1500);
260	}	260	}
261		261
262	if(MotorGestoppt && !TEST_SCHUB) PWM = 0;	262	if(MotorGestoppt && !TEST_SCHUB) PWM = 0;
263	SetPWM();	263	SetPWM();
264	// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	264	// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
265	if(!ZeitFuerBerechnungen++)	265	if(!ZeitFuerBerechnungen++)
266	{	266	{
267	if(MotorGestoppt) PORTD \|= GRUEN; //else PORTD &= ~GRUEN;	267	if(MotorGestoppt) PORTD \|= GRUEN; //else PORTD &= ~GRUEN;
268	if(SIO_DEBUG)	268	if(SIO_DEBUG)
269	{	269	{
270	DebugAusgaben(); // welche Werte sollen angezeigt werden?	270	DebugAusgaben(); // welche Werte sollen angezeigt werden?
271	if(!UebertragungAbgeschlossen) SendUart();	271	if(!UebertragungAbgeschlossen) SendUart();
272	else DatenUebertragung();	272	else DatenUebertragung();
273	}	273	}
274	// Berechnen des Mittleren Stroms zur (langsamen) Strombegrenzung	274	// Berechnen des Mittleren Stroms zur (langsamen) Strombegrenzung
275	if(CheckDelay(MittelstromTimer))	275	if(CheckDelay(MittelstromTimer))
276	{	276	{
277	MittelstromTimer = SetDelay(50); // alle 50ms	277	MittelstromTimer = SetDelay(50); // alle 50ms
278	if(Mittelstrom < Strom) Mittelstrom++;// Mittelwert des Stroms bilden	278	if(Mittelstrom < Strom) Mittelstrom++;// Mittelwert des Stroms bilden
279	else if(Mittelstrom > Strom) Mittelstrom--;	279	else if(Mittelstrom > Strom) Mittelstrom--;
280		280
281	if(Mittelstrom > LIMIT_STROM)// Strom am Limit?	281	if(Mittelstrom > LIMIT_STROM)// Strom am Limit?
282	{	282	{
283	MaxPWM--;// dann die Maximale PWM herunterfahren	283	MaxPWM--;// dann die Maximale PWM herunterfahren
284	PORTC \|= ROT;	284	PORTC \|= ROT;
285	}	285	}
286	else	286	else
287	{	287	{
288	if(MaxPWM < MAX_PWM) MaxPWM++;	288	if(MaxPWM < MAX_PWM) MaxPWM++;
289	}	289	}
290	}	290	}
291		291
292	if(CheckDelay(DrehzahlMessTimer)) // Ist-Drehzahl bestimmen	292	if(CheckDelay(DrehzahlMessTimer)) // Ist-Drehzahl bestimmen
293	{	293	{
294	DrehzahlMessTimer = SetDelay(10);	294	DrehzahlMessTimer = SetDelay(10);
295	SIO_Drehzahl = (6 * CntKommutierungen) / (POLANZAHL / 2);	295	SIO_Drehzahl = (6 * CntKommutierungen) / (POLANZAHL / 2);
296	CntKommutierungen = 0;	296	CntKommutierungen = 0;
297	if(PPM_Timeout == 0) // keine PPM-Signale	297	if(PPM_Timeout == 0) // keine PPM-Signale
298	ZeitZumAdWandeln = 1;	298	ZeitZumAdWandeln = 1;
299	}	299	}
300		300
301		301
302	if(CheckDelay(TestschubTimer))	302	if(CheckDelay(TestschubTimer))
303	{	303	{
304	TestschubTimer = SetDelay(1500);	304	TestschubTimer = SetDelay(1500);
305	if(TEST_SCHUB)	305	if(TEST_SCHUB)
306	{	306	{
307	switch(test)	307	switch(test)
308	{	308	{
309	case 0: PWM = 50; test++; break;	309	case 0: PWM = 50; test++; break;
310	case 1: PWM = 130; test++; break;	310	case 1: PWM = 130; test++; break;
311	case 2: PWM = 60; test++; break;	311	case 2: PWM = 60; test++; break;
312	case 3: PWM = 140; test++; break;	312	case 3: PWM = 140; test++; break;
313	case 4: PWM = 150; test = 0; break;	313	case 4: PWM = 150; test = 0; break;
314	default: test = 0;	314	default: test = 0;
315	}	315	}
316	}	316	}
317	}	317	}
318	// Motor Stehen geblieben	318	// Motor Stehen geblieben
319	if((CheckDelay(MinUpmPulse) && SIO_Drehzahl == 0) \|\| MotorAnwerfen)	319	if((CheckDelay(MinUpmPulse) && SIO_Drehzahl == 0) \|\| MotorAnwerfen)
320	{	320	{
321	MotorGestoppt = 1;	321	MotorGestoppt = 1;
322	DISABLE_SENSE_INT;	322	DISABLE_SENSE_INT;
323	MinUpmPulse = SetDelay(100);	323	MinUpmPulse = SetDelay(100);
324	if(MotorAnwerfen)	324	if(MotorAnwerfen)
325	{	325	{
326	PORTC &= ~ROT;	326	PORTC &= ~ROT;
327	MotorAnwerfen = 0;	327	MotorAnwerfen = 0;
328	Anwerfen(10);	328	Anwerfen(10);
329	PORTD \|= GRUEN;	329	PORTD \|= GRUEN;
330	MotorGestoppt = 0;	330	MotorGestoppt = 0;
331	Phase--;	331	Phase--;
332	PWM = 1;	332	PWM = 1;
333	SetPWM();	333	SetPWM();
334	SENSE_TOGGLE_INT;	334	SENSE_TOGGLE_INT;
335	ENABLE_SENSE_INT;	335	ENABLE_SENSE_INT;
336	MinUpmPulse = SetDelay(100);	336	MinUpmPulse = SetDelay(100);
337	while(!CheckDelay(MinUpmPulse)); // kurz Synchronisieren	337	while(!CheckDelay(MinUpmPulse)); // kurz Synchronisieren
338	PWM = 10;	338	PWM = 10;
339	SetPWM();	339	SetPWM();
340	MinUpmPulse = SetDelay(200);	340	MinUpmPulse = SetDelay(200);
341	while(!CheckDelay(MinUpmPulse)); // kurz Durchstarten	341	while(!CheckDelay(MinUpmPulse)); // kurz Durchstarten
342	MinUpmPulse = SetDelay(1000);	342	MinUpmPulse = SetDelay(1000);
343	altPhase = 7;	343	altPhase = 7;
344	}	344	}
345	}	345	}
346	} // ZeitFuerBerechnungen	346	} // ZeitFuerBerechnungen
347	} // while(1) - Hauptschleife	347	} // while(1) - Hauptschleife
348	}	348	}
349		349
350		350

Subversion Repositories BL-Ctrl

(root)/tags/V0.31/main.c - Rev 2 → 92