Subversion Repositories BL-Ctrl

Rev

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