EDA365电子论坛网

标题: 德国MK项目BLDC电调程序的源码！ [打印本页]

作者: kinidrily 时间: 2019-1-23 13:46
标题: 德国MK项目BLDC电调程序的源码！
德国MK项目BLDC电调程序的源码！

#include "main.h"
unsigned int  PWM = 0;
unsigned int  Strom = 0; //ca. in 0,1A
unsigned char Strom_max = 0;
unsigned char Mittelstrom = 0;
unsigned int  Drehzahl = 0;  // in 100UPM  60 = 6000
unsigned int  KommutierDelay = 10;
unsigned int  I2C_Timeout = 0;
unsigned char SIO_Timeout = 0;
unsigned int  SollDrehzahl = 0;
unsigned int  IstDrehzahl = 0;
unsigned int  DrehZahlTabelle[256];//vorberechnete Werte zur Drehzahlerfassung
unsigned char ZeitFuerBerechnungen = 1;
unsigned char MotorAnwerfen = 0;
unsigned char MotorGestoppt = 1;
unsigned char MaxPWM = MAX_PWM;
unsigned int  CntKommutierungen = 0;
unsigned int  SIO_Drehzahl = 0;
unsigned char ZeitZumAdWandeln = 1;

//############################################################################
//
void SetPWM(void)
//############################################################################
{
unsigned char tmp_pwm;
tmp_pwm = PWM;
if(tmp_pwm > MaxPWM) // Strombegrenzung
      {
      tmp_pwm = MaxPWM;
      PORTC |= ROT;
      }
if(Strom > MAX_STROM) // Strombegrenzung
      {
      OCR1A = 0; OCR1B = 0; OCR2  = 0;
      PORTC |= ROT;
      Strom--;
      }
else
      {
      #ifdef  _32KHZ
      OCR1A =  tmp_pwm; OCR1B =  tmp_pwm; OCR2  = tmp_pwm;
      #endif
      #ifdef  _16KHZ
      OCR1A = 2 * (int)tmp_pwm; OCR1B = 2 * (int)tmp_pwm; OCR2  = tmp_pwm;
      #endif
      }
}
//############################################################################
//
void PWM_Init(void)
//############################################################################
{
PWM_OFF;
TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (1 << WGM12) |
         (0 << WGM13) | (0<< ICES1) | (0 << ICNC1);
}
//############################################################################
//
void Wait(unsigned char dauer)
//############################################################################
{
dauer = (unsigned char)TCNT0 + dauer;
while((TCNT0 - dauer) & 0x80);
}
//############################################################################
//
void Anwerfen(unsigned char pwm)
//############################################################################
{
unsigned long timer = 300,i;
DISABLE_SENSE_INT;
PWM = 5;
SetPWM();
Manuell();
Delay_ms(200);
PWM = pwm;
while(1)
      {
      for(i=0;i<timer; i++)
         {
         if(!UebertragungAbgeschlossen)  SendUART();
         else DatenUebertragung();
         Wait(100);  // warten
         }
      timer-= timer/15+1;
      if(timer < 25) { if(TEST_MANUELL) timer = 25; else return; }
      Manuell();
      Phase++;
      Phase %= 6;
      ADConvert();
      PWM = pwm;
      SetPWM();
      if(SENSE)
         {
         PORTD ^= GRUEN;
         }
      }
}
//############################################################################
//
unsigned char SollwertErmittlung(void)
//############################################################################
{
static unsigned int sollwert = 0;
unsigned int ppm;
if(!I2C_Timeout) // bei Erreichen von 0 ist der Wert ungültig
      {
      if(SIO_Timeout)  // es gibt gültige SIO-Daten
         {
         sollwert =  (MAX_PWM * (unsigned int) SIO_Sollwert) / 200;  // skalieren auf 0-200 = 0-255
         }
      else
         if(PPM_Timeout)  // es gibt gültige PPM-Daten
            {
            ppm = PPM_Signal;
            if(ppm > 300) ppm = 0;  // ungültiges Signal
            if(ppm > 200) ppm = 200;
            if(ppm <= MIN_PPM) sollwert = 0;
            else
                  {
                  sollwert = (int) MIN_PWM + ((MAX_PWM - MIN_PWM) * (ppm - MIN_PPM)) / (190 - MIN_PPM);
                  }
            PORTC &= ~ROT;
            }
         else // Kein gültiger Sollwert
            {
            if(!TEST_SCHUB) { if(sollwert) sollwert--; }
            PORTC |= ROT;
            }
      }
else // I2C-Daten sind gültig
      {
      sollwert = I2C_RXBuffer;
      PORTC &= ~ROT;
      }
if(sollwert > MAX_PWM) sollwert = MAX_PWM;
return(sollwert);
}
void DebugAusgaben(void)
{
DebugOut.Analog[0] = Strom;
DebugOut.Analog[1] = Mittelstrom;
DebugOut.Analog[2] = SIO_Drehzahl;
DebugOut.Analog[3] = PPM_Signal;
}

//############################################################################
//Hauptprogramm
int main (void)
//############################################################################
{
char altPhase = 0;
int test = 0;
unsigned int MinUpmPulse,Blink,TestschubTimer;
unsigned int Blink2,MittelstromTimer,DrehzahlMessTimer,MotorGestopptTimer;
DDRC  = 0x08;
PORTC = 0x08;
DDRD  = 0xBA;
PORTD = 0x80;
DDRB  = 0x0E;
PORTB = 0x31;

UART_Init();
Timer0_Init();
sei ();//Globale Interrupts EinschaLTEn

// Am Blinken erkennt man die richtige Motoradresse
for(test=0;test<5;test++)
      {
      if(test == MOTORADRESSE) PORTD |= GRUEN;
      Delay_ms(150);
      PORTD &= ~GRUEN;
      Delay_ms(250);
      }
Delay_ms(500);

UART_Init();
PWM_Init();
InitIC2_Slave(0x50);
InitPPM();
Blink          = SetDelay(101);
Blink2          = SetDelay(102);
MinUpmPulse    = SetDelay(103);
MittelstromTimer  = SetDelay(254);
DrehzahlMessTimer = SetDelay(1005);
TestschubTimer = SetDelay(1006);
while(!CheckDelay(MinUpmPulse));
PORTD |= GRUEN;
PWM = 0;
SetPWM();
SFIOR = 0x08;  // Analog Comperator ein
ADMUX = 1;
MinUpmPulse = SetDelay(10);
DebugOut.Analog[1] = 1;
PPM_Signal = 0;
// zum Test der Hardware; Motor dreht mit konstanter Drehzahl ohne Regelung
if(TEST_MANUELL) Anwerfen(TEST_MANUELL);  // kommt von dort nicht wieder
while (1)
      {
      if(!TEST_SCHUB) PWM = SollwertErmittlung();
      //I2C_TXBuffer = PWM; // Antwort über I2C-Bus
      if(MANUELL_PWM) PWM = MANUELL_PWM;
      // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      if(Phase != altPhase) // es gab eine Kommutierung im Interrupt
         {
         MotorGestoppt = 0;
         ZeitFuerBerechnungen = 0; // direkt nach einer Kommutierung ist Zeit
         MinUpmPulse = SetDelay(50);  // Timeout, falls ein Motor stehen bleibt
         altPhase = Phase;
         }
      // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      if(!PWM) // Sollwert == 0
         {
         MotorAnwerfen = 0;    // kein startversuch
         ZeitFuerBerechnungen = 0;
         // nach 1,5 Sekunden den Motor als gestoppt betrachten
         if(CheckDelay(DrehzahlMessTimer))
            {
            DISABLE_SENSE_INT;
            MotorGestoppt = 1;
            STEUER_OFF;
            }
         }
      else
         {
         if(MotorGestoppt) MotorAnwerfen = 1;       // Startversuch
         MotorGestopptTimer = SetDelay(1500);
         }
      if(MotorGestoppt && !TEST_SCHUB) PWM = 0;
      SetPWM();
      // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      if(!ZeitFuerBerechnungen++)
         {
         if(MotorGestoppt) PORTD |= GRUEN; //else PORTD &= ~GRUEN;
         if(SIO_DEBUG)
            {
            DebugAusgaben();  // welche Werte sollen angezeigt werden?
            if(!UebertragungAbgeschlossen)  SendUart();
            else DatenUebertragung();
            }
         // Berechnen des Mittleren Stroms zur (langsamen) Strombegrenzung
         if(CheckDelay(MittelstromTimer))
            {
            MittelstromTimer = SetDelay(50); // alle 50ms
            if(Mittelstrom <  Strom) Mittelstrom++;// Mittelwert des Stroms bilden
            else if(Mittelstrom >  Strom) Mittelstrom--;

            if(Mittelstrom > LIMIT_STROM)// Strom am Limit?
                  {
                  MaxPWM--;// dann die Maximale PWM herunterfahren
                  PORTC |= ROT;
                  }
            else
                  {
                  if(MaxPWM < MAX_PWM) MaxPWM++;
                  }
            }
         if(CheckDelay(DrehzahlMessTimer)) // Ist-Drehzahl bestimmen
            {
            DrehzahlMessTimer = SetDelay(10);
            SIO_Drehzahl = (6 * CntKommutierungen) / (POLANZAHL / 2);
            CntKommutierungen = 0;
            if(PPM_Timeout == 0) // keine PPM-Signale
            ZeitZumAdWandeln = 1;
            }

         if(CheckDelay(TestschubTimer))
            {
            TestschubTimer = SetDelay(1500);
            if(TEST_SCHUB)
                  {
                  switch(test)
                     {
                     case 0: PWM = 50; test++; break;
                     case 1: PWM = 130; test++; break;
                     case 2: PWM = 60;  test++; break;
                     case 3: PWM = 140; test++; break;
                     case 4: PWM = 150; test = 0; break;
                     default: test = 0;
                     }
                  }
            }
         // Motor Stehen geblieben
         if((CheckDelay(MinUpmPulse) && SIO_Drehzahl == 0) || MotorAnwerfen)
            {
            MotorGestoppt = 1;
            DISABLE_SENSE_INT;
            MinUpmPulse = SetDelay(100);
            if(MotorAnwerfen)
                  {
                  PORTC &= ~ROT;
                  MotorAnwerfen = 0;
                  Anwerfen(10);
                  PORTD |= GRUEN;
                  MotorGestoppt = 0;
                  Phase--;
                  PWM = 1;
                  SetPWM();
                  SENSE_TOGGLE_INT;
                  ENABLE_SENSE_INT;
                  MinUpmPulse = SetDelay(100);
                  while(!CheckDelay(MinUpmPulse)); // kurz Synchronisieren
                  PWM = 10;
                  SetPWM();
                  MinUpmPulse = SetDelay(200);
                  while(!CheckDelay(MinUpmPulse)); // kurz Durchstarten
                  MinUpmPulse = SetDelay(1000);
                  altPhase = 7;
                  }
            }
         } // ZeitFuerBerechnungen
      } // while(1) - Hauptschleife
}
这个是部分的源码有想要了解的就去下载看吧
下载：

作者: cat12620 时间: 2019-1-23 15:29
谢谢分享

作者: wzhzn 时间: 2019-2-23 20:17
谢谢，学习！

作者: aaron_he 时间: 2019-6-15 19:32
谢谢分享，学习参观

作者: 2679609 时间: 2019-6-19 10:26
我想下载

作者: nyszx 时间: 2019-6-25 16:34
看一下啥情况

作者: lcszhl 时间: 2019-6-25 17:49
路过

作者: cdwlll 时间: 2019-7-25 14:25
正好需要，很感谢

作者: xj891110 时间: 2019-8-5 14:20
谢谢分享，学习参观！

作者: ryann 时间: 2019-8-22 22:27
好东西，顶一下

作者: shiyongzhu 时间: 2020-3-5 20:43
谢谢分享，感谢楼主。

作者: rm10b0 时间: 2020-3-10 10:02
这里没看到控制算法？

作者: jiaman520 时间: 2020-3-27 15:48
谢谢分享，学习参观

作者: vashonchen 时间: 2020-4-7 20:13
谢谢分享，学习参观

作者: 放烟花飞过海 时间: 2020-5-24 21:48
德国人但是

作者: lixiang_wx 时间: 2020-7-5 13:22
感谢谢分享，看看是否可用

作者: emanages 时间: 2020-7-31 14:05
感谢分享DDDDDDDDDDDDDDDDDDDDDDDDDD

作者: colcol 时间: 2020-8-10 23:32
看看

作者: 风中沙 时间: 2020-8-28 13:49
可以

作者: ixiaoxian 时间: 2020-9-14 16:54
good

作者: ixiaoxian 时间: 2020-9-15 10:21
谢谢分享，是用什么编译器？

作者: 阿牛叔 时间: 2020-10-5 17:28
xuexiyixia

作者: chengc31 时间: 2020-12-4 10:40
很好，看看

作者: yupw24 时间: 2021-1-22 17:44
感谢分享！感谢分享！感谢分享！

作者: love2008 时间: 2021-4-19 21:24
这个是几点版本

作者: marks_liu11 时间: 2021-5-31 18:00
好文章。感谢分享！感谢分享！感谢分享

作者: ryann 时间: 2021-8-31 15:39
感谢分享！

作者: devilzhang412 时间: 2021-9-1 17:21
初学，谢谢！

作者: ryann 时间: 2021-9-3 16:05
感谢分享！！！

作者: wtf2014 时间: 2021-10-11 20:16
太好了

作者: kobewgq 时间: 2021-10-20 17:38
谢谢分享，学习参观!

作者: weishiding 时间: 2021-11-26 23:37
kankan

作者: clgoal 时间: 2021-12-18 14:14
好东西，可惜注释是德语

作者: sjzwangjh 时间: 2022-1-26 23:30
好东西。看看。

作者: polo70 时间: 2022-7-7 18:08
很需要看看

作者: 107485133 时间: 2022-12-5 11:15
谢谢分享！

作者: rete0786 时间: 2022-12-12 17:40
谢谢分享

作者: rete0786 时间: 2022-12-12 17:42
这个有对应的原理图和PCB文件吗？

作者: star2002star 时间: 2025-3-18 17:33
谢谢分享，学习参观

欢迎光临 EDA365电子论坛网 (https://bbs.eda365.com/)