Subversion Repositories BL-Ctrl

Rev

Rev 80 | Rev 82 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 80 Rev 81
1 
/*#######################################################################################
 1 
/*#######################################################################################
2 
Flight Control
 2 
Flight Control
3 
#######################################################################################*/
 3 
#######################################################################################*/
4 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 4 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
5 
// + Regler für Brushless-Motoren
 5 
// + Regler für Brushless-Motoren
6 
// + ATMEGA8 mit 8MHz
 6 
// + ATMEGA8 mit 8MHz
7 
// + Nur für den privaten Gebrauch
 7 
// + Nur für den privaten Gebrauch
8 
// + Copyright (c) 12.2007 Holger Buss
 8 
// + Copyright (c) 12.2007 Holger Buss
9 
// + www.MikroKopter.com
 9 
// + www.MikroKopter.com
10 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 10 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11 
// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),
11 
// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),
12 
// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.
12 
// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.
13 
// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt
13 
// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt
14 
// + bzgl. der Nutzungsbedingungen aufzunehmen.
14 
// + bzgl. der Nutzungsbedingungen aufzunehmen.
15 
// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,
 15 
// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,
16 
// + Verkauf von Luftbildaufnahmen, usw.
 16 
// + Verkauf von Luftbildaufnahmen, usw.
17 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 17 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
18 
// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,
18 
// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,
19 
// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen
 19 
// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen
20 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 20 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
21 
// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
 21 
// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
22 
// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
 22 
// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
23 
// + eindeutig als Ursprung verlinkt werden
 23 
// + eindeutig als Ursprung verlinkt werden
24 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 24 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
25 
// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion
 25 
// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion
26 
// + Benutzung auf eigene Gefahr
 26 
// + Benutzung auf eigene Gefahr
27 
// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
 27 
// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
28 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 28 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
29 
// + Die Portierung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
29 
// + Die Portierung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
30 
// + mit unserer Zustimmung zulässig
 30 
// + mit unserer Zustimmung zulässig
31 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 31 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
32 
// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
 32 
// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
33 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 33 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
34 
// + Redistributions of source code (with or without modifications) must retain the above copyright notice,
34 
// + Redistributions of source code (with or without modifications) must retain the above copyright notice,
35 
// + this list of conditions and the following disclaimer.
 35 
// + this list of conditions and the following disclaimer.
36 
// +   * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
 36 
// +   * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
37 
// +     from this software without specific prior written permission.
 37 
// +     from this software without specific prior written permission.
38 
// +   * The use of this project (hardware, software, binary files, sources and documentation) is only permittet
38 
// +   * The use of this project (hardware, software, binary files, sources and documentation) is only permittet
39 
// +     for non-commercial use (directly or indirectly)
 39 
// +     for non-commercial use (directly or indirectly)
40 
// +     Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted
40 
// +     Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted
41 
// +     with our written permission
 41 
// +     with our written permission
42 
// +   * If sources or documentations are redistributet on other webpages, our webpage (http://www.MikroKopter.de) must be
42 
// +   * If sources or documentations are redistributet on other webpages, our webpage (http://www.MikroKopter.de) must be
43 
// +     clearly linked as origin
43 
// +     clearly linked as origin
44 
// +   * porting to systems other than hardware from www.mikrokopter.de is not allowed
 44 
// +   * porting to systems other than hardware from www.mikrokopter.de is not allowed
45 
// +  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 45 
// +  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
46 
// +  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 46 
// +  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
47 
// +  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 47 
// +  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
48 
// +  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 48 
// +  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
49 
// +  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 49 
// +  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
50 
// +  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 50 
// +  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
51 
// +  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 51 
// +  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
52 
// +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN// +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 52 
// +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN// +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
53 
// +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 53 
// +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
54 
// +  POSSIBILITY OF SUCH DAMAGE.
54 
// +  POSSIBILITY OF SUCH DAMAGE.
55 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 55 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
56 
 
 56 
 
57 
#include "main.h"
 57 
#include "main.h"
58 
 
 58 
 
59 
unsigned int  PWM = 0;
 59 
unsigned int  PWM = 0;
60 
unsigned int  Strom = 0,RuheStrom; //ca. in 0,1A
 60 
unsigned int  Strom = 0,RuheStrom; //ca. in 0,1A
61 
unsigned char Strom_max = 0;
 61 
unsigned char Strom_max = 0;
62 
unsigned char Mittelstrom = 0;
 62 
unsigned char Mittelstrom = 0;
63 
unsigned int  Drehzahl = 0;  // in 100UPM  60 = 6000
 63 
unsigned int  Drehzahl = 0;  // in 100UPM  60 = 6000
64 
unsigned int  KommutierDelay = 10;
 64 
unsigned int  KommutierDelay = 10;
65 
unsigned int  I2C_Timeout = 0;
 65 
unsigned int  I2C_Timeout = 0;
66 
unsigned int SIO_Timeout = 0;
 66 
unsigned int SIO_Timeout = 0;
67 
unsigned int  SollDrehzahl = 0;
 67 
unsigned int  SollDrehzahl = 0;
68 
unsigned int  IstDrehzahl = 0;
 68 
unsigned int  IstDrehzahl = 0;
69 
unsigned int  DrehZahlTabelle[256];//vorberechnete Werte zur Drehzahlerfassung
 69 
unsigned int  DrehZahlTabelle[256];//vorberechnete Werte zur Drehzahlerfassung
70 
unsigned char ZeitFuerBerechnungen = 1;
 70 
unsigned char ZeitFuerBerechnungen = 1;
71 
unsigned char MotorAnwerfen = 0;
 71 
unsigned char MotorAnwerfen = 0;
72 
unsigned char MotorGestoppt = 1;
 72 
unsigned char MotorGestoppt = 1;
73 
unsigned char MaxPWM = MAX_PWM;
 73 
unsigned char MaxPWM = MAX_PWM;
74 
unsigned int  CntKommutierungen = 0;
 74 
unsigned int  CntKommutierungen = 0;
75 
unsigned int  SIO_Drehzahl = 0;
 75 
unsigned int  SIO_Drehzahl = 0;
76 
unsigned char ZeitZumAdWandeln = 1;
 76 
unsigned char ZeitZumAdWandeln = 1;
77 
unsigned char MotorAdresse = 1;
 77 
unsigned char MotorAdresse = 1;
78 
unsigned char PPM_Betrieb = 1;
 78 
unsigned char PPM_Betrieb = 1;
79 
unsigned char HwVersion;
 79 
unsigned char HwVersion;
80 
unsigned char IntRef = 0;
 80 
unsigned char IntRef = 0;
81 
unsigned int MinUpmPulse;
 81 
unsigned int MinUpmPulse;
82 
//############################################################################
 82 
//############################################################################
83 
//
 83 
//
84 
void SetPWM(void)
 84 
void SetPWM(void)
85 
//############################################################################
 85 
//############################################################################
86 
{
 86 
{
87 
    unsigned char tmp_pwm;
 87 
    unsigned char tmp_pwm;
88 
    tmp_pwm = PWM;
 88 
    tmp_pwm = PWM;
89 
    if(tmp_pwm > MaxPWM)    // Strombegrenzung
 89 
    if(tmp_pwm > MaxPWM)    // Strombegrenzung
90 
        {
 90 
        {
91 
        tmp_pwm = MaxPWM;
 91 
        tmp_pwm = MaxPWM;
92 
        PORTC |= ROT;
 92 
        PORTC |= ROT;
93 
        }
 93 
        }
94 
    if(Strom > MAX_STROM)   // Strombegrenzung
 94 
    if(Strom > MAX_STROM)   // Strombegrenzung
95 
        {
 95 
        {
96 
        OCR1A = 0; OCR1B = 0; OCR2 = 0;
 96 
        OCR1A = 0; OCR1B = 0; OCR2 = 0;
97 
        PORTD &= ~0x38;
 97 
        PORTD &= ~0x38;
98 
        PORTC |= ROT;
 98 
        PORTC |= ROT;
99 
        DebugOut.Analog[6]++;
 99 
        DebugOut.Analog[6]++;
100 
        Strom--;
 100 
        Strom--;
101 
        }
 101 
        }
102 
    else
 102 
    else
103 
        {
 103 
        {
104 
        #ifdef  _32KHZ
104 
        #ifdef  _32KHZ
105 
        OCR1A =  tmp_pwm; OCR1B =  tmp_pwm; OCR2  = tmp_pwm;
 105 
        OCR1A =  tmp_pwm; OCR1B =  tmp_pwm; OCR2  = tmp_pwm;
106 
        #endif
106 
        #endif
107 
 
 107 
 
108 
        #ifdef  _16KHZ
108 
        #ifdef  _16KHZ
109 
        //OCR1A = 2 * (int)tmp_pwm; OCR1B = 2 * (int)tmp_pwm; OCR2  = tmp_pwm;
 109 
        //OCR1A = 2 * (int)tmp_pwm; OCR1B = 2 * (int)tmp_pwm; OCR2  = tmp_pwm;
110 
        OCR1A =  tmp_pwm; OCR1B =  tmp_pwm; OCR2  = tmp_pwm;
 110 
        OCR1A =  tmp_pwm; OCR1B =  tmp_pwm; OCR2  = tmp_pwm;
111 
        #endif
111 
        #endif
112 
        }
 112 
        }
113 
}
 113 
}
114 
 
 114 
 
115 
void DebugAusgaben(void)
 115 
void DebugAusgaben(void)
116 
{
 116 
{
117 
    DebugOut.Analog[0] = Strom;
 117 
    DebugOut.Analog[0] = Strom;
118 
    DebugOut.Analog[1] = Mittelstrom;
 118 
    DebugOut.Analog[1] = Mittelstrom;
119 
    DebugOut.Analog[2] = SIO_Drehzahl;
 119 
    DebugOut.Analog[2] = SIO_Drehzahl;
120 
    DebugOut.Analog[3] = PPM_Signal;
 120 
    DebugOut.Analog[3] = PPM_Signal;
121 
    DebugOut.Analog[4] = OCR2;
 121 
    DebugOut.Analog[4] = OCR2;
122 
//    DebugOut.Analog[5] = PWM;
 122 
//    DebugOut.Analog[5] = PWM;
123 
}
 123 
}
124 
 
 124 
 
125 
//############################################################################
 125 
//############################################################################
126 
//
 126 
//
127 
void PWM_Init(void)
 127 
void PWM_Init(void)
128 
//############################################################################
 128 
//############################################################################
129 
{
 129 
{
130 
    PWM_OFF;
 130 
    PWM_OFF;
131 
    TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (0 << WGM12) |
 131 
    TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (0 << WGM12) |
132 
             (0 << WGM13) | (0<< ICES1) | (0 << ICNC1);
 132 
             (0 << WGM13) | (0<< ICES1) | (0 << ICNC1);
133 
/*    TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (1 << WGM12) |
 133 
/*    TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (1 << WGM12) |
134 
             (0 << WGM13) | (0<< ICES1) | (0 << ICNC1);
 134 
             (0 << WGM13) | (0<< ICES1) | (0 << ICNC1);
135 
*/
 135 
*/
136 
}
 136 
}
137 
 
 137 
 
138 
//############################################################################
 138 
//############################################################################
139 
//
 139 
//
140 
void Wait(unsigned char dauer)
 140 
void Wait(unsigned char dauer)
141 
//############################################################################
 141 
//############################################################################
142 
{
 142 
{
143 
    dauer = (unsigned char)TCNT0 + dauer;
 143 
    dauer = (unsigned char)TCNT0 + dauer;
144 
    while((TCNT0 - dauer) & 0x80);
 144 
    while((TCNT0 - dauer) & 0x80);
145 
}
 145 
}
146 
 
 146 
 
147 
void RotBlink(unsigned char anz)
 147 
void RotBlink(unsigned char anz)
148 
{
 148 
{
149 
sei(); // Interrupts ein
 149 
sei(); // Interrupts ein
150 
 while(anz--)
 150 
 while(anz--)
151 
  {
 151 
  {
152 
   PORTC |= ROT;
 152 
   PORTC |= ROT;
153 
   Delay_ms(300);    
 153 
   Delay_ms(300);    
154 
   PORTC &= ~ROT;
 154 
   PORTC &= ~ROT;
155 
   Delay_ms(300);    
 155 
   Delay_ms(300);    
156 
  }
 156 
  }
157 
   Delay_ms(1000);    
 157 
   Delay_ms(1000);    
158 
}
 158 
}
159 
 
 159 
 
160 
//############################################################################
 160 
//############################################################################
161 
//
 161 
//
162 
char Anwerfen(unsigned char pwm)
 162 
char Anwerfen(unsigned char pwm)
163 
//############################################################################
 163 
//############################################################################
164 
{
 164 
{
165 
    unsigned long timer = 300,i;
 165 
    unsigned long timer = 300,i;
166 
    DISABLE_SENSE_INT;
 166 
    DISABLE_SENSE_INT;
167 
    PWM = 5;
 167 
    PWM = 5;
168 
    SetPWM();
 168 
    SetPWM();
169 
    Manuell();
 169 
    Manuell();
170 
//    Delay_ms(200);
 170 
//    Delay_ms(200);
171 
                    MinUpmPulse = SetDelay(300);
 171 
                    MinUpmPulse = SetDelay(300);
172 
                    while(!CheckDelay(MinUpmPulse))
 172 
                    while(!CheckDelay(MinUpmPulse))
173 
                    {
 173 
                    {
174 
                     FastADConvert();
 174 
                     FastADConvert();
175 
                      if(Strom > 120)
 175 
                      if(Strom > 120)
176 
                      {
 176 
                      {
177 
                        STEUER_OFF; // Abschalten wegen Kurzschluss
 177 
                        STEUER_OFF; // Abschalten wegen Kurzschluss
178 
                        RotBlink(10);
 178 
                        RotBlink(10);
179 
                        return(0);
 179 
                        return(0);
180 
                      }  
 180 
                      }  
181 
                    }
 181 
                    }
182 
    PWM = pwm;
 182 
    PWM = pwm;
183 
    while(1)
 183 
    while(1)
184 
        {
 184 
        {
185 
        for(i=0;i<timer; i++)
 185 
        for(i=0;i<timer; i++)
186 
            {
 186 
            {
187 
            if(!UebertragungAbgeschlossen)  SendUart();
 187 
            if(!UebertragungAbgeschlossen)  SendUart();
188 
            else DatenUebertragung();
 188 
            else DatenUebertragung();
189 
            Wait(100);  // warten
 189 
            Wait(100);  // warten
190 
            }
 190 
            }
191 
        DebugAusgaben();
 191 
        DebugAusgaben();
192 
        FastADConvert();
 192 
        FastADConvert();
193 
        if(Strom > 60)
 193 
        if(Strom > 60)
194 
          {
 194 
          {
195 
            STEUER_OFF; // Abschalten wegen Kurzschluss
 195 
            STEUER_OFF; // Abschalten wegen Kurzschluss
196 
            RotBlink(10);
 196 
            RotBlink(10);
197 
            return(0);
 197 
            return(0);
198 
          }  
 198 
          }  
199 
         
 199 
         
200 
        timer-= timer/15+1;
 200 
        timer-= timer/15+1;
201 
        if(timer < 25) { if(TEST_MANUELL) timer = 25; else return(1); }
 201 
        if(timer < 25) { if(TEST_MANUELL) timer = 25; else return(1); }
202 
        Manuell();
 202 
        Manuell();
203 
        Phase++;
 203 
        Phase++;
204 
        Phase %= 6;
 204 
        Phase %= 6;
205 
        AdConvert();
 205 
        AdConvert();
206 
        PWM = pwm;
 206 
        PWM = pwm;
207 
        SetPWM();
 207 
        SetPWM();
208 
        if(SENSE)
 208 
        if(SENSE)
209 
            {
 209 
            {
210 
            PORTD ^= GRUEN;
 210 
            PORTD ^= GRUEN;
211 
            }
 211 
            }
212 
        }
 212 
        }
213 
}
 213 
}
214 
 
 214 
 
215 
/*
 215 
/*
216 
#define SENSE_A ADMUX = 0;
 216 
#define SENSE_A ADMUX = 0;
217 
#define SENSE_B ADMUX = 1;
 217 
#define SENSE_B ADMUX = 1;
218 
#define SENSE_C ADMUX = 2;
 218 
#define SENSE_C ADMUX = 2;
219 
 
 219 
 
220 
#define ClrSENSE            ACSR |= 0x10
 220 
#define ClrSENSE            ACSR |= 0x10
221 
#define SENSE               ((ACSR & 0x10))
 221 
#define SENSE               ((ACSR & 0x10))
222 
#define SENSE_L             (!(ACSR & 0x20))
 222 
#define SENSE_L             (!(ACSR & 0x20))
223 
#define SENSE_H             ((ACSR & 0x20))
 223 
#define SENSE_H             ((ACSR & 0x20))
224 
*/
 224 
*/
225 
 
 225 
 
226 
 
 226 
 
227 
#define TEST_STROMGRENZE 120
 227 
#define TEST_STROMGRENZE 120
228 
unsigned char DelayM(unsigned int timer)
 228 
unsigned char DelayM(unsigned int timer)
229 
{
 229 
{
230 
 while(timer--)
 230 
 while(timer--)
231 
  {
 231 
  {
232 
   FastADConvert();
 232 
   FastADConvert();
233 
   if(Strom > (TEST_STROMGRENZE + RuheStrom))
 233 
   if(Strom > (TEST_STROMGRENZE + RuheStrom))
234 
       {
 234 
       {
235 
        FETS_OFF;
 235 
        FETS_OFF;
236 
        return(1);
 236 
        return(1);
237 
       }
 237 
       }
238 
  }
 238 
  }
239 
 return(0);  
 239 
 return(0);  
240 
}
 240 
}
241 
 
 241 
 
242 
unsigned char Delay(unsigned int timer)
 242 
unsigned char Delay(unsigned int timer)
243 
{
 243 
{
244 
 while(timer--)
 244 
 while(timer--)
245 
  {
 245 
  {
246 
//   if(SENSE_H) { PORTC |= ROT; } else { PORTC &= ~ROT;}
 246 
//   if(SENSE_H) { PORTC |= ROT; } else { PORTC &= ~ROT;}
- 
 
 247 
        asm volatile("");
247 
  }
 248 
  }
248 
 return(0);  
 249 
 return(0);  
249 
}
 250 
}
250 
 
 251 
 
251 
/*
 252 
/*
252 
void ShowSense(void)
 253 
void ShowSense(void)
253 
{
 254 
{
254 
 if(SENSE_H) { PORTC |= ROT; } else { PORTC &= ~ROT;}
 255 
 if(SENSE_H) { PORTC |= ROT; } else { PORTC &= ~ROT;}
255 
 
 256 
 
256 
}
 257 
}
257 
*/
 258 
*/
258 
#define HIGH_A_EIN PORTB |= 0x08
 259 
#define HIGH_A_EIN PORTB |= 0x08
259 
#define HIGH_B_EIN PORTB |= 0x04
 260 
#define HIGH_B_EIN PORTB |= 0x04
260 
#define HIGH_C_EIN PORTB |= 0x02
 261 
#define HIGH_C_EIN PORTB |= 0x02
261 
#define LOW_A_EIN  PORTD |= 0x08
 262 
#define LOW_A_EIN  PORTD |= 0x08
262 
#define LOW_B_EIN  PORTD |= 0x10
 263 
#define LOW_B_EIN  PORTD |= 0x10
263 
#define LOW_C_EIN  PORTD |= 0x20
 264 
#define LOW_C_EIN  PORTD |= 0x20
264 
 
 265 
 
265 
void MotorTon(void)
 266 
void MotorTon(void)
266 
//############################################################################
 267 
//############################################################################
267 
{
 268 
{
268 
    unsigned char ADR_TAB[5] = {0,0,2,1,3};
 269 
    unsigned char ADR_TAB[7] = {0,0,3,1,4,2,5};
269 
    unsigned int timer = 300,i;
 270 
    unsigned int timer = 300,i;
270 
    unsigned int t = 0;
 271 
    unsigned int t = 0;
271 
    unsigned char anz = 0,MosfetOkay = 0, grenze = 50;
 272 
    unsigned char anz = 0,MosfetOkay = 0, grenze = 50;
272 
 
 273 
 
273 
    PORTC &= ~ROT;
 274 
    PORTC &= ~ROT;
274 
    Delay_ms(300 * ADR_TAB[MotorAdresse]);    
 275 
    Delay_ms(300 * ADR_TAB[MotorAdresse]);    
275 
    DISABLE_SENSE_INT;
 276 
    DISABLE_SENSE_INT;
276 
    cli();//Globale Interrupts Ausschalten
 277 
    cli();//Globale Interrupts Ausschalten
277 
    uart_putchar('\n');
 278 
    uart_putchar('\n');
278 
    STEUER_OFF;
 279 
    STEUER_OFF;
279 
    Strom_max = 0;
 280 
    Strom_max = 0;
280 
    DelayM(50);
 281 
    DelayM(50);
281 
    RuheStrom = Strom_max;
 282 
    RuheStrom = Strom_max;
282 
//    uart_putchar(RuheStrom + 'A');
 283 
//    uart_putchar(RuheStrom + 'A');
283 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 284 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
284 
//+ High-Mosfets auf Kurzschluss testen
 285 
//+ High-Mosfets auf Kurzschluss testen
285 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 286 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
286 
    Strom = 0;
 287 
    Strom = 0;
287 
/*
 288 
/*
288 
    LOW_B_EIN;
 289 
    LOW_B_EIN;
289 
    HIGH_A_EIN;
 290 
    HIGH_A_EIN;
290 
    if(DelayM(3))
 291 
    if(DelayM(3))
291 
       {
 292 
       {
292 
        anz = 1;
 293 
        anz = 1;
293 
        uart_putchar('1');
 294 
        uart_putchar('1');
294 
       }
 295 
       }
295 
    FETS_OFF;
 296 
    FETS_OFF;
296 
    Delay(1000);
 297 
    Delay(1000);
297 
    Strom = 0;
 298 
    Strom = 0;
298 
    LOW_A_EIN;
 299 
    LOW_A_EIN;
299 
    HIGH_B_EIN;
 300 
    HIGH_B_EIN;
300 
    if(DelayM(3))
 301 
    if(DelayM(3))
301 
       {
 302 
       {
302 
        anz = 2;
 303 
        anz = 2;
303 
        uart_putchar('2');
 304 
        uart_putchar('2');
304 
       }
 305 
       }
305 
    FETS_OFF;
 306 
    FETS_OFF;
306 
    Delay(1000);
 307 
    Delay(1000);
307 
    Strom = 0;
 308 
    Strom = 0;
308 
    LOW_B_EIN; // Low C ein
 309 
    LOW_B_EIN; // Low C ein
309 
    HIGH_C_EIN; // High B ein
 310 
    HIGH_C_EIN; // High B ein
310 
    if(DelayM(3))
 311 
    if(DelayM(3))
311 
       {
 312 
       {
312 
        anz = 3;
 313 
        anz = 3;
313 
        uart_putchar('3');
 314 
        uart_putchar('3');
314 
       }
 315 
       }
315 
    FETS_OFF;
 316 
    FETS_OFF;
316 
    Delay(1000);
 317 
    Delay(1000);
317 
    LOW_A_EIN; // Low  A ein; und A gegen C
 318 
    LOW_A_EIN; // Low  A ein; und A gegen C
318 
    HIGH_C_EIN; // High C ein
 319 
    HIGH_C_EIN; // High C ein
319 
    if(DelayM(3))
 320 
    if(DelayM(3))
320 
       {
 321 
       {
321 
        anz = 3;
 322 
        anz = 3;
322 
        uart_putchar('7');
 323 
        uart_putchar('7');
323 
       }
 324 
       }
324 
    FETS_OFF;
 325 
    FETS_OFF;
325 
    DelayM(10000);
 326 
    DelayM(10000);
326 
 
 327 
 
327 
if(anz) while(1) RotBlink(anz);  // bei Kurzschluss nicht starten
 328 
if(anz) while(1) RotBlink(anz);  // bei Kurzschluss nicht starten
328 
*/
 329 
*/
329 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 330 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
330 
//+ LOW-Mosfets auf Schalten und Kurzschluss testen
 331 
//+ LOW-Mosfets auf Schalten und Kurzschluss testen
331 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 332 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
332 
 if(UDR == ' ') {t = 65535; grenze = 40; uart_putchar('_');} else t = 1000; // Ausführlicher Test
 333 
 if(UDR == ' ') {t = 65535; grenze = 40; uart_putchar('_');} else t = 1000; // Ausführlicher Test
333 
 Strom = 0;
 334 
 Strom = 0;
334 
 for(i=0;i<t;i++)
 335 
 for(i=0;i<t;i++)
335 
 {
 336 
 {
336 
  LOW_A_EIN;
 337 
  LOW_A_EIN;
337 
  DelayM(1);
 338 
  DelayM(1);
338 
  FETS_OFF;
 339 
  FETS_OFF;
339 
  Delay(5);
 340 
  Delay(5);
340 
  HIGH_A_EIN;
 341 
  HIGH_A_EIN;
341 
  DelayM(1);
 342 
  DelayM(1);
342 
  FETS_OFF;
 343 
  FETS_OFF;
343 
  if(Strom > grenze + RuheStrom) {anz = 4; uart_putchar('4'); FETS_OFF; break;}
 344 
  if(Strom > grenze + RuheStrom) {anz = 4; uart_putchar('4'); FETS_OFF; break;}
344 
  Delay(5);
 345 
  Delay(5);
345 
 }
 346 
 }
346 
 Delay(10000);
 347 
 Delay(10000);
347 
 
 348 
 
348 
 Strom = 0;
 349 
 Strom = 0;
349 
 for(i=0;i<t;i++)
 350 
 for(i=0;i<t;i++)
350 
 {
 351 
 {
351 
  LOW_B_EIN;
 352 
  LOW_B_EIN;
352 
  DelayM(1);
 353 
  DelayM(1);
353 
  FETS_OFF;
 354 
  FETS_OFF;
354 
  Delay(5);
 355 
  Delay(5);
355 
  HIGH_B_EIN;
 356 
  HIGH_B_EIN;
356 
  DelayM(1);
 357 
  DelayM(1);
357 
  FETS_OFF;
 358 
  FETS_OFF;
358 
  if(Strom > grenze + RuheStrom) {anz = 5; uart_putchar('5'); FETS_OFF;break;}
 359 
  if(Strom > grenze + RuheStrom) {anz = 5; uart_putchar('5'); FETS_OFF;break;}
359 
  Delay(5);
 360 
  Delay(5);
360 
 }
 361 
 }
361 
 
 362 
 
362 
 Strom = 0;
 363 
 Strom = 0;
363 
 Delay(10000);
 364 
 Delay(10000);
364 
 
 365 
 
365 
 for(i=0;i<t;i++)
 366 
 for(i=0;i<t;i++)
366 
 {
 367 
 {
367 
  LOW_C_EIN;
 368 
  LOW_C_EIN;
368 
  DelayM(1);
 369 
  DelayM(1);
369 
  FETS_OFF;
 370 
  FETS_OFF;
370 
  Delay(5);
 371 
  Delay(5);
371 
  HIGH_C_EIN;
 372 
  HIGH_C_EIN;
372 
  DelayM(1);
 373 
  DelayM(1);
373 
  FETS_OFF;
 374 
  FETS_OFF;
374 
  if(Strom > grenze + RuheStrom) {anz = 6; uart_putchar('6'); FETS_OFF; break;}
 375 
  if(Strom > grenze + RuheStrom) {anz = 6; uart_putchar('6'); FETS_OFF; break;}
375 
  Delay(5);
 376 
  Delay(5);
376 
 }
 377 
 }
377 
 
 378 
 
378 
 if(anz) while(1) RotBlink(anz);  // bei Kurzschluss nicht starten
 379 
 if(anz) while(1) RotBlink(anz);  // bei Kurzschluss nicht starten
379 
 
 380 
 
380 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 381 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
381 
//+ High-Mosfets auf Schalten testen
 382 
//+ High-Mosfets auf Schalten testen
382 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 383 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
383 
    SENSE_A;
 384 
    SENSE_A;
384 
    FETS_OFF;
 385 
    FETS_OFF;
385 
    LOW_B_EIN; // Low B ein
 386 
    LOW_B_EIN; // Low B ein
386 
    LOW_C_EIN; // Low C ein
 387 
    LOW_C_EIN; // Low C ein
387 
    Strom = 0;
 388 
    Strom = 0;
388 
#define TONDAUER  40000    
 389 
#define TONDAUER  40000    
389 
#define SOUND_E 1  // 1
 390 
#define SOUND_E 1  // 1
390 
#define SOUND1_A 300
 391 
#define SOUND1_A 300
391 
#define SOUND2_A 330
 392 
#define SOUND2_A 330
392 
#define SOUND3_A 360
 393 
#define SOUND3_A 360
393 
 
 394 
 
394 
    for(i=0; i< (TONDAUER / SOUND2_A) ; i++)
 395 
    for(i=0; i< (TONDAUER / SOUND2_A) ; i++)
395 
     {
 396 
     {
396 
      HIGH_A_EIN; // Test A
 397 
      HIGH_A_EIN; // Test A
397 
      Delay(SOUND_E);
 398 
      Delay(SOUND_E);
398 
      if(MessAD(0) > 50) { MosfetOkay |= 0x01; } else { MosfetOkay &= ~0x01;};
 399 
      if(MessAD(0) > 50) { MosfetOkay |= 0x01; } else { MosfetOkay &= ~0x01;};
399 
      PORTB = 0;
 400 
      PORTB = 0;
400 
      Delay(SOUND1_A);
 401 
      Delay(SOUND1_A);
401 
     }
 402 
     }
402 
    FETS_OFF;
 403 
    FETS_OFF;
403 
 
 404 
 
404 
    LOW_A_EIN; // Low A ein
 405 
    LOW_A_EIN; // Low A ein
405 
    LOW_C_EIN; // Low C ein
 406 
    LOW_C_EIN; // Low C ein
406 
    for(i=0; i<(TONDAUER / SOUND1_A); i++)
 407 
    for(i=0; i<(TONDAUER / SOUND1_A); i++)
407 
     {
 408 
     {
408 
      HIGH_B_EIN; // Test B
 409 
      HIGH_B_EIN; // Test B
409 
      Delay(SOUND_E);
 410 
      Delay(SOUND_E);
410 
      if(MessAD(1) > 50) { MosfetOkay |= 0x02; } else { MosfetOkay &= ~0x02;};
 411 
      if(MessAD(1) > 50) { MosfetOkay |= 0x02; } else { MosfetOkay &= ~0x02;};
411 
      PORTB = 0;
 412 
      PORTB = 0;
412 
      Delay(SOUND1_A);
 413 
      Delay(SOUND1_A);
413 
     }
 414 
     }
414 
 
 415 
 
415 
    FETS_OFF;
 416 
    FETS_OFF;
416 
    LOW_A_EIN; // Low A ein
 417 
    LOW_A_EIN; // Low A ein
417 
    LOW_B_EIN; // Low B ein
 418 
    LOW_B_EIN; // Low B ein
418 
    for(i=0; i<(TONDAUER / SOUND3_A); i++)
 419 
    for(i=0; i<(TONDAUER / SOUND3_A); i++)
419 
     {
 420 
     {
420 
      HIGH_C_EIN; // Test C
 421 
      HIGH_C_EIN; // Test C
421 
      Delay(SOUND_E);
 422 
      Delay(SOUND_E);
422 
      if(MessAD(2) > 50) { MosfetOkay |= 0x04; } else { MosfetOkay &= ~0x04;};
 423 
      if(MessAD(2) > 50) { MosfetOkay |= 0x04; } else { MosfetOkay &= ~0x04;};
423 
      PORTB = 0;
 424 
      PORTB = 0;
424 
      Delay(SOUND2_A);
 425 
      Delay(SOUND2_A);
425 
     }
 426 
     }
426 
    FETS_OFF;
 427 
    FETS_OFF;
427 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 428 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
428 
//+ Low-Mosfets auf Schalten testen
 429 
//+ Low-Mosfets auf Schalten testen
429 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 430 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
430 
//    SENSE_B;
 431 
//    SENSE_B;
431 
    LOW_A_EIN; // Low A ein
 432 
    LOW_A_EIN; // Low A ein
432 
    for(i=0; i< (TONDAUER / SOUND2_A) ; i++)
 433 
    for(i=0; i< (TONDAUER / SOUND2_A) ; i++)
433 
     {
 434 
     {
434 
      HIGH_B_EIN; // Test B
 435 
      HIGH_B_EIN; // Test B
435 
      Delay(SOUND_E);
 436 
      Delay(SOUND_E);
436 
      if(MessAD(0) > 128) { MosfetOkay &= ~0x08;} else { MosfetOkay |= 0x08;};
 437 
      if(MessAD(0) > 128) { MosfetOkay &= ~0x08;} else { MosfetOkay |= 0x08;};
437 
      PORTB = 0;
 438 
      PORTB = 0;
438 
      Delay(SOUND2_A);
 439 
      Delay(SOUND2_A);
439 
     }
 440 
     }
440 
 
 441 
 
441 
//++++++++++++++++++++++++++++++++++++
 442 
//++++++++++++++++++++++++++++++++++++
442 
    LOW_C_EIN; // Low C ein
 443 
    LOW_C_EIN; // Low C ein
443 
    for(i=0; i<(TONDAUER / SOUND1_A); i++)
 444 
    for(i=0; i<(TONDAUER / SOUND1_A); i++)
444 
     {
 445 
     {
445 
      HIGH_B_EIN; // Test B
 446 
      HIGH_B_EIN; // Test B
446 
      Delay(SOUND_E);
 447 
      Delay(SOUND_E);
447 
      if(MessAD(2) > 128) { MosfetOkay &= ~0x20;} else { MosfetOkay |= 0x20;};
 448 
      if(MessAD(2) > 128) { MosfetOkay &= ~0x20;} else { MosfetOkay |= 0x20;};
448 
      PORTB = 0;
 449 
      PORTB = 0;
449 
      Delay(SOUND3_A);
 450 
      Delay(SOUND3_A);
450 
     }
 451 
     }
451 
    FETS_OFF;
 452 
    FETS_OFF;
452 
//++++++++++++++++++++++++++++++++++++
 453 
//++++++++++++++++++++++++++++++++++++
453 
    FETS_OFF;
 454 
    FETS_OFF;
454 
    LOW_B_EIN; // Low B ein
 455 
    LOW_B_EIN; // Low B ein
455 
    for(i=0; i<(TONDAUER / SOUND3_A); i++)
 456 
    for(i=0; i<(TONDAUER / SOUND3_A); i++)
456 
     {
 457 
     {
457 
      HIGH_C_EIN; // Test C
 458 
      HIGH_C_EIN; // Test C
458 
      Delay(SOUND_E);
 459 
      Delay(SOUND_E);
459 
      if(MessAD(1) > 128) { MosfetOkay &= ~0x10;} else { MosfetOkay |= 0x10;};
 460 
      if(MessAD(1) > 128) { MosfetOkay &= ~0x10;} else { MosfetOkay |= 0x10;};
460 
      PORTB = 0;
 461 
      PORTB = 0;
461 
      Delay(SOUND3_A);
 462 
      Delay(SOUND3_A);
462 
     }
 463 
     }
463 
    FETS_OFF;
 464 
    FETS_OFF;
464 
//++++++++++++++++++++++++++++++++++++
 465 
//++++++++++++++++++++++++++++++++++++
465 
 
 466 
 
466 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 467 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
467 
    sei();//Globale Interrupts Einschalten
 468 
    sei();//Globale Interrupts Einschalten
468 
//    Delay_ms(250 * MotorAdresse);    
 469 
//    Delay_ms(250 * MotorAdresse);    
469 
/*
 470 
/*
470 
    LOW_A_EIN; // Low B ein
 471 
    LOW_A_EIN; // Low B ein
471 
#define SOUND8_A 650
 472 
#define SOUND8_A 650
472 
    for(i=0; i<(TONDAUER / SOUND8_A); i++)
 473 
    for(i=0; i<(TONDAUER / SOUND8_A); i++)
473 
     {
 474 
     {
474 
      HIGH_B_EIN; // Test B
 475 
      HIGH_B_EIN; // Test B
475 
      Delay(SOUND_E);
 476 
      Delay(SOUND_E);
476 
      PORTB = 0;
 477 
      PORTB = 0;
477 
      Delay(SOUND8_A);
 478 
      Delay(SOUND8_A);
478 
     }
 479 
     }
479 
*/
 480 
*/
480 
 Delay_ms(300 * (4-ADR_TAB[MotorAdresse]));    
 481 
 Delay_ms(300 * (6-ADR_TAB[MotorAdresse]));    
481 
 if(!(MosfetOkay & 0x01))  { anz = 1; UDR='A'; } else
 482 
 if(!(MosfetOkay & 0x01))  { anz = 1; UDR='A'; } else
482 
 if(!(MosfetOkay & 0x02))  { anz = 2; UDR='B'; } else
 483 
 if(!(MosfetOkay & 0x02))  { anz = 2; UDR='B'; } else
483 
 if(!(MosfetOkay & 0x04))  { anz = 3; UDR='C'; } else
 484 
 if(!(MosfetOkay & 0x04))  { anz = 3; UDR='C'; } else
484 
 if(!(MosfetOkay & 0x08))  { anz = 4; UDR='a'; } else
 485 
 if(!(MosfetOkay & 0x08))  { anz = 4; UDR='a'; } else
485 
 if(!(MosfetOkay & 0x10))  { anz = 5; UDR='b'; } else
 486 
 if(!(MosfetOkay & 0x10))  { anz = 5; UDR='b'; } else
486 
 if(!(MosfetOkay & 0x20))  { anz = 6; UDR='c'; }  
 487 
 if(!(MosfetOkay & 0x20))  { anz = 6; UDR='c'; }  
487 
 
 488 
 
488 
// if(anz) Delay_ms(1000);
489 
// if(anz) Delay_ms(1000);
489 
 if(anz) while(1) RotBlink(anz);  // bei Kurzschluss nicht starten
 490 
 if(anz) while(1) RotBlink(anz);  // bei Kurzschluss nicht starten
490 
 RotBlink(anz);
 491 
 RotBlink(anz);
491 
 uart_putchar('.');
 492 
 uart_putchar('.');
492 
}
 493 
}
493 
 
 494 
 
494 
//############################################################################
 495 
//############################################################################
495 
//
 496 
//
496 
unsigned char SollwertErmittlung(void)
 497 
unsigned char SollwertErmittlung(void)
497 
//############################################################################
 498 
//############################################################################
498 
{
 499 
{
499 
    static unsigned int sollwert = 0;
 500 
    static unsigned int sollwert = 0;
500 
    unsigned int ppm;
 501 
    unsigned int ppm;
501 
    if(!I2C_Timeout)   // bei Erreichen von 0 ist der Wert ungültig
 502 
    if(!I2C_Timeout)   // bei Erreichen von 0 ist der Wert ungültig
502 
        {
 503 
        {
503 
        if(SIO_Timeout)  // es gibt gültige SIO-Daten
 504 
        if(SIO_Timeout)  // es gibt gültige SIO-Daten
504 
            {
 505 
            {
505 
             sollwert =  (MAX_PWM * (unsigned int) SIO_Sollwert) / 200;  // skalieren auf 0-200 = 0-255
 506 
             sollwert =  (MAX_PWM * (unsigned int) SIO_Sollwert) / 200;  // skalieren auf 0-200 = 0-255
506 
             PPM_Betrieb = 0;
 507 
             PPM_Betrieb = 0;
507 
             ICP_INT_DISABLE;
 508 
             ICP_INT_DISABLE;
508 
             PORTC &= ~ROT;
 509 
             PORTC &= ~ROT;
509 
            }
 510 
            }
510 
        else
 511 
        else
511 
            if(anz_ppm_werte > 20)  // es gibt gültige PPM-Daten
 512 
            if(anz_ppm_werte > 20)  // es gibt gültige PPM-Daten
512 
                {
 513 
                {
513 
                PPM_Betrieb = 1;
 514 
                PPM_Betrieb = 1;
514 
                ppm = PPM_Signal;
 515 
                ppm = PPM_Signal;
515 
                if(ppm > 300) ppm =   0;  // ungültiges Signal
 516 
                if(ppm > 300) ppm =   0;  // ungültiges Signal
516 
                if(ppm > 200) ppm = 200;
 517 
                if(ppm > 200) ppm = 200;
517 
                if(ppm <= MIN_PPM) sollwert = 0;
 518 
                if(ppm <= MIN_PPM) sollwert = 0;
518 
                else
 519 
                else
519 
                    {
 520 
                    {
520 
                    sollwert = (int) MIN_PWM + ((MAX_PWM - MIN_PWM) * (ppm - MIN_PPM)) / (190 - MIN_PPM);
 521 
                    sollwert = (int) MIN_PWM + ((MAX_PWM - MIN_PWM) * (ppm - MIN_PPM)) / (190 - MIN_PPM);
521 
                    }
 522 
                    }
522 
                PORTC &= ~ROT;
 523 
                PORTC &= ~ROT;
523 
                }
 524 
                }
524 
            else   // Kein gültiger Sollwert
 525 
            else   // Kein gültiger Sollwert
525 
                {
 526 
                {
526 
                 if(!TEST_SCHUB) { if(sollwert) sollwert--; }  
 527 
                 if(!TEST_SCHUB) { if(sollwert) sollwert--; }  
527 
                 PORTC |= ROT;
 528 
                 PORTC |= ROT;
528 
                }
 529 
                }
529 
        }
 530 
        }
530 
    else // I2C-Daten sind gültig
 531 
    else // I2C-Daten sind gültig
531 
        {
 532 
        {
532 
        sollwert = I2C_RXBuffer;
 533 
        sollwert = I2C_RXBuffer;
533 
        PPM_Betrieb = 0;
 534 
        PPM_Betrieb = 0;
534 
        PORTC &= ~ROT;
 535 
        PORTC &= ~ROT;
535 
        ICP_INT_DISABLE;
 536 
        ICP_INT_DISABLE;
536 
        }
 537 
        }
537 
    if(sollwert > MAX_PWM) sollwert = MAX_PWM;
 538 
    if(sollwert > MAX_PWM) sollwert = MAX_PWM;
538 
    return(sollwert);
 539 
    return(sollwert);
539 
}
 540 
}
540 
 
 541 
 
541 
 
 542 
 
542 
 
 543 
 
543 
//############################################################################
 544 
//############################################################################
544 
//Hauptprogramm
 545 
//Hauptprogramm
545 
int main (void)
 546 
int main (void)
546 
//############################################################################
 547 
//############################################################################
547 
{
 548 
{
548 
    char altPhase = 0;
 549 
    char altPhase = 0;
549 
    int test = 0;
 550 
    int test = 0;
550 
    unsigned int Blink,TestschubTimer;
 551 
    unsigned int Blink,TestschubTimer;
551 
    unsigned int Blink2,MittelstromTimer,DrehzahlMessTimer,MotorGestopptTimer;
 552 
    unsigned int Blink2,MittelstromTimer,DrehzahlMessTimer,MotorGestopptTimer;
552 
 
 553 
 
553 
    DDRC  = 0x08;
 554 
    DDRC  = 0x08;
554 
    PORTC = 0x08;
 555 
    PORTC = 0x08;
555 
    DDRD  = 0x3A;
 556 
    DDRD  = 0x3A;
556 
    PORTD = 0x00;
 557 
    PORTD = 0x00;
557 
    DDRB  = 0x0E;
 558 
    DDRB  = 0x0E;
558 
    PORTB = 0x31;
 559 
    PORTB = 0x31;
559 
       
 560 
       
560 
#if (MOTORADRESSE == 0)
 561 
#if (MOTORADRESSE == 0)
561 
    PORTB |= (ADR1 + ADR2);   // Pullups für Adresswahl
 562 
    PORTB |= (ADR1 + ADR2);   // Pullups für Adresswahl
562 
    for(test=0;test<500;test++);
 563 
    for(test=0;test<500;test++);
563 
    if(PINB & ADR1)
 564 
    if(PINB & ADR1)
564 
         {
 565 
         {
565 
           if (PINB & ADR2) MotorAdresse = 1;
 566 
           if (PINB & ADR2) MotorAdresse = 1;
566 
            else MotorAdresse = 2;
 567 
            else MotorAdresse = 2;
567 
         }
 568 
         }
568 
         else
 569 
         else
569 
         {
 570 
         {
570 
           if (PINB & ADR2) MotorAdresse = 3;
 571 
           if (PINB & ADR2) MotorAdresse = 3;
571 
            else MotorAdresse = 4;
 572 
            else MotorAdresse = 4;
572 
         }
 573 
         }
573 
    HwVersion = 11;
 574 
    HwVersion = 11;
574 
#else
 575 
#else
575 
    MotorAdresse  = MOTORADRESSE;
 576 
    MotorAdresse  = MOTORADRESSE;
576 
    HwVersion = 10;
 577 
    HwVersion = 10;
577 
#endif
 578 
#endif
578 
    if(PIND & 0x80) {HwVersion = 12; IntRef = 0xc0;}    
 579 
    if(PIND & 0x80) {HwVersion = 12; IntRef = 0xc0;}    
579 
    DDRD  = 0xBA;
 580 
    DDRD  = 0xBA;
580 
    UART_Init();
 581 
    UART_Init();
581 
    Timer0_Init();
 582 
    Timer0_Init();
582 
    sei();//Globale Interrupts Einschalten
 583 
    sei();//Globale Interrupts Einschalten
583 
   
 584 
   
584 
    // Am Blinken erkennt man die richtige Motoradresse
 585 
    // Am Blinken erkennt man die richtige Motoradresse
585 
/*
 586 
/*
586 
    for(test=0;test<5;test++)
 587 
    for(test=0;test<5;test++)
587 
        {
 588 
        {
588 
        if(test == MotorAdresse) PORTD |= GRUEN;
 589 
        if(test == MotorAdresse) PORTD |= GRUEN;
589 
        Delay_ms(150);
 590 
        Delay_ms(150);
590 
        PORTD &= ~GRUEN;
 591 
        PORTD &= ~GRUEN;
591 
        Delay_ms(250);
 592 
        Delay_ms(250);
592 
        }      
 593 
        }      
593 
 
 594 
 
594 
    Delay_ms(500);
 595 
    Delay_ms(500);
595 
*/  
 596 
*/  
596 
   // UART_Init();  // war doppelt
 597 
   // UART_Init();  // war doppelt
597 
    PWM_Init();
 598 
    PWM_Init();
598 
 
 599 
 
599 
    InitIC2_Slave(0x50);                           
 600 
    InitIC2_Slave(0x50);                           
600 
    InitPPM();
 601 
    InitPPM();
601 
 
 602 
 
602 
    Blink             = SetDelay(101);    
 603 
    Blink             = SetDelay(101);    
603 
    Blink2            = SetDelay(102);
 604 
    Blink2            = SetDelay(102);
604 
    MinUpmPulse       = SetDelay(103);
 605 
    MinUpmPulse       = SetDelay(103);
605 
    MittelstromTimer  = SetDelay(254);
 606 
    MittelstromTimer  = SetDelay(254);
606 
    DrehzahlMessTimer = SetDelay(1005);
 607 
    DrehzahlMessTimer = SetDelay(1005);
607 
    TestschubTimer    = SetDelay(1006);
 608 
    TestschubTimer    = SetDelay(1006);
608 
    while(!CheckDelay(MinUpmPulse))
 609 
    while(!CheckDelay(MinUpmPulse))
609 
    {
 610 
    {
610 
     if(SollwertErmittlung()) break;
 611 
     if(SollwertErmittlung()) break;
611 
    }
 612 
    }
612 
 
 613 
 
613 
    GRN_ON;
 614 
    GRN_ON;
614 
    PWM = 0;
 615 
    PWM = 0;
615 
 
 616 
 
616 
    SetPWM();
 617 
    SetPWM();
617 
 
 618 
 
618 
    SFIOR = 0x08;  // Analog Comperator ein
 619 
    SFIOR = 0x08;  // Analog Comperator ein
619 
    ADMUX = 1;
 620 
    ADMUX = 1;
620 
 
 621 
 
621 
    MinUpmPulse = SetDelay(10);
 622 
    MinUpmPulse = SetDelay(10);
622 
    DebugOut.Analog[1] = 1;
 623 
    DebugOut.Analog[1] = 1;
623 
    PPM_Signal = 0;
 624 
    PPM_Signal = 0;
624 
 
 625 
 
625 
    if(!SollwertErmittlung()) MotorTon();
 626 
    if(!SollwertErmittlung()) MotorTon();
626 
//MotorTon();    
 627 
//MotorTon();    
627 
    PORTB = 0x31; // Pullups wieder einschalten
 628 
    PORTB = 0x31; // Pullups wieder einschalten
628 
 
 629 
 
629 
    // zum Test der Hardware; Motor dreht mit konstanter Drehzahl ohne Regelung
 630 
    // zum Test der Hardware; Motor dreht mit konstanter Drehzahl ohne Regelung
630 
    if(TEST_MANUELL)    Anwerfen(TEST_MANUELL);  // kommt von dort nicht wieder
 631 
    if(TEST_MANUELL)    Anwerfen(TEST_MANUELL);  // kommt von dort nicht wieder
631 
 
 632 
 
632 
    while (1)
 633 
    while (1)
633 
        {
 634 
        {
634 
//ShowSense();
 635 
//ShowSense();
635 
 
 636 
 
636 
        if(!TEST_SCHUB)   PWM = SollwertErmittlung();
 637 
        if(!TEST_SCHUB)   PWM = SollwertErmittlung();
637 
        //I2C_TXBuffer = PWM; // Antwort über I2C-Bus
 638 
        //I2C_TXBuffer = PWM; // Antwort über I2C-Bus
638 
        if(MANUELL_PWM)   PWM = MANUELL_PWM;
 639 
        if(MANUELL_PWM)   PWM = MANUELL_PWM;
639 
 
 640 
 
640 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 641 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
641 
        if(Phase != altPhase)   // es gab eine Kommutierung im Interrupt
 642 
        if(Phase != altPhase)   // es gab eine Kommutierung im Interrupt
642 
            {
 643 
            {
643 
            MotorGestoppt = 0;
 644 
            MotorGestoppt = 0;
644 
            ZeitFuerBerechnungen = 0;    // direkt nach einer Kommutierung ist Zeit
645 
            ZeitFuerBerechnungen = 0;    // direkt nach einer Kommutierung ist Zeit
645 
            MinUpmPulse = SetDelay(250);  // Timeout, falls ein Motor stehen bleibt
 646 
            MinUpmPulse = SetDelay(250);  // Timeout, falls ein Motor stehen bleibt
646 
            altPhase = Phase;
 647 
            altPhase = Phase;
647 
            }
 648 
            }
648 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 649 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
649 
        if(!PWM)    // Sollwert == 0
 650 
        if(!PWM)    // Sollwert == 0
650 
            {
 651 
            {
651 
            MotorAnwerfen = 0;      // kein Startversuch
 652 
            MotorAnwerfen = 0;      // kein Startversuch
652 
            ZeitFuerBerechnungen = 0;
 653 
            ZeitFuerBerechnungen = 0;
653 
            // nach 1,5 Sekunden den Motor als gestoppt betrachten
654 
            // nach 1,5 Sekunden den Motor als gestoppt betrachten
654 
            if(CheckDelay(MotorGestopptTimer))
 655 
            if(CheckDelay(MotorGestopptTimer))
655 
                {
 656 
                {
656 
                DISABLE_SENSE_INT;
 657 
                DISABLE_SENSE_INT;
657 
                MotorGestoppt = 1;  
 658 
                MotorGestoppt = 1;  
658 
                STEUER_OFF;
 659 
                STEUER_OFF;
659 
                }
 660 
                }
660 
            }
 661 
            }
661 
        else
 662 
        else
662 
            {
 663 
            {
663 
            if(MotorGestoppt) MotorAnwerfen = 1;        // Startversuch
 664 
            if(MotorGestoppt) MotorAnwerfen = 1;        // Startversuch
664 
            MotorGestopptTimer = SetDelay(1500);
 665 
            MotorGestopptTimer = SetDelay(1500);
665 
            }
 666 
            }
666 
 
 667 
 
667 
        if(MotorGestoppt && !TEST_SCHUB) PWM = 0;
 668 
        if(MotorGestoppt && !TEST_SCHUB) PWM = 0;
668 
        SetPWM();
 669 
        SetPWM();
669 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 670 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
670 
        if(!ZeitFuerBerechnungen++)
 671 
        if(!ZeitFuerBerechnungen++)
671 
            {
 672 
            {
672 
            if(MotorGestoppt)
 673 
            if(MotorGestoppt)
673 
             {
 674 
             {
674 
              GRN_ON;
 675 
              GRN_ON;
675 
              FastADConvert();
 676 
              FastADConvert();
676 
             }
 677 
             }
677 
            if(SIO_DEBUG)
 678 
            if(SIO_DEBUG)
678 
                {
 679 
                {
679 
                DebugAusgaben();  // welche Werte sollen angezeigt werden?
 680 
                DebugAusgaben();  // welche Werte sollen angezeigt werden?
680 
                if(!UebertragungAbgeschlossen)  SendUart();
 681 
                if(!UebertragungAbgeschlossen)  SendUart();
681 
                else DatenUebertragung();
 682 
                else DatenUebertragung();
682 
                }
 683 
                }
683 
            // Berechnen des Mittleren Stroms zur (langsamen) Strombegrenzung
 684 
            // Berechnen des Mittleren Stroms zur (langsamen) Strombegrenzung
684 
            if(CheckDelay(MittelstromTimer))  
 685 
            if(CheckDelay(MittelstromTimer))  
685 
                {
 686 
                {
686 
                MittelstromTimer = SetDelay(50); // alle 50ms
 687 
                MittelstromTimer = SetDelay(50); // alle 50ms
687 
                if(Mittelstrom <  Strom) Mittelstrom++;// Mittelwert des Stroms bilden
 688 
                if(Mittelstrom <  Strom) Mittelstrom++;// Mittelwert des Stroms bilden
688 
                else if(Mittelstrom >  Strom) Mittelstrom--;
 689 
                else if(Mittelstrom >  Strom) Mittelstrom--;
689 
                if(Strom > MAX_STROM) MaxPWM -= MaxPWM / 32;              
 690 
                if(Strom > MAX_STROM) MaxPWM -= MaxPWM / 32;              
690 
                if((Mittelstrom > LIMIT_STROM))// Strom am Limit?
 691 
                if((Mittelstrom > LIMIT_STROM))// Strom am Limit?
691 
                    {
 692 
                    {
692 
                    if(MaxPWM) MaxPWM--;// dann die Maximale PWM herunterfahren
 693 
                    if(MaxPWM) MaxPWM--;// dann die Maximale PWM herunterfahren
693 
                    PORTC |= ROT;
 694 
                    PORTC |= ROT;
694 
                    }
 695 
                    }
695 
                else
 696 
                else
696 
                    {
 697 
                    {
697 
                    if(MaxPWM < MAX_PWM) MaxPWM++;
 698 
                    if(MaxPWM < MAX_PWM) MaxPWM++;
698 
                    }
 699 
                    }
699 
                }
 700 
                }
700 
 
 701 
 
701 
            if(CheckDelay(DrehzahlMessTimer))   // Ist-Drehzahl bestimmen
 702 
            if(CheckDelay(DrehzahlMessTimer))   // Ist-Drehzahl bestimmen
702 
                {
 703 
                {
703 
                DrehzahlMessTimer = SetDelay(10);
 704 
                DrehzahlMessTimer = SetDelay(10);
704 
                SIO_Drehzahl = CntKommutierungen;//(6 * CntKommutierungen) / (POLANZAHL / 2);
 705 
                SIO_Drehzahl = CntKommutierungen;//(6 * CntKommutierungen) / (POLANZAHL / 2);
705 
                CntKommutierungen = 0;
 706 
                CntKommutierungen = 0;
706 
               // if(PPM_Timeout == 0) // keine PPM-Signale
 707 
               // if(PPM_Timeout == 0) // keine PPM-Signale
707 
                ZeitZumAdWandeln = 1;
 708 
                ZeitZumAdWandeln = 1;
708 
                }
 709 
                }
709 
 
 710 
 
710 
#if TEST_SCHUB == 1
 711 
#if TEST_SCHUB == 1
711 
           {
 712 
           {
712 
            if(CheckDelay(TestschubTimer))  
 713 
            if(CheckDelay(TestschubTimer))  
713 
                {
 714 
                {
714 
                TestschubTimer = SetDelay(1500);
 715 
                TestschubTimer = SetDelay(1500);
715 
                    switch(test)
 716 
                    switch(test)
716 
                        {
 717 
                        {
717 
                        case 0: PWM = 50; test++; break;
 718 
                        case 0: PWM = 50; test++; break;
718 
                        case 1: PWM = 130; test++; break;
 719 
                        case 1: PWM = 130; test++; break;
719 
                        case 2: PWM = 60;  test++; break;
 720 
                        case 2: PWM = 60;  test++; break;
720 
                        case 3: PWM = 140; test++; break;
 721 
                        case 3: PWM = 140; test++; break;
721 
                        case 4: PWM = 150; test = 0; break;
 722 
                        case 4: PWM = 150; test = 0; break;
722 
                        default: test = 0;
 723 
                        default: test = 0;
723 
                        }
 724 
                        }
724 
                }
 725 
                }
725 
            }  
 726 
            }  
726 
#endif
 727 
#endif
727 
          // Motor Stehen geblieben
 728 
          // Motor Stehen geblieben
728 
            if((CheckDelay(MinUpmPulse) && SIO_Drehzahl == 0) || MotorAnwerfen)
 729 
            if((CheckDelay(MinUpmPulse) && SIO_Drehzahl == 0) || MotorAnwerfen)
729 
                {
 730 
                {
730 
                MotorGestoppt = 1;    
 731 
                MotorGestoppt = 1;    
731 
                DISABLE_SENSE_INT;
 732 
                DISABLE_SENSE_INT;
732 
                MinUpmPulse = SetDelay(100);        
 733 
                MinUpmPulse = SetDelay(100);        
733 
                if(MotorAnwerfen)
 734 
                if(MotorAnwerfen)
734 
                  {
 735 
                  {
735 
                   PORTC &= ~ROT;
 736 
                   PORTC &= ~ROT;
736 
                   Strom_max = 0;
 737 
                   Strom_max = 0;
737 
                   MotorAnwerfen = 0;
 738 
                   MotorAnwerfen = 0;
738 
                   if(Anwerfen(10))
 739 
                   if(Anwerfen(10))
739 
                   {  
 740 
                   {  
740 
                    GRN_ON;
 741 
                    GRN_ON;
741 
                    MotorGestoppt = 0;    
 742 
                    MotorGestoppt = 0;    
742 
                    Phase--;
 743 
                    Phase--;
743 
                    PWM = 1;
 744 
                    PWM = 1;
744 
                    SetPWM();
 745 
                    SetPWM();
745 
                    SENSE_TOGGLE_INT;
 746 
                    SENSE_TOGGLE_INT;
746 
                    ENABLE_SENSE_INT;
 747 
                    ENABLE_SENSE_INT;
747 
                    MinUpmPulse = SetDelay(20);
 748 
                    MinUpmPulse = SetDelay(20);
748 
                    while(!CheckDelay(MinUpmPulse)); // kurz Synchronisieren
 749 
                    while(!CheckDelay(MinUpmPulse)); // kurz Synchronisieren
749 
                    PWM = 15;
 750 
                    PWM = 15;
750 
                    SetPWM();
 751 
                    SetPWM();
751 
                    MinUpmPulse = SetDelay(300);
 752 
                    MinUpmPulse = SetDelay(300);
752 
                    while(!CheckDelay(MinUpmPulse)) // kurz Durchstarten
 753 
                    while(!CheckDelay(MinUpmPulse)) // kurz Durchstarten
753 
                    {
 754 
                    {
754 
                      if(Strom > LIMIT_STROM/2)
 755 
                      if(Strom > LIMIT_STROM/2)
755 
                      {
 756 
                      {
756 
                        STEUER_OFF; // Abschalten wegen Kurzschluss
 757 
                        STEUER_OFF; // Abschalten wegen Kurzschluss
757 
                        RotBlink(10);
 758 
                        RotBlink(10);
758 
                        MotorAnwerfen = 1;
 759 
                        MotorAnwerfen = 1;
759 
                      }  
 760 
                      }  
760 
                    }
 761 
                    }
761 
                                    // Drehzahlmessung wieder aufsetzen
 762 
                                    // Drehzahlmessung wieder aufsetzen
762 
                    DrehzahlMessTimer = SetDelay(50);
 763 
                    DrehzahlMessTimer = SetDelay(50);
763 
                    altPhase = 7;
 764 
                    altPhase = 7;
764 
                   }
 765 
                   }
765 
                   else if(SollwertErmittlung()) MotorAnwerfen = 1;
 766 
                   else if(SollwertErmittlung()) MotorAnwerfen = 1;
766 
                  }
 767 
                  }
767 
                }
 768 
                }
768 
            } // ZeitFuerBerechnungen
 769 
            } // ZeitFuerBerechnungen
769 
        } // while(1) - Hauptschleife
 770 
        } // while(1) - Hauptschleife
770 
}
 771 
}
771 
 
 772 
 
772 
 
 773