Subversion Repositories BL-Ctrl

Rev

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