Rev 51 | Rev 60 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1 | ingob | 1 | /*############################################################################ |
2 | + Regler für Brushless-Motoren |
||
3 | + ATMEGA8 mit 8MHz |
||
4 | + (c) 01.2007 Holger Buss |
||
5 | + Nur für den privaten Gebrauch |
||
6 | + Keine Garantie auf Fehlerfreiheit |
||
7 | + Kommerzielle Nutzung nur mit meiner Zustimmung |
||
8 | + Der Code ist für die Hardware BL_Ctrl V1.0 entwickelt worden |
||
9 | + www.mikrocontroller.com |
||
10 | /############################################################################*/ |
||
11 | |||
12 | #include "main.h" |
||
13 | |||
14 | unsigned int PWM = 0; |
||
58 | hbuss | 15 | unsigned int Strom = 0,RuheStrom; //ca. in 0,1A |
1 | ingob | 16 | unsigned char Strom_max = 0; |
51 | holgerb | 17 | unsigned char Mittelstrom = 0; |
1 | ingob | 18 | unsigned int Drehzahl = 0; // in 100UPM 60 = 6000 |
19 | unsigned int KommutierDelay = 10; |
||
20 | unsigned int I2C_Timeout = 0; |
||
23 | ingob | 21 | unsigned int SIO_Timeout = 0; |
1 | ingob | 22 | unsigned int SollDrehzahl = 0; |
23 | unsigned int IstDrehzahl = 0; |
||
24 | unsigned int DrehZahlTabelle[256];//vorberechnete Werte zur Drehzahlerfassung |
||
25 | unsigned char ZeitFuerBerechnungen = 1; |
||
26 | unsigned char MotorAnwerfen = 0; |
||
27 | unsigned char MotorGestoppt = 1; |
||
28 | unsigned char MaxPWM = MAX_PWM; |
||
29 | unsigned int CntKommutierungen = 0; |
||
30 | unsigned int SIO_Drehzahl = 0; |
||
31 | unsigned char ZeitZumAdWandeln = 1; |
||
24 | ingob | 32 | unsigned char MotorAdresse = 1; |
50 | holgerb | 33 | unsigned char PPM_Betrieb = 1; |
1 | ingob | 34 | |
35 | //############################################################################ |
||
36 | // |
||
37 | void SetPWM(void) |
||
38 | //############################################################################ |
||
39 | { |
||
40 | unsigned char tmp_pwm; |
||
41 | tmp_pwm = PWM; |
||
42 | if(tmp_pwm > MaxPWM) // Strombegrenzung |
||
43 | { |
||
44 | tmp_pwm = MaxPWM; |
||
45 | PORTC |= ROT; |
||
46 | } |
||
47 | if(Strom > MAX_STROM) // Strombegrenzung |
||
48 | { |
||
49 | OCR1A = 0; OCR1B = 0; OCR2 = 0; |
||
50 | PORTC |= ROT; |
||
51 | Strom--; |
||
52 | } |
||
53 | else |
||
54 | { |
||
55 | #ifdef _32KHZ |
||
56 | OCR1A = tmp_pwm; OCR1B = tmp_pwm; OCR2 = tmp_pwm; |
||
57 | #endif |
||
58 | |||
59 | #ifdef _16KHZ |
||
50 | holgerb | 60 | //OCR1A = 2 * (int)tmp_pwm; OCR1B = 2 * (int)tmp_pwm; OCR2 = tmp_pwm; |
61 | OCR1A = tmp_pwm; OCR1B = tmp_pwm; OCR2 = tmp_pwm; |
||
1 | ingob | 62 | #endif |
63 | } |
||
64 | } |
||
65 | |||
66 | //############################################################################ |
||
67 | // |
||
68 | void PWM_Init(void) |
||
69 | //############################################################################ |
||
70 | { |
||
71 | PWM_OFF; |
||
50 | holgerb | 72 | TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (0 << WGM12) | |
1 | ingob | 73 | (0 << WGM13) | (0<< ICES1) | (0 << ICNC1); |
50 | holgerb | 74 | /* TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (1 << WGM12) | |
75 | (0 << WGM13) | (0<< ICES1) | (0 << ICNC1); |
||
76 | */ |
||
1 | ingob | 77 | } |
78 | |||
79 | //############################################################################ |
||
80 | // |
||
81 | void Wait(unsigned char dauer) |
||
82 | //############################################################################ |
||
83 | { |
||
84 | dauer = (unsigned char)TCNT0 + dauer; |
||
85 | while((TCNT0 - dauer) & 0x80); |
||
86 | } |
||
87 | |||
88 | //############################################################################ |
||
89 | // |
||
90 | void Anwerfen(unsigned char pwm) |
||
91 | //############################################################################ |
||
92 | { |
||
93 | unsigned long timer = 300,i; |
||
94 | DISABLE_SENSE_INT; |
||
95 | PWM = 5; |
||
96 | SetPWM(); |
||
97 | Manuell(); |
||
98 | Delay_ms(200); |
||
99 | PWM = pwm; |
||
100 | while(1) |
||
101 | { |
||
102 | for(i=0;i<timer; i++) |
||
103 | { |
||
104 | if(!UebertragungAbgeschlossen) SendUart(); |
||
105 | else DatenUebertragung(); |
||
106 | Wait(100); // warten |
||
107 | } |
||
108 | timer-= timer/15+1; |
||
109 | if(timer < 25) { if(TEST_MANUELL) timer = 25; else return; } |
||
110 | |||
111 | Manuell(); |
||
112 | Phase++; |
||
113 | Phase %= 6; |
||
114 | AdConvert(); |
||
115 | PWM = pwm; |
||
116 | SetPWM(); |
||
117 | if(SENSE) |
||
118 | { |
||
119 | PORTD ^= GRUEN; |
||
120 | } |
||
121 | } |
||
122 | } |
||
123 | |||
50 | holgerb | 124 | /* |
125 | #define SENSE_A ADMUX = 0; |
||
126 | #define SENSE_B ADMUX = 1; |
||
127 | #define SENSE_C ADMUX = 2; |
||
128 | |||
129 | #define ClrSENSE ACSR |= 0x10 |
||
130 | #define SENSE ((ACSR & 0x10)) |
||
131 | #define SENSE_L (!(ACSR & 0x20)) |
||
132 | #define SENSE_H ((ACSR & 0x20)) |
||
133 | */ |
||
134 | |||
135 | void RotBlink(unsigned char anz) |
||
136 | { |
||
137 | sei(); // Interrupts ein |
||
138 | while(anz--) |
||
139 | { |
||
140 | PORTC |= ROT; |
||
141 | Delay_ms(300); |
||
142 | PORTC &= ~ROT; |
||
143 | Delay_ms(300); |
||
144 | } |
||
145 | Delay_ms(1000); |
||
146 | } |
||
147 | |||
58 | hbuss | 148 | #define TEST_STROMGRENZE 120 |
50 | holgerb | 149 | unsigned char DelayM(unsigned int timer) |
150 | { |
||
151 | while(timer--) |
||
152 | { |
||
153 | FastADConvert(); |
||
58 | hbuss | 154 | if(Strom > (TEST_STROMGRENZE + RuheStrom)) |
50 | holgerb | 155 | { |
51 | holgerb | 156 | FETS_OFF; |
50 | holgerb | 157 | return(1); |
158 | } |
||
159 | } |
||
160 | return(0); |
||
161 | } |
||
162 | |||
163 | unsigned char Delay(unsigned int timer) |
||
164 | { |
||
165 | while(timer--) |
||
166 | { |
||
51 | holgerb | 167 | // if(SENSE_H) { PORTC |= ROT; } else { PORTC &= ~ROT;} |
50 | holgerb | 168 | } |
169 | return(0); |
||
170 | } |
||
171 | |||
58 | hbuss | 172 | /* |
51 | holgerb | 173 | void ShowSense(void) |
174 | { |
||
175 | if(SENSE_H) { PORTC |= ROT; } else { PORTC &= ~ROT;} |
||
50 | holgerb | 176 | |
51 | holgerb | 177 | } |
58 | hbuss | 178 | */ |
51 | holgerb | 179 | #define HIGH_A_EIN PORTB |= 0x08 |
180 | #define HIGH_B_EIN PORTB |= 0x04 |
||
181 | #define HIGH_C_EIN PORTB |= 0x02 |
||
182 | #define LOW_A_EIN PORTD |= 0x08 |
||
183 | #define LOW_B_EIN PORTD |= 0x10 |
||
184 | #define LOW_C_EIN PORTD |= 0x20 |
||
185 | |||
50 | holgerb | 186 | void MotorTon(void) |
1 | ingob | 187 | //############################################################################ |
50 | holgerb | 188 | { |
51 | holgerb | 189 | unsigned char ADR_TAB[5] = {0,0,2,1,3}; |
50 | holgerb | 190 | unsigned int timer = 300,i; |
51 | holgerb | 191 | unsigned int t = 0; |
58 | hbuss | 192 | unsigned char anz = 0,MosfetOkay = 0, grenze = 50; |
51 | holgerb | 193 | |
194 | PORTC &= ~ROT; |
||
195 | Delay_ms(300 * ADR_TAB[MotorAdresse]); |
||
50 | holgerb | 196 | DISABLE_SENSE_INT; |
197 | cli();//Globale Interrupts Ausschalten |
||
198 | uart_putchar('\n'); |
||
199 | STEUER_OFF; |
||
58 | hbuss | 200 | Strom_max = 0; |
201 | DelayM(50); |
||
202 | RuheStrom = Strom_max; |
||
203 | // uart_putchar(RuheStrom + 'A'); |
||
50 | holgerb | 204 | //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
205 | //+ High-Mosfets auf Kurzschluss testen |
||
206 | //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
||
207 | Strom = 0; |
||
51 | holgerb | 208 | LOW_B_EIN; |
209 | HIGH_A_EIN; |
||
50 | holgerb | 210 | if(DelayM(3)) |
211 | { |
||
212 | anz = 1; |
||
51 | holgerb | 213 | uart_putchar('1'); |
50 | holgerb | 214 | } |
51 | holgerb | 215 | FETS_OFF; |
216 | Delay(1000); |
||
50 | holgerb | 217 | Strom = 0; |
51 | holgerb | 218 | LOW_A_EIN; |
219 | HIGH_B_EIN; |
||
50 | holgerb | 220 | if(DelayM(3)) |
221 | { |
||
222 | anz = 2; |
||
51 | holgerb | 223 | uart_putchar('2'); |
50 | holgerb | 224 | } |
51 | holgerb | 225 | FETS_OFF; |
226 | Delay(1000); |
||
50 | holgerb | 227 | Strom = 0; |
51 | holgerb | 228 | LOW_B_EIN; // Low C ein |
229 | HIGH_C_EIN; // High B ein |
||
50 | holgerb | 230 | if(DelayM(3)) |
231 | { |
||
232 | anz = 3; |
||
51 | holgerb | 233 | uart_putchar('3'); |
50 | holgerb | 234 | } |
51 | holgerb | 235 | FETS_OFF; |
236 | Delay(1000); |
||
237 | LOW_A_EIN; // Low A ein; und A gegen C |
||
238 | HIGH_C_EIN; // High C ein |
||
50 | holgerb | 239 | if(DelayM(3)) |
240 | { |
||
241 | anz = 3; |
||
51 | holgerb | 242 | uart_putchar('7'); |
50 | holgerb | 243 | } |
51 | holgerb | 244 | FETS_OFF; |
245 | DelayM(10000); |
||
246 | if(anz) while(1) RotBlink(anz); // bei Kurzschluss nicht starten |
||
247 | |||
50 | holgerb | 248 | //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
51 | holgerb | 249 | //+ LOW-Mosfets auf Schalten und Kurzschluss testen |
50 | holgerb | 250 | //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
58 | hbuss | 251 | if(UDR == ' ') {t = 65535; grenze = 40; uart_putchar('_');} else t = 1000; // Ausführlicher Test |
51 | holgerb | 252 | Strom = 0; |
253 | for(i=0;i<t;i++) |
||
254 | { |
||
255 | LOW_A_EIN; |
||
256 | DelayM(1); |
||
257 | FETS_OFF; |
||
258 | Delay(5); |
||
259 | HIGH_A_EIN; |
||
260 | DelayM(1); |
||
261 | FETS_OFF; |
||
58 | hbuss | 262 | if(Strom > grenze + RuheStrom) {anz = 4; uart_putchar('4'); break;} |
51 | holgerb | 263 | Delay(5); |
264 | } |
||
265 | Delay(10000); |
||
50 | holgerb | 266 | |
51 | holgerb | 267 | Strom = 0; |
268 | for(i=0;i<t;i++) |
||
269 | { |
||
270 | LOW_B_EIN; |
||
271 | DelayM(1); |
||
272 | FETS_OFF; |
||
273 | Delay(5); |
||
274 | HIGH_B_EIN; |
||
275 | DelayM(1); |
||
276 | FETS_OFF; |
||
58 | hbuss | 277 | if(Strom > grenze + RuheStrom) {anz = 5; uart_putchar('5'); break;} |
51 | holgerb | 278 | Delay(5); |
279 | } |
||
50 | holgerb | 280 | |
51 | holgerb | 281 | Strom = 0; |
282 | Delay(10000); |
||
283 | |||
284 | for(i=0;i<t;i++) |
||
285 | { |
||
286 | LOW_C_EIN; |
||
287 | DelayM(1); |
||
288 | FETS_OFF; |
||
289 | Delay(5); |
||
290 | HIGH_C_EIN; |
||
291 | DelayM(1); |
||
292 | FETS_OFF; |
||
58 | hbuss | 293 | if(Strom > grenze + RuheStrom) {anz = 6; uart_putchar('6'); break;} |
51 | holgerb | 294 | Delay(5); |
295 | } |
||
296 | |||
50 | holgerb | 297 | //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
298 | //+ High-Mosfets auf Schalten testen |
||
299 | //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
||
300 | SENSE_A; |
||
51 | holgerb | 301 | FETS_OFF; |
302 | LOW_B_EIN; // Low B ein |
||
303 | LOW_C_EIN; // Low C ein |
||
50 | holgerb | 304 | Strom = 0; |
51 | holgerb | 305 | #define TONDAUER 40000 |
306 | #define SOUND_E 2 |
||
307 | #define SOUND1_A 300 |
||
308 | #define SOUND2_A 330 |
||
309 | #define SOUND3_A 360 |
||
310 | |||
50 | holgerb | 311 | for(i=0; i< (TONDAUER / SOUND2_A) ; i++) |
312 | { |
||
51 | holgerb | 313 | HIGH_A_EIN; // Test A |
50 | holgerb | 314 | Delay(SOUND_E); |
51 | holgerb | 315 | if(MessAD(0) > 50) { MosfetOkay |= 0x01; } else { MosfetOkay &= ~0x01;}; |
50 | holgerb | 316 | PORTB = 0; |
51 | holgerb | 317 | Delay(SOUND1_A); |
50 | holgerb | 318 | } |
51 | holgerb | 319 | FETS_OFF; |
320 | |||
321 | LOW_A_EIN; // Low A ein |
||
322 | LOW_C_EIN; // Low C ein |
||
50 | holgerb | 323 | for(i=0; i<(TONDAUER / SOUND1_A); i++) |
324 | { |
||
51 | holgerb | 325 | HIGH_B_EIN; // Test B |
50 | holgerb | 326 | Delay(SOUND_E); |
51 | holgerb | 327 | if(MessAD(1) > 50) { MosfetOkay |= 0x02; } else { MosfetOkay &= ~0x02;}; |
50 | holgerb | 328 | PORTB = 0; |
329 | Delay(SOUND1_A); |
||
330 | } |
||
331 | |||
51 | holgerb | 332 | FETS_OFF; |
333 | LOW_A_EIN; // Low A ein |
||
334 | LOW_B_EIN; // Low B ein |
||
50 | holgerb | 335 | for(i=0; i<(TONDAUER / SOUND3_A); i++) |
336 | { |
||
51 | holgerb | 337 | HIGH_C_EIN; // Test C |
50 | holgerb | 338 | Delay(SOUND_E); |
51 | holgerb | 339 | if(MessAD(2) > 50) { MosfetOkay |= 0x04; } else { MosfetOkay &= ~0x04;}; |
50 | holgerb | 340 | PORTB = 0; |
51 | holgerb | 341 | Delay(SOUND2_A); |
50 | holgerb | 342 | } |
51 | holgerb | 343 | FETS_OFF; |
50 | holgerb | 344 | //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
345 | //+ Low-Mosfets auf Schalten testen |
||
346 | //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
||
347 | SENSE_B; |
||
51 | holgerb | 348 | LOW_A_EIN; // Low A ein |
50 | holgerb | 349 | for(i=0; i< (TONDAUER / SOUND2_A) ; i++) |
350 | { |
||
51 | holgerb | 351 | HIGH_B_EIN; // Test B |
50 | holgerb | 352 | Delay(SOUND_E); |
51 | holgerb | 353 | if(MessAD(0) > 50) { MosfetOkay &= ~0x08;} else { MosfetOkay |= 0x08;}; |
50 | holgerb | 354 | PORTB = 0; |
355 | Delay(SOUND2_A); |
||
356 | } |
||
51 | holgerb | 357 | |
358 | //++++++++++++++++++++++++++++++++++++ |
||
359 | LOW_C_EIN; // Low C ein |
||
360 | for(i=0; i<(TONDAUER / SOUND1_A); i++) |
||
50 | holgerb | 361 | { |
51 | holgerb | 362 | HIGH_B_EIN; // Test B |
50 | holgerb | 363 | Delay(SOUND_E); |
51 | holgerb | 364 | if(MessAD(2) > 50) { MosfetOkay &= ~0x20;} else { MosfetOkay |= 0x20;}; |
50 | holgerb | 365 | PORTB = 0; |
366 | Delay(SOUND3_A); |
||
367 | } |
||
51 | holgerb | 368 | FETS_OFF; |
369 | //++++++++++++++++++++++++++++++++++++ |
||
370 | FETS_OFF; |
||
371 | LOW_B_EIN; // Low B ein |
||
372 | for(i=0; i<(TONDAUER / SOUND3_A); i++) |
||
50 | holgerb | 373 | { |
51 | holgerb | 374 | HIGH_C_EIN; // Test C |
50 | holgerb | 375 | Delay(SOUND_E); |
51 | holgerb | 376 | if(MessAD(1) > 50) { MosfetOkay &= ~0x10;} else { MosfetOkay |= 0x10;}; |
50 | holgerb | 377 | PORTB = 0; |
51 | holgerb | 378 | Delay(SOUND3_A); |
50 | holgerb | 379 | } |
51 | holgerb | 380 | FETS_OFF; |
381 | //++++++++++++++++++++++++++++++++++++ |
||
50 | holgerb | 382 | |
51 | holgerb | 383 | //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
50 | holgerb | 384 | sei();//Globale Interrupts Einschalten |
51 | holgerb | 385 | // Delay_ms(250 * MotorAdresse); |
386 | /* |
||
387 | LOW_A_EIN; // Low B ein |
||
50 | holgerb | 388 | #define SOUND8_A 650 |
389 | for(i=0; i<(TONDAUER / SOUND8_A); i++) |
||
390 | { |
||
51 | holgerb | 391 | HIGH_B_EIN; // Test B |
392 | Delay(SOUND_E); |
||
393 | PORTB = 0; |
||
394 | Delay(SOUND8_A); |
||
50 | holgerb | 395 | } |
51 | holgerb | 396 | */ |
397 | Delay_ms(300 * (4-ADR_TAB[MotorAdresse])); |
||
58 | hbuss | 398 | if(!(MosfetOkay & 0x01)) { anz = 1; UDR='A'; } else |
399 | if(!(MosfetOkay & 0x02)) { anz = 2; UDR='B'; } else |
||
400 | if(!(MosfetOkay & 0x04)) { anz = 3; UDR='C'; } else |
||
401 | if(!(MosfetOkay & 0x08)) { anz = 4; UDR='a'; } else |
||
402 | if(!(MosfetOkay & 0x10)) { anz = 5; UDR='b'; } else |
||
403 | if(!(MosfetOkay & 0x20)) { anz = 6; UDR='c'; } |
||
50 | holgerb | 404 | |
58 | hbuss | 405 | if(anz) Delay_ms(1000); |
50 | holgerb | 406 | |
51 | holgerb | 407 | RotBlink(anz); |
408 | uart_putchar('.'); |
||
50 | holgerb | 409 | } |
410 | |||
411 | //############################################################################ |
||
1 | ingob | 412 | // |
413 | unsigned char SollwertErmittlung(void) |
||
414 | //############################################################################ |
||
415 | { |
||
416 | static unsigned int sollwert = 0; |
||
417 | unsigned int ppm; |
||
418 | if(!I2C_Timeout) // bei Erreichen von 0 ist der Wert ungültig |
||
419 | { |
||
420 | if(SIO_Timeout) // es gibt gültige SIO-Daten |
||
421 | { |
||
50 | holgerb | 422 | sollwert = (MAX_PWM * (unsigned int) SIO_Sollwert) / 200; // skalieren auf 0-200 = 0-255 |
423 | PPM_Betrieb = 0; |
||
424 | ICP_INT_DISABLE; |
||
425 | PORTC &= ~ROT; |
||
1 | ingob | 426 | } |
427 | else |
||
50 | holgerb | 428 | if(anz_ppm_werte > 20) // es gibt gültige PPM-Daten |
1 | ingob | 429 | { |
50 | holgerb | 430 | PPM_Betrieb = 1; |
1 | ingob | 431 | ppm = PPM_Signal; |
432 | if(ppm > 300) ppm = 0; // ungültiges Signal |
||
433 | if(ppm > 200) ppm = 200; |
||
434 | if(ppm <= MIN_PPM) sollwert = 0; |
||
435 | else |
||
436 | { |
||
437 | sollwert = (int) MIN_PWM + ((MAX_PWM - MIN_PWM) * (ppm - MIN_PPM)) / (190 - MIN_PPM); |
||
438 | } |
||
439 | PORTC &= ~ROT; |
||
440 | } |
||
441 | else // Kein gültiger Sollwert |
||
442 | { |
||
50 | holgerb | 443 | if(!TEST_SCHUB) { if(sollwert) sollwert--; } |
444 | PORTC |= ROT; |
||
1 | ingob | 445 | } |
446 | } |
||
447 | else // I2C-Daten sind gültig |
||
448 | { |
||
449 | sollwert = I2C_RXBuffer; |
||
50 | holgerb | 450 | PPM_Betrieb = 0; |
1 | ingob | 451 | PORTC &= ~ROT; |
50 | holgerb | 452 | ICP_INT_DISABLE; |
1 | ingob | 453 | } |
454 | if(sollwert > MAX_PWM) sollwert = MAX_PWM; |
||
455 | return(sollwert); |
||
456 | } |
||
457 | |||
458 | void DebugAusgaben(void) |
||
459 | { |
||
460 | DebugOut.Analog[0] = Strom; |
||
461 | DebugOut.Analog[1] = Mittelstrom; |
||
462 | DebugOut.Analog[2] = SIO_Drehzahl; |
||
463 | DebugOut.Analog[3] = PPM_Signal; |
||
464 | } |
||
465 | |||
466 | |||
467 | //############################################################################ |
||
468 | //Hauptprogramm |
||
469 | int main (void) |
||
470 | //############################################################################ |
||
471 | { |
||
472 | char altPhase = 0; |
||
473 | int test = 0; |
||
474 | unsigned int MinUpmPulse,Blink,TestschubTimer; |
||
475 | unsigned int Blink2,MittelstromTimer,DrehzahlMessTimer,MotorGestopptTimer; |
||
476 | |||
477 | DDRC = 0x08; |
||
478 | PORTC = 0x08; |
||
479 | DDRD = 0xBA; |
||
26 | ingob | 480 | PORTD = 0x00; |
1 | ingob | 481 | DDRB = 0x0E; |
482 | PORTB = 0x31; |
||
24 | ingob | 483 | |
484 | #if (MOTORADRESSE == 0) |
||
485 | PORTB |= (ADR1 + ADR2); // Pullups für Adresswahl |
||
43 | holgerb | 486 | for(test=0;test<500;test++); |
24 | ingob | 487 | if (PINB & ADR1) |
488 | { |
||
489 | if (PINB & ADR2) MotorAdresse = 1; |
||
490 | else MotorAdresse = 2; |
||
491 | } |
||
492 | else |
||
493 | { |
||
494 | if (PINB & ADR2) MotorAdresse = 3; |
||
495 | else MotorAdresse = 4; |
||
496 | } |
||
497 | #else |
||
498 | MotorAdresse = MOTORADRESSE; |
||
499 | #endif |
||
1 | ingob | 500 | |
501 | UART_Init(); |
||
502 | Timer0_Init(); |
||
50 | holgerb | 503 | sei();//Globale Interrupts Einschalten |
1 | ingob | 504 | |
505 | // Am Blinken erkennt man die richtige Motoradresse |
||
50 | holgerb | 506 | /* |
1 | ingob | 507 | for(test=0;test<5;test++) |
508 | { |
||
24 | ingob | 509 | if(test == MotorAdresse) PORTD |= GRUEN; |
1 | ingob | 510 | Delay_ms(150); |
511 | PORTD &= ~GRUEN; |
||
512 | Delay_ms(250); |
||
513 | } |
||
514 | |||
515 | Delay_ms(500); |
||
50 | holgerb | 516 | */ |
18 | ingob | 517 | // UART_Init(); // war doppelt |
1 | ingob | 518 | PWM_Init(); |
519 | |||
520 | InitIC2_Slave(0x50); |
||
521 | InitPPM(); |
||
522 | |||
523 | Blink = SetDelay(101); |
||
524 | Blink2 = SetDelay(102); |
||
525 | MinUpmPulse = SetDelay(103); |
||
526 | MittelstromTimer = SetDelay(254); |
||
527 | DrehzahlMessTimer = SetDelay(1005); |
||
528 | TestschubTimer = SetDelay(1006); |
||
50 | holgerb | 529 | while(!CheckDelay(MinUpmPulse)) |
530 | { |
||
531 | if(SollwertErmittlung()) break; |
||
532 | } |
||
533 | ; |
||
1 | ingob | 534 | PORTD |= GRUEN; |
535 | PWM = 0; |
||
536 | |||
537 | SetPWM(); |
||
538 | |||
539 | SFIOR = 0x08; // Analog Comperator ein |
||
540 | ADMUX = 1; |
||
541 | |||
542 | MinUpmPulse = SetDelay(10); |
||
543 | DebugOut.Analog[1] = 1; |
||
544 | PPM_Signal = 0; |
||
545 | |||
50 | holgerb | 546 | if(!SollwertErmittlung()) MotorTon(); |
58 | hbuss | 547 | //MotorTon(); |
548 | PORTB = 0x31; // Pullups wieder einschalten |
||
50 | holgerb | 549 | |
1 | ingob | 550 | // zum Test der Hardware; Motor dreht mit konstanter Drehzahl ohne Regelung |
551 | if(TEST_MANUELL) Anwerfen(TEST_MANUELL); // kommt von dort nicht wieder |
||
552 | |||
553 | while (1) |
||
554 | { |
||
51 | holgerb | 555 | //ShowSense(); |
556 | |||
1 | ingob | 557 | if(!TEST_SCHUB) PWM = SollwertErmittlung(); |
558 | //I2C_TXBuffer = PWM; // Antwort über I2C-Bus |
||
559 | if(MANUELL_PWM) PWM = MANUELL_PWM; |
||
560 | |||
561 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
||
562 | if(Phase != altPhase) // es gab eine Kommutierung im Interrupt |
||
563 | { |
||
564 | MotorGestoppt = 0; |
||
565 | ZeitFuerBerechnungen = 0; // direkt nach einer Kommutierung ist Zeit |
||
58 | hbuss | 566 | MinUpmPulse = SetDelay(250); // Timeout, falls ein Motor stehen bleibt |
1 | ingob | 567 | altPhase = Phase; |
568 | } |
||
569 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
||
570 | if(!PWM) // Sollwert == 0 |
||
571 | { |
||
572 | MotorAnwerfen = 0; // kein Startversuch |
||
573 | ZeitFuerBerechnungen = 0; |
||
574 | // nach 1,5 Sekunden den Motor als gestoppt betrachten |
||
18 | ingob | 575 | if(CheckDelay(MotorGestopptTimer)) |
1 | ingob | 576 | { |
577 | DISABLE_SENSE_INT; |
||
578 | MotorGestoppt = 1; |
||
579 | STEUER_OFF; |
||
580 | } |
||
581 | } |
||
582 | else |
||
583 | { |
||
584 | if(MotorGestoppt) MotorAnwerfen = 1; // Startversuch |
||
585 | MotorGestopptTimer = SetDelay(1500); |
||
586 | } |
||
587 | |||
588 | if(MotorGestoppt && !TEST_SCHUB) PWM = 0; |
||
589 | SetPWM(); |
||
590 | // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
||
591 | if(!ZeitFuerBerechnungen++) |
||
592 | { |
||
593 | if(MotorGestoppt) PORTD |= GRUEN; //else PORTD &= ~GRUEN; |
||
594 | if(SIO_DEBUG) |
||
595 | { |
||
596 | DebugAusgaben(); // welche Werte sollen angezeigt werden? |
||
597 | if(!UebertragungAbgeschlossen) SendUart(); |
||
598 | else DatenUebertragung(); |
||
599 | } |
||
600 | // Berechnen des Mittleren Stroms zur (langsamen) Strombegrenzung |
||
601 | if(CheckDelay(MittelstromTimer)) |
||
602 | { |
||
603 | MittelstromTimer = SetDelay(50); // alle 50ms |
||
604 | if(Mittelstrom < Strom) Mittelstrom++;// Mittelwert des Stroms bilden |
||
605 | else if(Mittelstrom > Strom) Mittelstrom--; |
||
58 | hbuss | 606 | if(Strom > MAX_STROM) MaxPWM -= MaxPWM / 32; |
607 | if((Mittelstrom > LIMIT_STROM))// Strom am Limit? |
||
1 | ingob | 608 | { |
58 | hbuss | 609 | if(MaxPWM) MaxPWM--;// dann die Maximale PWM herunterfahren |
1 | ingob | 610 | PORTC |= ROT; |
611 | } |
||
612 | else |
||
613 | { |
||
614 | if(MaxPWM < MAX_PWM) MaxPWM++; |
||
615 | } |
||
616 | } |
||
617 | |||
618 | if(CheckDelay(DrehzahlMessTimer)) // Ist-Drehzahl bestimmen |
||
619 | { |
||
620 | DrehzahlMessTimer = SetDelay(10); |
||
58 | hbuss | 621 | SIO_Drehzahl = CntKommutierungen;//(6 * CntKommutierungen) / (POLANZAHL / 2); |
1 | ingob | 622 | CntKommutierungen = 0; |
623 | if(PPM_Timeout == 0) // keine PPM-Signale |
||
624 | ZeitZumAdWandeln = 1; |
||
625 | } |
||
626 | |||
58 | hbuss | 627 | if(TEST_SCHUB) |
628 | { |
||
1 | ingob | 629 | if(CheckDelay(TestschubTimer)) |
630 | { |
||
631 | TestschubTimer = SetDelay(1500); |
||
632 | switch(test) |
||
633 | { |
||
634 | case 0: PWM = 50; test++; break; |
||
635 | case 1: PWM = 130; test++; break; |
||
636 | case 2: PWM = 60; test++; break; |
||
637 | case 3: PWM = 140; test++; break; |
||
638 | case 4: PWM = 150; test = 0; break; |
||
639 | default: test = 0; |
||
640 | } |
||
641 | } |
||
58 | hbuss | 642 | } |
643 | // Motor Stehen geblieben |
||
1 | ingob | 644 | if((CheckDelay(MinUpmPulse) && SIO_Drehzahl == 0) || MotorAnwerfen) |
645 | { |
||
646 | MotorGestoppt = 1; |
||
647 | DISABLE_SENSE_INT; |
||
648 | MinUpmPulse = SetDelay(100); |
||
649 | if(MotorAnwerfen) |
||
650 | { |
||
651 | PORTC &= ~ROT; |
||
652 | MotorAnwerfen = 0; |
||
653 | Anwerfen(10); |
||
654 | PORTD |= GRUEN; |
||
655 | MotorGestoppt = 0; |
||
656 | Phase--; |
||
657 | PWM = 1; |
||
658 | SetPWM(); |
||
659 | SENSE_TOGGLE_INT; |
||
660 | ENABLE_SENSE_INT; |
||
43 | holgerb | 661 | MinUpmPulse = SetDelay(20); |
1 | ingob | 662 | while(!CheckDelay(MinUpmPulse)); // kurz Synchronisieren |
43 | holgerb | 663 | PWM = 15; |
1 | ingob | 664 | SetPWM(); |
43 | holgerb | 665 | MinUpmPulse = SetDelay(300); |
1 | ingob | 666 | while(!CheckDelay(MinUpmPulse)); // kurz Durchstarten |
18 | ingob | 667 | |
668 | // Drehzahlmessung wieder aufsetzen |
||
669 | DrehzahlMessTimer = SetDelay(50); |
||
1 | ingob | 670 | altPhase = 7; |
671 | } |
||
672 | } |
||
673 | } // ZeitFuerBerechnungen |
||
674 | } // while(1) - Hauptschleife |
||
675 | } |
||
676 |