Subversion Repositories BL-Ctrl

Rev

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