Rev 26 | Rev 50 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 26 | Rev 43 | ||
---|---|---|---|
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 |
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 int SIO_Timeout = 0; |
21 | unsigned int 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 | unsigned char MotorAdresse = 1; |
32 | unsigned char MotorAdresse = 1; |
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 = 0x00; |
182 | PORTD = 0x00; |
183 | DDRB = 0x0E; |
183 | DDRB = 0x0E; |
184 | PORTB = 0x31; |
184 | PORTB = 0x31; |
185 | 185 | ||
186 | #if (MOTORADRESSE == 0) |
186 | #if (MOTORADRESSE == 0) |
187 | PORTB |= (ADR1 + ADR2); // Pullups für Adresswahl |
187 | PORTB |= (ADR1 + ADR2); // Pullups für Adresswahl |
- | 188 | for(test=0;test<500;test++); |
|
188 | if (PINB & ADR1) |
189 | if (PINB & ADR1) |
189 | { |
190 | { |
190 | if (PINB & ADR2) MotorAdresse = 1; |
191 | if (PINB & ADR2) MotorAdresse = 1; |
191 | else MotorAdresse = 2; |
192 | else MotorAdresse = 2; |
192 | } |
193 | } |
193 | else |
194 | else |
194 | { |
195 | { |
195 | if (PINB & ADR2) MotorAdresse = 3; |
196 | if (PINB & ADR2) MotorAdresse = 3; |
196 | else MotorAdresse = 4; |
197 | else MotorAdresse = 4; |
197 | } |
198 | } |
198 | #else |
199 | #else |
199 | MotorAdresse = MOTORADRESSE; |
200 | MotorAdresse = MOTORADRESSE; |
200 | #endif |
201 | #endif |
201 | 202 | ||
202 | UART_Init(); |
203 | UART_Init(); |
203 | Timer0_Init(); |
204 | Timer0_Init(); |
204 | sei ();//Globale Interrupts Einschalten |
205 | sei ();//Globale Interrupts Einschalten |
205 | 206 | ||
206 | // Am Blinken erkennt man die richtige Motoradresse |
207 | // Am Blinken erkennt man die richtige Motoradresse |
207 | for(test=0;test<5;test++) |
208 | for(test=0;test<5;test++) |
208 | { |
209 | { |
209 | if(test == MotorAdresse) PORTD |= GRUEN; |
210 | if(test == MotorAdresse) PORTD |= GRUEN; |
210 | Delay_ms(150); |
211 | Delay_ms(150); |
211 | PORTD &= ~GRUEN; |
212 | PORTD &= ~GRUEN; |
212 | Delay_ms(250); |
213 | Delay_ms(250); |
213 | } |
214 | } |
214 | 215 | ||
215 | Delay_ms(500); |
216 | Delay_ms(500); |
216 | 217 | ||
217 | // UART_Init(); // war doppelt |
218 | // UART_Init(); // war doppelt |
218 | PWM_Init(); |
219 | PWM_Init(); |
219 | 220 | ||
220 | InitIC2_Slave(0x50); |
221 | InitIC2_Slave(0x50); |
221 | InitPPM(); |
222 | InitPPM(); |
222 | 223 | ||
223 | Blink = SetDelay(101); |
224 | Blink = SetDelay(101); |
224 | Blink2 = SetDelay(102); |
225 | Blink2 = SetDelay(102); |
225 | MinUpmPulse = SetDelay(103); |
226 | MinUpmPulse = SetDelay(103); |
226 | MittelstromTimer = SetDelay(254); |
227 | MittelstromTimer = SetDelay(254); |
227 | DrehzahlMessTimer = SetDelay(1005); |
228 | DrehzahlMessTimer = SetDelay(1005); |
228 | TestschubTimer = SetDelay(1006); |
229 | TestschubTimer = SetDelay(1006); |
229 | while(!CheckDelay(MinUpmPulse)); |
230 | while(!CheckDelay(MinUpmPulse)); |
230 | PORTD |= GRUEN; |
231 | PORTD |= GRUEN; |
231 | PWM = 0; |
232 | PWM = 0; |
232 | 233 | ||
233 | SetPWM(); |
234 | SetPWM(); |
234 | 235 | ||
235 | SFIOR = 0x08; // Analog Comperator ein |
236 | SFIOR = 0x08; // Analog Comperator ein |
236 | ADMUX = 1; |
237 | ADMUX = 1; |
237 | 238 | ||
238 | MinUpmPulse = SetDelay(10); |
239 | MinUpmPulse = SetDelay(10); |
239 | DebugOut.Analog[1] = 1; |
240 | DebugOut.Analog[1] = 1; |
240 | PPM_Signal = 0; |
241 | PPM_Signal = 0; |
241 | 242 | ||
242 | // zum Test der Hardware; Motor dreht mit konstanter Drehzahl ohne Regelung |
243 | // zum Test der Hardware; Motor dreht mit konstanter Drehzahl ohne Regelung |
243 | if(TEST_MANUELL) Anwerfen(TEST_MANUELL); // kommt von dort nicht wieder |
244 | if(TEST_MANUELL) Anwerfen(TEST_MANUELL); // kommt von dort nicht wieder |
244 | 245 | ||
245 | while (1) |
246 | while (1) |
246 | { |
247 | { |
247 | if(!TEST_SCHUB) PWM = SollwertErmittlung(); |
248 | if(!TEST_SCHUB) PWM = SollwertErmittlung(); |
248 | //I2C_TXBuffer = PWM; // Antwort über I2C-Bus |
249 | //I2C_TXBuffer = PWM; // Antwort über I2C-Bus |
249 | if(MANUELL_PWM) PWM = MANUELL_PWM; |
250 | if(MANUELL_PWM) PWM = MANUELL_PWM; |
250 | 251 | ||
251 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
252 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
252 | if(Phase != altPhase) // es gab eine Kommutierung im Interrupt |
253 | if(Phase != altPhase) // es gab eine Kommutierung im Interrupt |
253 | { |
254 | { |
254 | MotorGestoppt = 0; |
255 | MotorGestoppt = 0; |
255 | ZeitFuerBerechnungen = 0; // direkt nach einer Kommutierung ist Zeit |
256 | ZeitFuerBerechnungen = 0; // direkt nach einer Kommutierung ist Zeit |
256 | MinUpmPulse = SetDelay(50); // Timeout, falls ein Motor stehen bleibt |
257 | MinUpmPulse = SetDelay(50); // Timeout, falls ein Motor stehen bleibt |
257 | altPhase = Phase; |
258 | altPhase = Phase; |
258 | } |
259 | } |
259 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
260 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
260 | if(!PWM) // Sollwert == 0 |
261 | if(!PWM) // Sollwert == 0 |
261 | { |
262 | { |
262 | MotorAnwerfen = 0; // kein Startversuch |
263 | MotorAnwerfen = 0; // kein Startversuch |
263 | ZeitFuerBerechnungen = 0; |
264 | ZeitFuerBerechnungen = 0; |
264 | // nach 1,5 Sekunden den Motor als gestoppt betrachten |
265 | // nach 1,5 Sekunden den Motor als gestoppt betrachten |
265 | if(CheckDelay(MotorGestopptTimer)) |
266 | if(CheckDelay(MotorGestopptTimer)) |
266 | { |
267 | { |
267 | DISABLE_SENSE_INT; |
268 | DISABLE_SENSE_INT; |
268 | MotorGestoppt = 1; |
269 | MotorGestoppt = 1; |
269 | STEUER_OFF; |
270 | STEUER_OFF; |
270 | } |
271 | } |
271 | } |
272 | } |
272 | else |
273 | else |
273 | { |
274 | { |
274 | if(MotorGestoppt) MotorAnwerfen = 1; // Startversuch |
275 | if(MotorGestoppt) MotorAnwerfen = 1; // Startversuch |
275 | MotorGestopptTimer = SetDelay(1500); |
276 | MotorGestopptTimer = SetDelay(1500); |
276 | } |
277 | } |
277 | 278 | ||
278 | if(MotorGestoppt && !TEST_SCHUB) PWM = 0; |
279 | if(MotorGestoppt && !TEST_SCHUB) PWM = 0; |
279 | SetPWM(); |
280 | SetPWM(); |
280 | // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
281 | // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
281 | if(!ZeitFuerBerechnungen++) |
282 | if(!ZeitFuerBerechnungen++) |
282 | { |
283 | { |
283 | if(MotorGestoppt) PORTD |= GRUEN; //else PORTD &= ~GRUEN; |
284 | if(MotorGestoppt) PORTD |= GRUEN; //else PORTD &= ~GRUEN; |
284 | if(SIO_DEBUG) |
285 | if(SIO_DEBUG) |
285 | { |
286 | { |
286 | DebugAusgaben(); // welche Werte sollen angezeigt werden? |
287 | DebugAusgaben(); // welche Werte sollen angezeigt werden? |
287 | if(!UebertragungAbgeschlossen) SendUart(); |
288 | if(!UebertragungAbgeschlossen) SendUart(); |
288 | else DatenUebertragung(); |
289 | else DatenUebertragung(); |
289 | } |
290 | } |
290 | // Berechnen des Mittleren Stroms zur (langsamen) Strombegrenzung |
291 | // Berechnen des Mittleren Stroms zur (langsamen) Strombegrenzung |
291 | if(CheckDelay(MittelstromTimer)) |
292 | if(CheckDelay(MittelstromTimer)) |
292 | { |
293 | { |
293 | MittelstromTimer = SetDelay(50); // alle 50ms |
294 | MittelstromTimer = SetDelay(50); // alle 50ms |
294 | if(Mittelstrom < Strom) Mittelstrom++;// Mittelwert des Stroms bilden |
295 | if(Mittelstrom < Strom) Mittelstrom++;// Mittelwert des Stroms bilden |
295 | else if(Mittelstrom > Strom) Mittelstrom--; |
296 | else if(Mittelstrom > Strom) Mittelstrom--; |
296 | 297 | ||
297 | if(Mittelstrom > LIMIT_STROM)// Strom am Limit? |
298 | if(Mittelstrom > LIMIT_STROM)// Strom am Limit? |
298 | { |
299 | { |
299 | MaxPWM--;// dann die Maximale PWM herunterfahren |
300 | MaxPWM--;// dann die Maximale PWM herunterfahren |
300 | PORTC |= ROT; |
301 | PORTC |= ROT; |
301 | } |
302 | } |
302 | else |
303 | else |
303 | { |
304 | { |
304 | if(MaxPWM < MAX_PWM) MaxPWM++; |
305 | if(MaxPWM < MAX_PWM) MaxPWM++; |
305 | } |
306 | } |
306 | } |
307 | } |
307 | 308 | ||
308 | if(CheckDelay(DrehzahlMessTimer)) // Ist-Drehzahl bestimmen |
309 | if(CheckDelay(DrehzahlMessTimer)) // Ist-Drehzahl bestimmen |
309 | { |
310 | { |
310 | DrehzahlMessTimer = SetDelay(10); |
311 | DrehzahlMessTimer = SetDelay(10); |
311 | SIO_Drehzahl = (6 * CntKommutierungen) / (POLANZAHL / 2); |
312 | SIO_Drehzahl = (6 * CntKommutierungen) / (POLANZAHL / 2); |
312 | CntKommutierungen = 0; |
313 | CntKommutierungen = 0; |
313 | if(PPM_Timeout == 0) // keine PPM-Signale |
314 | if(PPM_Timeout == 0) // keine PPM-Signale |
314 | ZeitZumAdWandeln = 1; |
315 | ZeitZumAdWandeln = 1; |
315 | } |
316 | } |
316 | 317 | ||
317 | 318 | ||
318 | if(CheckDelay(TestschubTimer)) |
319 | if(CheckDelay(TestschubTimer)) |
319 | { |
320 | { |
320 | TestschubTimer = SetDelay(1500); |
321 | TestschubTimer = SetDelay(1500); |
321 | if(TEST_SCHUB) |
322 | if(TEST_SCHUB) |
322 | { |
323 | { |
323 | switch(test) |
324 | switch(test) |
324 | { |
325 | { |
325 | case 0: PWM = 50; test++; break; |
326 | case 0: PWM = 50; test++; break; |
326 | case 1: PWM = 130; test++; break; |
327 | case 1: PWM = 130; test++; break; |
327 | case 2: PWM = 60; test++; break; |
328 | case 2: PWM = 60; test++; break; |
328 | case 3: PWM = 140; test++; break; |
329 | case 3: PWM = 140; test++; break; |
329 | case 4: PWM = 150; test = 0; break; |
330 | case 4: PWM = 150; test = 0; break; |
330 | default: test = 0; |
331 | default: test = 0; |
331 | } |
332 | } |
332 | } |
333 | } |
333 | } |
334 | } |
334 | // Motor Stehen geblieben |
335 | // Motor Stehen geblieben |
335 | if((CheckDelay(MinUpmPulse) && SIO_Drehzahl == 0) || MotorAnwerfen) |
336 | if((CheckDelay(MinUpmPulse) && SIO_Drehzahl == 0) || MotorAnwerfen) |
336 | { |
337 | { |
337 | MotorGestoppt = 1; |
338 | MotorGestoppt = 1; |
338 | DISABLE_SENSE_INT; |
339 | DISABLE_SENSE_INT; |
339 | MinUpmPulse = SetDelay(100); |
340 | MinUpmPulse = SetDelay(100); |
340 | if(MotorAnwerfen) |
341 | if(MotorAnwerfen) |
341 | { |
342 | { |
342 | PORTC &= ~ROT; |
343 | PORTC &= ~ROT; |
343 | MotorAnwerfen = 0; |
344 | MotorAnwerfen = 0; |
344 | Anwerfen(10); |
345 | Anwerfen(10); |
345 | PORTD |= GRUEN; |
346 | PORTD |= GRUEN; |
346 | MotorGestoppt = 0; |
347 | MotorGestoppt = 0; |
347 | Phase--; |
348 | Phase--; |
348 | PWM = 1; |
349 | PWM = 1; |
349 | SetPWM(); |
350 | SetPWM(); |
350 | SENSE_TOGGLE_INT; |
351 | SENSE_TOGGLE_INT; |
351 | ENABLE_SENSE_INT; |
352 | ENABLE_SENSE_INT; |
352 | MinUpmPulse = SetDelay(100); |
353 | MinUpmPulse = SetDelay(20); |
353 | while(!CheckDelay(MinUpmPulse)); // kurz Synchronisieren |
354 | while(!CheckDelay(MinUpmPulse)); // kurz Synchronisieren |
354 | PWM = 10; |
355 | PWM = 15; |
355 | SetPWM(); |
356 | SetPWM(); |
356 | MinUpmPulse = SetDelay(200); |
357 | MinUpmPulse = SetDelay(300); |
357 | while(!CheckDelay(MinUpmPulse)); // kurz Durchstarten |
358 | while(!CheckDelay(MinUpmPulse)); // kurz Durchstarten |
358 | 359 | ||
359 | // Drehzahlmessung wieder aufsetzen |
360 | // Drehzahlmessung wieder aufsetzen |
360 | DrehzahlMessTimer = SetDelay(50); |
361 | DrehzahlMessTimer = SetDelay(50); |
361 | altPhase = 7; |
362 | altPhase = 7; |
362 | } |
363 | } |
363 | } |
364 | } |
364 | } // ZeitFuerBerechnungen |
365 | } // ZeitFuerBerechnungen |
365 | } // while(1) - Hauptschleife |
366 | } // while(1) - Hauptschleife |
366 | } |
367 | } |
367 | 368 | ||
368 | 369 |