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