Subversion Repositories BL-Ctrl

Rev

Rev 90 | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 90 Rev 92
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 / NON-COMMERCIAL USE ONLY
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 oder Nutzung 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 the sources to other systems or using the software on other systems (except 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 
//GRN_ON;
 113 
//GRN_ON;
114 
}
 114 
}
115 
 
 115 
 
116 
void DebugAusgaben(void)
 116 
void DebugAusgaben(void)
117 
{
 117 
{
118 
    DebugOut.Analog[0] = Strom;
 118 
    DebugOut.Analog[0] = Strom;
119 
    DebugOut.Analog[1] = Mittelstrom;
 119 
    DebugOut.Analog[1] = Mittelstrom;
120 
    DebugOut.Analog[2] = SIO_Drehzahl;
 120 
    DebugOut.Analog[2] = SIO_Drehzahl;
121 
    DebugOut.Analog[3] = PPM_Signal;
 121 
    DebugOut.Analog[3] = PPM_Signal;
122 
    DebugOut.Analog[4] = OCR2;
 122 
    DebugOut.Analog[4] = OCR2;
123 
//    DebugOut.Analog[5] = PWM;
 123 
//    DebugOut.Analog[5] = PWM;
124 
}
 124 
}
125 
 
 125 
 
126 
//############################################################################
 126 
//############################################################################
127 
//
 127 
//
128 
void PWM_Init(void)
 128 
void PWM_Init(void)
129 
//############################################################################
 129 
//############################################################################
130 
{
 130 
{
131 
    PWM_OFF;
 131 
    PWM_OFF;
132 
    TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (0 << WGM12) |
 132 
    TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (0 << WGM12) |
133 
             (0 << WGM13) | (0<< ICES1) | (0 << ICNC1);
 133 
             (0 << WGM13) | (0<< ICES1) | (0 << ICNC1);
134 
/*    TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (1 << WGM12) |
 134 
/*    TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (1 << WGM12) |
135 
             (0 << WGM13) | (0<< ICES1) | (0 << ICNC1);
 135 
             (0 << WGM13) | (0<< ICES1) | (0 << ICNC1);
136 
*/
 136 
*/
137 
}
 137 
}
138 
 
 138 
 
139 
//############################################################################
 139 
//############################################################################
140 
//
 140 
//
141 
void Wait(unsigned char dauer)
 141 
void Wait(unsigned char dauer)
142 
//############################################################################
 142 
//############################################################################
143 
{
 143 
{
144 
    dauer = (unsigned char)TCNT0 + dauer;
 144 
    dauer = (unsigned char)TCNT0 + dauer;
145 
    while((TCNT0 - dauer) & 0x80);
 145 
    while((TCNT0 - dauer) & 0x80);
146 
}
 146 
}
147 
 
 147 
 
148 
void RotBlink(unsigned char anz)
 148 
void RotBlink(unsigned char anz)
149 
{
 149 
{
150 
sei(); // Interrupts ein
 150 
sei(); // Interrupts ein
151 
 while(anz--)
 151 
 while(anz--)
152 
  {
 152 
  {
153 
   PORTC |= ROT;
 153 
   PORTC |= ROT;
154 
   Delay_ms(300);    
 154 
   Delay_ms(300);    
155 
   PORTC &= ~ROT;
 155 
   PORTC &= ~ROT;
156 
   Delay_ms(300);    
 156 
   Delay_ms(300);    
157 
  }
 157 
  }
158 
   Delay_ms(1000);    
 158 
   Delay_ms(1000);    
159 
}
 159 
}
160 
 
 160 
 
161 
//############################################################################
 161 
//############################################################################
162 
//
 162 
//
163 
char Anwerfen(unsigned char pwm)
 163 
char Anwerfen(unsigned char pwm)
164 
//############################################################################
 164 
//############################################################################
165 
{
 165 
{
166 
    unsigned long timer = 300,i;
 166 
    unsigned long timer = 300,i;
167 
    DISABLE_SENSE_INT;
 167 
    DISABLE_SENSE_INT;
168 
    PWM = 5;
 168 
    PWM = 5;
169 
    SetPWM();
 169 
    SetPWM();
170 
    Manuell();
 170 
    Manuell();
171 
//    Delay_ms(200);
 171 
//    Delay_ms(200);
172 
                    MinUpmPulse = SetDelay(300);
 172 
                    MinUpmPulse = SetDelay(300);
173 
                    while(!CheckDelay(MinUpmPulse))
 173 
                    while(!CheckDelay(MinUpmPulse))
174 
                    {
 174 
                    {
175 
                     FastADConvert();
 175 
                     FastADConvert();
176 
                      if(Strom > 120)
 176 
                      if(Strom > 120)
177 
                      {
 177 
                      {
178 
                        STEUER_OFF; // Abschalten wegen Kurzschluss
 178 
                        STEUER_OFF; // Abschalten wegen Kurzschluss
179 
                        RotBlink(10);
 179 
                        RotBlink(10);
180 
                        return(0);
 180 
                        return(0);
181 
                      }  
 181 
                      }  
182 
                    }
 182 
                    }
183 
    PWM = pwm;
 183 
    PWM = pwm;
184 
    while(1)
 184 
    while(1)
185 
        {
 185 
        {
186 
        for(i=0;i<timer; i++)
 186 
        for(i=0;i<timer; i++)
187 
            {
 187 
            {
188 
            if(!UebertragungAbgeschlossen)  SendUart();
 188 
            if(!UebertragungAbgeschlossen)  SendUart();
189 
            else DatenUebertragung();
 189 
            else DatenUebertragung();
190 
            Wait(100);  // warten
 190 
            Wait(100);  // warten
191 
            }
 191 
            }
192 
        DebugAusgaben();
 192 
        DebugAusgaben();
193 
        FastADConvert();
 193 
        FastADConvert();
194 
        if(Strom > 60)
 194 
        if(Strom > 60)
195 
          {
 195 
          {
196 
            STEUER_OFF; // Abschalten wegen Kurzschluss
 196 
            STEUER_OFF; // Abschalten wegen Kurzschluss
197 
            RotBlink(10);
 197 
            RotBlink(10);
198 
            return(0);
 198 
            return(0);
199 
          }  
 199 
          }  
200 
         
 200 
         
201 
        timer-= timer/15+1;
 201 
        timer-= timer/15+1;
202 
        if(timer < 25) { if(TEST_MANUELL) timer = 25; else return(1); }
 202 
        if(timer < 25) { if(TEST_MANUELL) timer = 25; else return(1); }
203 
        Manuell();
 203 
        Manuell();
204 
        Phase++;
 204 
        Phase++;
205 
        Phase %= 6;
 205 
        Phase %= 6;
206 
        AdConvert();
 206 
        AdConvert();
207 
        PWM = pwm;
 207 
        PWM = pwm;
208 
        SetPWM();
 208 
        SetPWM();
209 
        if(SENSE)
 209 
        if(SENSE)
210 
            {
 210 
            {
211 
            PORTD ^= GRUEN;
 211 
            PORTD ^= GRUEN;
212 
            }
 212 
            }
213 
        }
 213 
        }
214 
}
 214 
}
215 
 
 215 
 
216 
/*
 216 
/*
217 
#define SENSE_A ADMUX = 0;
 217 
#define SENSE_A ADMUX = 0;
218 
#define SENSE_B ADMUX = 1;
 218 
#define SENSE_B ADMUX = 1;
219 
#define SENSE_C ADMUX = 2;
 219 
#define SENSE_C ADMUX = 2;
220 
 
 220 
 
221 
#define ClrSENSE            ACSR |= 0x10
 221 
#define ClrSENSE            ACSR |= 0x10
222 
#define SENSE               ((ACSR & 0x10))
 222 
#define SENSE               ((ACSR & 0x10))
223 
#define SENSE_L             (!(ACSR & 0x20))
 223 
#define SENSE_L             (!(ACSR & 0x20))
224 
#define SENSE_H             ((ACSR & 0x20))
 224 
#define SENSE_H             ((ACSR & 0x20))
225 
*/
 225 
*/
226 
 
 226 
 
227 
 
 227 
 
228 
#define TEST_STROMGRENZE 120
 228 
#define TEST_STROMGRENZE 120
229 
unsigned char DelayM(unsigned int timer)
 229 
unsigned char DelayM(unsigned int timer)
230 
{
 230 
{
231 
 while(timer--)
 231 
 while(timer--)
232 
  {
 232 
  {
233 
   FastADConvert();
 233 
   FastADConvert();
234 
   if(Strom > (TEST_STROMGRENZE + RuheStrom))
 234 
   if(Strom > (TEST_STROMGRENZE + RuheStrom))
235 
       {
 235 
       {
236 
        FETS_OFF;
 236 
        FETS_OFF;
237 
        return(1);
 237 
        return(1);
238 
       }
 238 
       }
239 
  }
 239 
  }
240 
 return(0);  
 240 
 return(0);  
241 
}
 241 
}
242 
 
 242 
 
243 
unsigned char Delay(unsigned int timer)
 243 
unsigned char Delay(unsigned int timer)
244 
{
 244 
{
245 
 while(timer--)
 245 
 while(timer--)
246 
  {
 246 
  {
247 
//   if(SENSE_H) { PORTC |= ROT; } else { PORTC &= ~ROT;}
 247 
//   if(SENSE_H) { PORTC |= ROT; } else { PORTC &= ~ROT;}
248 
  }
 248 
  }
249 
 return(0);  
 249 
 return(0);  
250 
}
 250 
}
251 
 
 251 
 
252 
/*
 252 
/*
253 
void ShowSense(void)
 253 
void ShowSense(void)
254 
{
 254 
{
255 
 if(SENSE_H) { PORTC |= ROT; } else { PORTC &= ~ROT;}
 255 
 if(SENSE_H) { PORTC |= ROT; } else { PORTC &= ~ROT;}
256 
 
 256 
 
257 
}
 257 
}
258 
*/
 258 
*/
259 
#define HIGH_A_EIN PORTB |= 0x08
 259 
#define HIGH_A_EIN PORTB |= 0x08
260 
#define HIGH_B_EIN PORTB |= 0x04
 260 
#define HIGH_B_EIN PORTB |= 0x04
261 
#define HIGH_C_EIN PORTB |= 0x02
 261 
#define HIGH_C_EIN PORTB |= 0x02
262 
#define LOW_A_EIN  PORTD |= 0x08
 262 
#define LOW_A_EIN  PORTD |= 0x08
263 
#define LOW_B_EIN  PORTD |= 0x10
 263 
#define LOW_B_EIN  PORTD |= 0x10
264 
#define LOW_C_EIN  PORTD |= 0x20
 264 
#define LOW_C_EIN  PORTD |= 0x20
265 
 
 265 
 
266 
void MotorTon(void)
 266 
void MotorTon(void)
267 
//############################################################################
 267 
//############################################################################
268 
{
 268 
{
269 
    unsigned char ADR_TAB[9] = {0,0,2,1,3,4,5,6,7};
 269 
    unsigned char ADR_TAB[9] = {0,0,2,1,3,4,5,6,7};
270 
    unsigned int timer = 300,i;
 270 
    unsigned int timer = 300,i;
271 
    unsigned int t = 0;
 271 
    unsigned int t = 0;
272 
    unsigned char anz = 0,MosfetOkay = 0, grenze = 50;
 272 
    unsigned char anz = 0,MosfetOkay = 0, grenze = 50;
273 
 
 273 
 
274 
    PORTC &= ~ROT;
 274 
    PORTC &= ~ROT;
275 
    Delay_ms(300 * ADR_TAB[MotorAdresse]);    
 275 
    Delay_ms(300 * ADR_TAB[MotorAdresse]);    
276 
    DISABLE_SENSE_INT;
 276 
    DISABLE_SENSE_INT;
277 
    cli();//Globale Interrupts Ausschalten
 277 
    cli();//Globale Interrupts Ausschalten
278 
    uart_putchar('\n');
 278 
    uart_putchar('\n');
279 
    STEUER_OFF;
 279 
    STEUER_OFF;
280 
    Strom_max = 0;
 280 
    Strom_max = 0;
281 
    DelayM(50);
 281 
    DelayM(50);
282 
    RuheStrom = Strom_max;
 282 
    RuheStrom = Strom_max;
283 
//    uart_putchar(RuheStrom + 'A');
 283 
//    uart_putchar(RuheStrom + 'A');
284 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 284 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
285 
//+ High-Mosfets auf Kurzschluss testen
 285 
//+ High-Mosfets auf Kurzschluss testen
286 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 286 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
287 
    Strom = 0;
 287 
    Strom = 0;
288 
/*
 288 
/*
289 
    LOW_B_EIN;
 289 
    LOW_B_EIN;
290 
    HIGH_A_EIN;
 290 
    HIGH_A_EIN;
291 
    if(DelayM(3))
 291 
    if(DelayM(3))
292 
       {
 292 
       {
293 
        anz = 1;
 293 
        anz = 1;
294 
        uart_putchar('1');
 294 
        uart_putchar('1');
295 
       }
 295 
       }
296 
    FETS_OFF;
 296 
    FETS_OFF;
297 
    Delay(1000);
 297 
    Delay(1000);
298 
    Strom = 0;
 298 
    Strom = 0;
299 
    LOW_A_EIN;
 299 
    LOW_A_EIN;
300 
    HIGH_B_EIN;
 300 
    HIGH_B_EIN;
301 
    if(DelayM(3))
 301 
    if(DelayM(3))
302 
       {
 302 
       {
303 
        anz = 2;
 303 
        anz = 2;
304 
        uart_putchar('2');
 304 
        uart_putchar('2');
305 
       }
 305 
       }
306 
    FETS_OFF;
 306 
    FETS_OFF;
307 
    Delay(1000);
 307 
    Delay(1000);
308 
    Strom = 0;
 308 
    Strom = 0;
309 
    LOW_B_EIN; // Low C ein
 309 
    LOW_B_EIN; // Low C ein
310 
    HIGH_C_EIN; // High B ein
 310 
    HIGH_C_EIN; // High B ein
311 
    if(DelayM(3))
 311 
    if(DelayM(3))
312 
       {
 312 
       {
313 
        anz = 3;
 313 
        anz = 3;
314 
        uart_putchar('3');
 314 
        uart_putchar('3');
315 
       }
 315 
       }
316 
    FETS_OFF;
 316 
    FETS_OFF;
317 
    Delay(1000);
 317 
    Delay(1000);
318 
    LOW_A_EIN; // Low  A ein; und A gegen C
 318 
    LOW_A_EIN; // Low  A ein; und A gegen C
319 
    HIGH_C_EIN; // High C ein
 319 
    HIGH_C_EIN; // High C ein
320 
    if(DelayM(3))
 320 
    if(DelayM(3))
321 
       {
 321 
       {
322 
        anz = 3;
 322 
        anz = 3;
323 
        uart_putchar('7');
 323 
        uart_putchar('7');
324 
       }
 324 
       }
325 
    FETS_OFF;
 325 
    FETS_OFF;
326 
    DelayM(10000);
 326 
    DelayM(10000);
327 
 
 327 
 
328 
if(anz) while(1) RotBlink(anz);  // bei Kurzschluss nicht starten
 328 
if(anz) while(1) RotBlink(anz);  // bei Kurzschluss nicht starten
329 
*/
 329 
*/
330 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 330 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
331 
//+ LOW-Mosfets auf Schalten und Kurzschluss testen
 331 
//+ LOW-Mosfets auf Schalten und Kurzschluss testen
332 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 332 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
333 
 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
334 
 Strom = 0;
 334 
 Strom = 0;
335 
 for(i=0;i<t;i++)
 335 
 for(i=0;i<t;i++)
336 
 {
 336 
 {
337 
  LOW_A_EIN;
 337 
  LOW_A_EIN;
338 
  DelayM(1);
 338 
  DelayM(1);
339 
  FETS_OFF;
 339 
  FETS_OFF;
340 
  Delay(5);
 340 
  Delay(5);
341 
  HIGH_A_EIN;
 341 
  HIGH_A_EIN;
342 
  DelayM(1);
 342 
  DelayM(1);
343 
  FETS_OFF;
 343 
  FETS_OFF;
344 
  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;}
345 
  Delay(5);
 345 
  Delay(5);
346 
 }
 346 
 }
347 
 Delay(10000);
 347 
 Delay(10000);
348 
 
 348 
 
349 
 Strom = 0;
 349 
 Strom = 0;
350 
 for(i=0;i<t;i++)
 350 
 for(i=0;i<t;i++)
351 
 {
 351 
 {
352 
  LOW_B_EIN;
 352 
  LOW_B_EIN;
353 
  DelayM(1);
 353 
  DelayM(1);
354 
  FETS_OFF;
 354 
  FETS_OFF;
355 
  Delay(5);
 355 
  Delay(5);
356 
  HIGH_B_EIN;
 356 
  HIGH_B_EIN;
357 
  DelayM(1);
 357 
  DelayM(1);
358 
  FETS_OFF;
 358 
  FETS_OFF;
359 
  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;}
360 
  Delay(5);
 360 
  Delay(5);
361 
 }
 361 
 }
362 
 
 362 
 
363 
 Strom = 0;
 363 
 Strom = 0;
364 
 Delay(10000);
 364 
 Delay(10000);
365 
 
 365 
 
366 
 for(i=0;i<t;i++)
 366 
 for(i=0;i<t;i++)
367 
 {
 367 
 {
368 
  LOW_C_EIN;
 368 
  LOW_C_EIN;
369 
  DelayM(1);
 369 
  DelayM(1);
370 
  FETS_OFF;
 370 
  FETS_OFF;
371 
  Delay(5);
 371 
  Delay(5);
372 
  HIGH_C_EIN;
 372 
  HIGH_C_EIN;
373 
  DelayM(1);
 373 
  DelayM(1);
374 
  FETS_OFF;
 374 
  FETS_OFF;
375 
  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;}
376 
  Delay(5);
 376 
  Delay(5);
377 
 }
 377 
 }
378 
 
 378 
 
379 
 if(anz) while(1) RotBlink(anz);  // bei Kurzschluss nicht starten
 379 
 if(anz) while(1) RotBlink(anz);  // bei Kurzschluss nicht starten
380 
 
 380 
 
381 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 381 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
382 
//+ High-Mosfets auf Schalten testen
 382 
//+ High-Mosfets auf Schalten testen
383 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 383 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
384 
    SENSE_A;
 384 
    SENSE_A;
385 
    FETS_OFF;
 385 
    FETS_OFF;
386 
    LOW_B_EIN; // Low B ein
 386 
    LOW_B_EIN; // Low B ein
387 
    LOW_C_EIN; // Low C ein
 387 
    LOW_C_EIN; // Low C ein
388 
    Strom = 0;
 388 
    Strom = 0;
389 
#define TONDAUER  40000    
 389 
#define TONDAUER  40000    
390 
#define SOUND_E 1  // 1
 390 
#define SOUND_E 1  // 1
391 
#define SOUND1_A 300
 391 
#define SOUND1_A 300
392 
#define SOUND2_A 330
 392 
#define SOUND2_A 330
393 
#define SOUND3_A 360
 393 
#define SOUND3_A 360
394 
 
 394 
 
395 
    for(i=0; i< (TONDAUER / SOUND2_A) ; i++)
 395 
    for(i=0; i< (TONDAUER / SOUND2_A) ; i++)
396 
     {
 396 
     {
397 
      HIGH_A_EIN; // Test A
 397 
      HIGH_A_EIN; // Test A
398 
      Delay(SOUND_E);
 398 
      Delay(SOUND_E);
399 
      if(MessAD(0) > 50) { MosfetOkay |= 0x01; } else { MosfetOkay &= ~0x01;};
 399 
      if(MessAD(0) > 50) { MosfetOkay |= 0x01; } else { MosfetOkay &= ~0x01;};
400 
      PORTB = 0;
 400 
      PORTB = 0;
401 
      Delay(SOUND1_A);
 401 
      Delay(SOUND1_A);
402 
     }
 402 
     }
403 
    FETS_OFF;
 403 
    FETS_OFF;
404 
 
 404 
 
405 
    LOW_A_EIN; // Low A ein
 405 
    LOW_A_EIN; // Low A ein
406 
    LOW_C_EIN; // Low C ein
 406 
    LOW_C_EIN; // Low C ein
407 
    for(i=0; i<(TONDAUER / SOUND1_A); i++)
 407 
    for(i=0; i<(TONDAUER / SOUND1_A); i++)
408 
     {
 408 
     {
409 
      HIGH_B_EIN; // Test B
 409 
      HIGH_B_EIN; // Test B
410 
      Delay(SOUND_E);
 410 
      Delay(SOUND_E);
411 
      if(MessAD(1) > 50) { MosfetOkay |= 0x02; } else { MosfetOkay &= ~0x02;};
 411 
      if(MessAD(1) > 50) { MosfetOkay |= 0x02; } else { MosfetOkay &= ~0x02;};
412 
      PORTB = 0;
 412 
      PORTB = 0;
413 
      Delay(SOUND1_A);
 413 
      Delay(SOUND1_A);
414 
     }
 414 
     }
415 
 
 415 
 
416 
    FETS_OFF;
 416 
    FETS_OFF;
417 
    LOW_A_EIN; // Low A ein
 417 
    LOW_A_EIN; // Low A ein
418 
    LOW_B_EIN; // Low B ein
 418 
    LOW_B_EIN; // Low B ein
419 
    for(i=0; i<(TONDAUER / SOUND3_A); i++)
 419 
    for(i=0; i<(TONDAUER / SOUND3_A); i++)
420 
     {
 420 
     {
421 
      HIGH_C_EIN; // Test C
 421 
      HIGH_C_EIN; // Test C
422 
      Delay(SOUND_E);
 422 
      Delay(SOUND_E);
423 
      if(MessAD(2) > 50) { MosfetOkay |= 0x04; } else { MosfetOkay &= ~0x04;};
 423 
      if(MessAD(2) > 50) { MosfetOkay |= 0x04; } else { MosfetOkay &= ~0x04;};
424 
      PORTB = 0;
 424 
      PORTB = 0;
425 
      Delay(SOUND2_A);
 425 
      Delay(SOUND2_A);
426 
     }
 426 
     }
427 
    FETS_OFF;
 427 
    FETS_OFF;
428 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 428 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
429 
//+ Low-Mosfets auf Schalten testen
 429 
//+ Low-Mosfets auf Schalten testen
430 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 430 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
431 
//    SENSE_B;
 431 
//    SENSE_B;
432 
    LOW_A_EIN; // Low A ein
 432 
    LOW_A_EIN; // Low A ein
433 
    for(i=0; i< (TONDAUER / SOUND2_A) ; i++)
 433 
    for(i=0; i< (TONDAUER / SOUND2_A) ; i++)
434 
     {
 434 
     {
435 
      HIGH_B_EIN; // Test B
 435 
      HIGH_B_EIN; // Test B
436 
      Delay(SOUND_E);
 436 
      Delay(SOUND_E);
437 
      if(MessAD(0) > 128) { MosfetOkay &= ~0x08;} else { MosfetOkay |= 0x08;};
 437 
      if(MessAD(0) > 128) { MosfetOkay &= ~0x08;} else { MosfetOkay |= 0x08;};
438 
      PORTB = 0;
 438 
      PORTB = 0;
439 
      Delay(SOUND2_A);
 439 
      Delay(SOUND2_A);
440 
     }
 440 
     }
441 
 
 441 
 
442 
//++++++++++++++++++++++++++++++++++++
 442 
//++++++++++++++++++++++++++++++++++++
443 
    LOW_C_EIN; // Low C ein
 443 
    LOW_C_EIN; // Low C ein
444 
    for(i=0; i<(TONDAUER / SOUND1_A); i++)
 444 
    for(i=0; i<(TONDAUER / SOUND1_A); i++)
445 
     {
 445 
     {
446 
      HIGH_B_EIN; // Test B
 446 
      HIGH_B_EIN; // Test B
447 
      Delay(SOUND_E);
 447 
      Delay(SOUND_E);
448 
      if(MessAD(2) > 128) { MosfetOkay &= ~0x20;} else { MosfetOkay |= 0x20;};
 448 
      if(MessAD(2) > 128) { MosfetOkay &= ~0x20;} else { MosfetOkay |= 0x20;};
449 
      PORTB = 0;
 449 
      PORTB = 0;
450 
      Delay(SOUND3_A);
 450 
      Delay(SOUND3_A);
451 
     }
 451 
     }
452 
    FETS_OFF;
 452 
    FETS_OFF;
453 
//++++++++++++++++++++++++++++++++++++
 453 
//++++++++++++++++++++++++++++++++++++
454 
    FETS_OFF;
 454 
    FETS_OFF;
455 
    LOW_B_EIN; // Low B ein
 455 
    LOW_B_EIN; // Low B ein
456 
    for(i=0; i<(TONDAUER / SOUND3_A); i++)
 456 
    for(i=0; i<(TONDAUER / SOUND3_A); i++)
457 
     {
 457 
     {
458 
      HIGH_C_EIN; // Test C
 458 
      HIGH_C_EIN; // Test C
459 
      Delay(SOUND_E);
 459 
      Delay(SOUND_E);
460 
      if(MessAD(1) > 128) { MosfetOkay &= ~0x10;} else { MosfetOkay |= 0x10;};
 460 
      if(MessAD(1) > 128) { MosfetOkay &= ~0x10;} else { MosfetOkay |= 0x10;};
461 
      PORTB = 0;
 461 
      PORTB = 0;
462 
      Delay(SOUND3_A);
 462 
      Delay(SOUND3_A);
463 
     }
 463 
     }
464 
    FETS_OFF;
 464 
    FETS_OFF;
465 
//++++++++++++++++++++++++++++++++++++
 465 
//++++++++++++++++++++++++++++++++++++
466 
 
 466 
 
467 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 467 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
468 
    sei();//Globale Interrupts Einschalten
 468 
    sei();//Globale Interrupts Einschalten
469 
//    Delay_ms(250 * MotorAdresse);    
 469 
//    Delay_ms(250 * MotorAdresse);    
470 
/*
 470 
/*
471 
    LOW_A_EIN; // Low B ein
 471 
    LOW_A_EIN; // Low B ein
472 
#define SOUND8_A 650
 472 
#define SOUND8_A 650
473 
    for(i=0; i<(TONDAUER / SOUND8_A); i++)
 473 
    for(i=0; i<(TONDAUER / SOUND8_A); i++)
474 
     {
 474 
     {
475 
      HIGH_B_EIN; // Test B
 475 
      HIGH_B_EIN; // Test B
476 
      Delay(SOUND_E);
 476 
      Delay(SOUND_E);
477 
      PORTB = 0;
 477 
      PORTB = 0;
478 
      Delay(SOUND8_A);
 478 
      Delay(SOUND8_A);
479 
     }
 479 
     }
480 
*/
 480 
*/
481 
 Delay_ms(300 * (4-ADR_TAB[MotorAdresse]));    
 481 
 Delay_ms(300 * (4-ADR_TAB[MotorAdresse]));    
482 
 if(!(MosfetOkay & 0x01))  { anz = 1; UDR='A'; } else
 482 
 if(!(MosfetOkay & 0x01))  { anz = 1; UDR='A'; } else
483 
 if(!(MosfetOkay & 0x02))  { anz = 2; UDR='B'; } else
 483 
 if(!(MosfetOkay & 0x02))  { anz = 2; UDR='B'; } else
484 
 if(!(MosfetOkay & 0x04))  { anz = 3; UDR='C'; } else
 484 
 if(!(MosfetOkay & 0x04))  { anz = 3; UDR='C'; } else
485 
 if(!(MosfetOkay & 0x08))  { anz = 4; UDR='a'; } else
 485 
 if(!(MosfetOkay & 0x08))  { anz = 4; UDR='a'; } else
486 
 if(!(MosfetOkay & 0x10))  { anz = 5; UDR='b'; } else
 486 
 if(!(MosfetOkay & 0x10))  { anz = 5; UDR='b'; } else
487 
 if(!(MosfetOkay & 0x20))  { anz = 6; UDR='c'; }  
 487 
 if(!(MosfetOkay & 0x20))  { anz = 6; UDR='c'; }  
488 
 
 488 
 
489 
// if(anz) Delay_ms(1000);
489 
// if(anz) Delay_ms(1000);
490 
 if(anz) while(1) RotBlink(anz);  // bei Kurzschluss nicht starten
 490 
 if(anz) while(1) RotBlink(anz);  // bei Kurzschluss nicht starten
491 
 RotBlink(anz);
 491 
 RotBlink(anz);
492 
 uart_putchar('.');
 492 
 uart_putchar('.');
493 
}
 493 
}
494 
 
 494 
 
495 
//############################################################################
 495 
//############################################################################
496 
//
 496 
//
497 
unsigned char SollwertErmittlung(void)
 497 
unsigned char SollwertErmittlung(void)
498 
//############################################################################
 498 
//############################################################################
499 
{
 499 
{
500 
    static unsigned int sollwert = 0;
 500 
    static unsigned int sollwert = 0;
501 
    unsigned int ppm;
 501 
    unsigned int ppm;
502 
    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
503 
        {
 503 
        {
504 
        if(SIO_Timeout)  // es gibt gültige SIO-Daten
 504 
        if(SIO_Timeout)  // es gibt gültige SIO-Daten
505 
            {
 505 
            {
506 
             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
507 
             PPM_Betrieb = 0;
 507 
             PPM_Betrieb = 0;
508 
             ICP_INT_DISABLE;
 508 
             ICP_INT_DISABLE;
509 
             PORTC &= ~ROT;
 509 
             PORTC &= ~ROT;
510 
            }
 510 
            }
511 
        else
 511 
        else
512 
            if(anz_ppm_werte > 20)  // es gibt gültige PPM-Daten
 512 
            if(anz_ppm_werte > 20)  // es gibt gültige PPM-Daten
513 
                {
 513 
                {
514 
                PPM_Betrieb = 1;
 514 
                PPM_Betrieb = 1;
515 
                ppm = PPM_Signal;
 515 
                ppm = PPM_Signal;
516 
                if(ppm > 300) ppm =   0;  // ungültiges Signal
 516 
                if(ppm > 300) ppm =   0;  // ungültiges Signal
517 
                if(ppm > 200) ppm = 200;
 517 
                if(ppm > 200) ppm = 200;
518 
                if(ppm <= MIN_PPM) sollwert = 0;
 518 
                if(ppm <= MIN_PPM) sollwert = 0;
519 
                else
 519 
                else
520 
                    {
 520 
                    {
521 
                    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);
522 
                    }
 522 
                    }
523 
                PORTC &= ~ROT;
 523 
                PORTC &= ~ROT;
524 
                }
 524 
                }
525 
            else   // Kein gültiger Sollwert
 525 
            else   // Kein gültiger Sollwert
526 
                {
 526 
                {
527 
                 if(!TEST_SCHUB) { if(sollwert) sollwert--; }  
 527 
                 if(!TEST_SCHUB) { if(sollwert) sollwert--; }  
528 
                 PORTC |= ROT;
 528 
                 PORTC |= ROT;
529 
                }
 529 
                }
530 
        }
 530 
        }
531 
    else // I2C-Daten sind gültig
 531 
    else // I2C-Daten sind gültig
532 
        {
 532 
        {
533 
        sollwert = I2C_RXBuffer;
 533 
        sollwert = I2C_RXBuffer;
534 
        PPM_Betrieb = 0;
 534 
        PPM_Betrieb = 0;
535 
        PORTC &= ~ROT;
 535 
        PORTC &= ~ROT;
536 
        ICP_INT_DISABLE;
 536 
        ICP_INT_DISABLE;
537 
        }
 537 
        }
538 
    if(sollwert > MAX_PWM) sollwert = MAX_PWM;
 538 
    if(sollwert > MAX_PWM) sollwert = MAX_PWM;
539 
    return(sollwert);
 539 
    return(sollwert);
540 
}
 540 
}
541 
 
 541 
 
542 
 
 542 
 
543 
 
 543 
 
544 
//############################################################################
 544 
//############################################################################
545 
//Hauptprogramm
 545 
//Hauptprogramm
546 
int main (void)
 546 
int main (void)
547 
//############################################################################
 547 
//############################################################################
548 
{
 548 
{
549 
    char altPhase = 0;
 549 
    char altPhase = 0;
550 
    int test = 0;
 550 
    int test = 0;
551 
    unsigned int Blink,TestschubTimer;
 551 
    unsigned int Blink,TestschubTimer;
552 
    unsigned int Blink2,MittelstromTimer,DrehzahlMessTimer,MotorGestopptTimer;
 552 
    unsigned int Blink2,MittelstromTimer,DrehzahlMessTimer,MotorGestopptTimer;
553 
 
 553 
 
554 
    DDRC  = 0x08;
 554 
    DDRC  = 0x08;
555 
    PORTC = 0x08;
 555 
    PORTC = 0x08;
556 
    DDRD  = 0x3A;
 556 
    DDRD  = 0x3A;
557 
    PORTD = 0x00;
 557 
    PORTD = 0x00;
558 
    DDRB  = 0x0E;
 558 
    DDRB  = 0x0E;
559 
    PORTB = 0x31;
 559 
    PORTB = 0x31;
560 
 
 560 
 
561 
#define ADRESSOFFSET 0
 561 
#define ADRESSOFFSET 0
562 
 
 562 
 
563 
#if (MOTORADRESSE == 0)
 563 
#if (MOTORADRESSE == 0)
564 
    PORTB |= (ADR1 + ADR2);   // Pullups für Adresswahl
 564 
    PORTB |= (ADR1 + ADR2);   // Pullups für Adresswahl
565 
    for(test=0;test<500;test++);
 565 
    for(test=0;test<500;test++);
566 
    if(PINB & ADR1)
 566 
    if(PINB & ADR1)
567 
         {
 567 
         {
568 
           if (PINB & ADR2) MotorAdresse = 1 + ADRESSOFFSET;
 568 
           if (PINB & ADR2) MotorAdresse = 1 + ADRESSOFFSET;
569 
            else MotorAdresse = 2 + ADRESSOFFSET;
 569 
            else MotorAdresse = 2 + ADRESSOFFSET;
570 
         }
 570 
         }
571 
         else
 571 
         else
572 
         {
 572 
         {
573 
           if (PINB & ADR2) MotorAdresse = 3 + ADRESSOFFSET;
 573 
           if (PINB & ADR2) MotorAdresse = 3 + ADRESSOFFSET;
574 
            else MotorAdresse = 4 + ADRESSOFFSET;
 574 
            else MotorAdresse = 4 + ADRESSOFFSET;
575 
         }
 575 
         }
576 
    HwVersion = 11;
 576 
    HwVersion = 11;
577 
#else
 577 
#else
578 
    MotorAdresse  = MOTORADRESSE;
 578 
    MotorAdresse  = MOTORADRESSE;
579 
    HwVersion = 10;
 579 
    HwVersion = 10;
580 
#endif
 580 
#endif
581 
    if(PIND & 0x80) {HwVersion = 12; IntRef = 0xc0;}    
 581 
    if(PIND & 0x80) {HwVersion = 12; IntRef = 0xc0;}    
582 
    DDRD  = 0xBA;
 582 
    DDRD  = 0xBA;
583 
    UART_Init();
 583 
    UART_Init();
584 
    Timer0_Init();
 584 
    Timer0_Init();
585 
    sei();//Globale Interrupts Einschalten
 585 
    sei();//Globale Interrupts Einschalten
586 
   
 586 
   
587 
    // Am Blinken erkennt man die richtige Motoradresse
 587 
    // Am Blinken erkennt man die richtige Motoradresse
588 
/*
 588 
/*
589 
    for(test=0;test<5;test++)
 589 
    for(test=0;test<5;test++)
590 
        {
 590 
        {
591 
        if(test == MotorAdresse) PORTD |= GRUEN;
 591 
        if(test == MotorAdresse) PORTD |= GRUEN;
592 
        Delay_ms(150);
 592 
        Delay_ms(150);
593 
        PORTD &= ~GRUEN;
 593 
        PORTD &= ~GRUEN;
594 
        Delay_ms(250);
 594 
        Delay_ms(250);
595 
        }      
 595 
        }      
596 
 
 596 
 
597 
    Delay_ms(500);
 597 
    Delay_ms(500);
598 
*/  
 598 
*/  
599 
   // UART_Init();  // war doppelt
 599 
   // UART_Init();  // war doppelt
600 
    PWM_Init();
 600 
    PWM_Init();
601 
 
 601 
 
602 
    InitIC2_Slave(0x50);                           
 602 
    InitIC2_Slave(0x50);                           
603 
    InitPPM();
 603 
    InitPPM();
604 
 
 604 
 
605 
    Blink             = SetDelay(101);    
 605 
    Blink             = SetDelay(101);    
606 
    Blink2            = SetDelay(102);
 606 
    Blink2            = SetDelay(102);
607 
    MinUpmPulse       = SetDelay(103);
 607 
    MinUpmPulse       = SetDelay(103);
608 
    MittelstromTimer  = SetDelay(254);
 608 
    MittelstromTimer  = SetDelay(254);
609 
    DrehzahlMessTimer = SetDelay(1005);
 609 
    DrehzahlMessTimer = SetDelay(1005);
610 
    TestschubTimer    = SetDelay(1006);
 610 
    TestschubTimer    = SetDelay(1006);
611 
    while(!CheckDelay(MinUpmPulse))
 611 
    while(!CheckDelay(MinUpmPulse))
612 
    {
 612 
    {
613 
     if(SollwertErmittlung()) break;
 613 
     if(SollwertErmittlung()) break;
614 
    }
 614 
    }
615 
 
 615 
 
616 
    GRN_ON;
 616 
    GRN_ON;
617 
    PWM = 0;
 617 
    PWM = 0;
618 
 
 618 
 
619 
    SetPWM();
 619 
    SetPWM();
620 
 
 620 
 
621 
    SFIOR = 0x08;  // Analog Comperator ein
 621 
    SFIOR = 0x08;  // Analog Comperator ein
622 
    ADMUX = 1;
 622 
    ADMUX = 1;
623 
 
 623 
 
624 
    MinUpmPulse = SetDelay(10);
 624 
    MinUpmPulse = SetDelay(10);
625 
    DebugOut.Analog[1] = 1;
 625 
    DebugOut.Analog[1] = 1;
626 
    PPM_Signal = 0;
 626 
    PPM_Signal = 0;
627 
 
 627 
 
628 
    if(!SollwertErmittlung()) MotorTon();
 628 
    if(!SollwertErmittlung()) MotorTon();
629 
//MotorTon();    
 629 
//MotorTon();    
630 
    PORTB = 0x31; // Pullups wieder einschalten
 630 
    PORTB = 0x31; // Pullups wieder einschalten
631 
 
 631 
 
632 
    // zum Test der Hardware; Motor dreht mit konstanter Drehzahl ohne Regelung
 632 
    // zum Test der Hardware; Motor dreht mit konstanter Drehzahl ohne Regelung
633 
    if(TEST_MANUELL)    Anwerfen(TEST_MANUELL);  // kommt von dort nicht wieder
 633 
    if(TEST_MANUELL)    Anwerfen(TEST_MANUELL);  // kommt von dort nicht wieder
634 
 
 634 
 
635 
    while (1)
 635 
    while (1)
636 
        {
 636 
        {
637 
//ShowSense();
 637 
//ShowSense();
638 
 
 638 
 
639 
        if(!TEST_SCHUB)   PWM = SollwertErmittlung();
 639 
        if(!TEST_SCHUB)   PWM = SollwertErmittlung();
640 
        //I2C_TXBuffer = PWM; // Antwort über I2C-Bus
 640 
        //I2C_TXBuffer = PWM; // Antwort über I2C-Bus
641 
        if(MANUELL_PWM)   PWM = MANUELL_PWM;
 641 
        if(MANUELL_PWM)   PWM = MANUELL_PWM;
642 
 
 642 
 
643 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 643 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
644 
        if(Phase != altPhase)   // es gab eine Kommutierung im Interrupt
 644 
        if(Phase != altPhase)   // es gab eine Kommutierung im Interrupt
645 
            {
 645 
            {
646 
            MotorGestoppt = 0;
 646 
            MotorGestoppt = 0;
647 
            ZeitFuerBerechnungen = 0;    // direkt nach einer Kommutierung ist Zeit
647 
            ZeitFuerBerechnungen = 0;    // direkt nach einer Kommutierung ist Zeit
648 
            MinUpmPulse = SetDelay(250);  // Timeout, falls ein Motor stehen bleibt
 648 
            MinUpmPulse = SetDelay(250);  // Timeout, falls ein Motor stehen bleibt
649 
            altPhase = Phase;
 649 
            altPhase = Phase;
650 
            }
 650 
            }
651 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 651 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
652 
        if(!PWM)    // Sollwert == 0
 652 
        if(!PWM)    // Sollwert == 0
653 
            {
 653 
            {
654 
            MotorAnwerfen = 0;      // kein Startversuch
 654 
            MotorAnwerfen = 0;      // kein Startversuch
655 
            ZeitFuerBerechnungen = 0;
 655 
            ZeitFuerBerechnungen = 0;
656 
            // nach 1,5 Sekunden den Motor als gestoppt betrachten
656 
            // nach 1,5 Sekunden den Motor als gestoppt betrachten
657 
            if(CheckDelay(MotorGestopptTimer))
 657 
            if(CheckDelay(MotorGestopptTimer))
658 
                {
 658 
                {
659 
                DISABLE_SENSE_INT;
 659 
                DISABLE_SENSE_INT;
660 
                MotorGestoppt = 1;  
 660 
                MotorGestoppt = 1;  
661 
                STEUER_OFF;
 661 
                STEUER_OFF;
662 
                }
 662 
                }
663 
            }
 663 
            }
664 
        else
 664 
        else
665 
            {
 665 
            {
666 
            if(MotorGestoppt) MotorAnwerfen = 1;        // Startversuch
 666 
            if(MotorGestoppt) MotorAnwerfen = 1;        // Startversuch
667 
            MotorGestopptTimer = SetDelay(1500);
 667 
            MotorGestopptTimer = SetDelay(1500);
668 
            }
 668 
            }
669 
 
 669 
 
670 
        if(MotorGestoppt && !TEST_SCHUB) PWM = 0;
 670 
        if(MotorGestoppt && !TEST_SCHUB) PWM = 0;
671 
        SetPWM();
 671 
        SetPWM();
672 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 672 
        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
673 
        if(!ZeitFuerBerechnungen++)
 673 
        if(!ZeitFuerBerechnungen++)
674 
            {
 674 
            {
675 
            if(MotorGestoppt)
 675 
            if(MotorGestoppt)
676 
             {
 676 
             {
677 
//              GRN_ON;
677 
//              GRN_ON;
678 
              FastADConvert();
 678 
              FastADConvert();
679 
             }
 679 
             }
680 
            if(SIO_DEBUG)
 680 
            if(SIO_DEBUG)
681 
                {
 681 
                {
682 
                DebugAusgaben();  // welche Werte sollen angezeigt werden?
 682 
                DebugAusgaben();  // welche Werte sollen angezeigt werden?
683 
                if(!UebertragungAbgeschlossen)  SendUart();
 683 
                if(!UebertragungAbgeschlossen)  SendUart();
684 
                else DatenUebertragung();
 684 
                else DatenUebertragung();
685 
                }
 685 
                }
686 
            // Berechnen des Mittleren Stroms zur (langsamen) Strombegrenzung
 686 
            // Berechnen des Mittleren Stroms zur (langsamen) Strombegrenzung
687 
            if(CheckDelay(MittelstromTimer))  
 687 
            if(CheckDelay(MittelstromTimer))  
688 
                {
 688 
                {
689 
                MittelstromTimer = SetDelay(50); // alle 50ms
 689 
                MittelstromTimer = SetDelay(50); // alle 50ms
690 
                if(Mittelstrom <  Strom) Mittelstrom++;// Mittelwert des Stroms bilden
 690 
                if(Mittelstrom <  Strom) Mittelstrom++;// Mittelwert des Stroms bilden
691 
                else if(Mittelstrom >  Strom) Mittelstrom--;
 691 
                else if(Mittelstrom >  Strom) Mittelstrom--;
692 
                if(Strom > MAX_STROM) MaxPWM -= MaxPWM / 32;              
 692 
                if(Strom > MAX_STROM) MaxPWM -= MaxPWM / 32;              
693 
                if((Mittelstrom > LIMIT_STROM))// Strom am Limit?
 693 
                if((Mittelstrom > LIMIT_STROM))// Strom am Limit?
694 
                    {
 694 
                    {
695 
                    if(MaxPWM) MaxPWM--;// dann die Maximale PWM herunterfahren
 695 
                    if(MaxPWM) MaxPWM--;// dann die Maximale PWM herunterfahren
696 
                    PORTC |= ROT;
 696 
                    PORTC |= ROT;
697 
                    }
 697 
                    }
698 
                else
 698 
                else
699 
                    {
 699 
                    {
700 
                    if(MaxPWM < MAX_PWM) MaxPWM++;
 700 
                    if(MaxPWM < MAX_PWM) MaxPWM++;
701 
                    }
 701 
                    }
702 
                }
 702 
                }
703 
 
 703 
 
704 
            if(CheckDelay(DrehzahlMessTimer))   // Ist-Drehzahl bestimmen
 704 
            if(CheckDelay(DrehzahlMessTimer))   // Ist-Drehzahl bestimmen
705 
                {
 705 
                {
706 
                DrehzahlMessTimer = SetDelay(10);
 706 
                DrehzahlMessTimer = SetDelay(10);
707 
                SIO_Drehzahl = CntKommutierungen;//(6 * CntKommutierungen) / (POLANZAHL / 2);
 707 
                SIO_Drehzahl = CntKommutierungen;//(6 * CntKommutierungen) / (POLANZAHL / 2);
708 
                CntKommutierungen = 0;
 708 
                CntKommutierungen = 0;
709 
               // if(PPM_Timeout == 0) // keine PPM-Signale
 709 
               // if(PPM_Timeout == 0) // keine PPM-Signale
710 
                ZeitZumAdWandeln = 1;
 710 
                ZeitZumAdWandeln = 1;
711 
                }
 711 
                }
712 
 
 712 
 
713 
#if TEST_SCHUB == 1
 713 
#if TEST_SCHUB == 1
714 
           {
 714 
           {
715 
            if(CheckDelay(TestschubTimer))  
 715 
            if(CheckDelay(TestschubTimer))  
716 
                {
 716 
                {
717 
                TestschubTimer = SetDelay(1500);
 717 
                TestschubTimer = SetDelay(1500);
718 
                    switch(test)
 718 
                    switch(test)
719 
                        {
 719 
                        {
720 
                        case 0: PWM = 50; test++; break;
 720 
                        case 0: PWM = 50; test++; break;
721 
                        case 1: PWM = 130; test++; break;
 721 
                        case 1: PWM = 130; test++; break;
722 
                        case 2: PWM = 60;  test++; break;
 722 
                        case 2: PWM = 60;  test++; break;
723 
                        case 3: PWM = 140; test++; break;
 723 
                        case 3: PWM = 140; test++; break;
724 
                        case 4: PWM = 150; test = 0; break;
 724 
                        case 4: PWM = 150; test = 0; break;
725 
                        default: test = 0;
 725 
                        default: test = 0;
726 
                        }
 726 
                        }
727 
                }
 727 
                }
728 
            }  
 728 
            }  
729 
#endif
 729 
#endif
730 
          // Motor Stehen geblieben
 730 
          // Motor Stehen geblieben
731 
            if((CheckDelay(MinUpmPulse) && SIO_Drehzahl == 0) || MotorAnwerfen)
 731 
            if((CheckDelay(MinUpmPulse) && SIO_Drehzahl == 0) || MotorAnwerfen)
732 
                {
 732 
                {
733 
                MotorGestoppt = 1;    
 733 
                MotorGestoppt = 1;    
734 
                DISABLE_SENSE_INT;
 734 
                DISABLE_SENSE_INT;
735 
                MinUpmPulse = SetDelay(100);        
 735 
                MinUpmPulse = SetDelay(100);        
736 
                if(MotorAnwerfen)
 736 
                if(MotorAnwerfen)
737 
                  {
 737 
                  {
738 
                   PORTC &= ~ROT;
 738 
                   PORTC &= ~ROT;
739 
                   Strom_max = 0;
 739 
                   Strom_max = 0;
740 
                   MotorAnwerfen = 0;
 740 
                   MotorAnwerfen = 0;
741 
                   if(Anwerfen(10))
 741 
                   if(Anwerfen(10))
742 
                   {  
 742 
                   {  
743 
//                    GRN_ON;
 743 
//                    GRN_ON;
744 
                    MotorGestoppt = 0;    
 744 
                    MotorGestoppt = 0;    
745 
                    Phase--;
 745 
                    Phase--;
746 
                    PWM = 1;
 746 
                    PWM = 1;
747 
                    SetPWM();
 747 
                    SetPWM();
748 
                    SENSE_TOGGLE_INT;
 748 
                    SENSE_TOGGLE_INT;
749 
                    ENABLE_SENSE_INT;
 749 
                    ENABLE_SENSE_INT;
750 
                    MinUpmPulse = SetDelay(20);
 750 
                    MinUpmPulse = SetDelay(20);
751 
                    while(!CheckDelay(MinUpmPulse)); // kurz Synchronisieren
 751 
                    while(!CheckDelay(MinUpmPulse)); // kurz Synchronisieren
752 
                    PWM = 15;
 752 
                    PWM = 15;
753 
                    SetPWM();
 753 
                    SetPWM();
754 
                    MinUpmPulse = SetDelay(300);
 754 
                    MinUpmPulse = SetDelay(300);
755 
                    while(!CheckDelay(MinUpmPulse)) // kurz Durchstarten
 755 
                    while(!CheckDelay(MinUpmPulse)) // kurz Durchstarten
756 
                    {
 756 
                    {
757 
                      if(Strom > LIMIT_STROM/2)
 757 
                      if(Strom > LIMIT_STROM/2)
758 
                      {
 758 
                      {
759 
                        STEUER_OFF; // Abschalten wegen Kurzschluss
 759 
                        STEUER_OFF; // Abschalten wegen Kurzschluss
760 
                        RotBlink(10);
 760 
                        RotBlink(10);
761 
                        MotorAnwerfen = 1;
 761 
                        MotorAnwerfen = 1;
762 
                      }  
 762 
                      }  
763 
                    }
 763 
                    }
764 
                                    // Drehzahlmessung wieder aufsetzen
 764 
                                    // Drehzahlmessung wieder aufsetzen
765 
                    DrehzahlMessTimer = SetDelay(50);
 765 
                    DrehzahlMessTimer = SetDelay(50);
766 
                    altPhase = 7;
 766 
                    altPhase = 7;
767 
                   }
 767 
                   }
768 
                   else if(SollwertErmittlung()) MotorAnwerfen = 1;
 768 
                   else if(SollwertErmittlung()) MotorAnwerfen = 1;
769 
                  }
 769 
                  }
770 
                }
 770 
                }
771 
            } // ZeitFuerBerechnungen
 771 
            } // ZeitFuerBerechnungen
772 
        } // while(1) - Hauptschleife
 772 
        } // while(1) - Hauptschleife
773 
}
 773 
}
774 
 
 774 
 
775 
 
 775