Ist mein µC schnell genug?

[Alex H. (sherlock)]

Hallo Leute!



Ich bin dabei einen Code für einen BLDC Motor Treiber zu schreiben.
Der Code ist noch nicht ganz fertig und wenn ich auf build klicke, zeigt 
mir das Programm folgendes:

Program Memory Usage   :  6910 bytes   21,1 % Full

Speicher ist zwar noch genügend da, aber bei einem Motor Treiber ist 
genaues Timing ja sehr wichtig.

Wie finde ich heraus ob mein ATmega32 schnell genug für den Code ist, 
oder muss ich mir da keine sogen machen solange der Programm Speicher 
nicht voll ist?

[Henning (Gast)]

Die Codegröße hat doch rein gar nichts mit der Geschwindigkeit zu tun.

[Alex H. (sherlock)]

Das habe ich mir gedacht, aber wie finde ich das dann raus?

[Andreas B. (bitverdreher)]

Indem Du das ausprobierst.
Ansonsten: wenn  Du mehr Infos rausrückst (Code), kann man das 
vielleicht abschätzen.

Gruß
Andreas

[Stefan P. (form)]

Setz im Programm an den Stellen wo nichts getan wird ein Pin auf High 
und schau Dir das Puls/Pausen-Verhälntnis auf einem Oszi an. Damit 
kannst Du deine µC-Load von 0..100% ausrechnen.

[Frank (Gast)]

Das hängt von Deinem Programm ab. Wie schnell muß an den IO-Ports 
gewackelt werden? Wie schnell muß der µC auf Interrupts reagieren bzw. 
was muß er in welcher Zeit erledigen? Da gibt es keine pauschale 
Antwort. Wie Henning schon gesagt hat, mit der Programmgröße hat das 
überhaupt nix zu tun.

Frank

[Frank M. (ukw) (Moderator)]

Alex H. schrieb:
> Das habe ich mir gedacht, aber wie finde ich das dann raus?

LSS-Datei anschauen, im Datenblatt nachsehen, wieviel Takte welcher 
Befehl verbraucht, die Takte addieren und dann mittels F_CPU in eine 
Zeit umrechnen.

[Mike (Gast)]

>Wie finde ich heraus ob mein ATmega32
Also normalerweise macht das ein AVR mit links! (Optimierung beim 
Compilieren einschalten!)

Wieviele MHz hat dein AVR und wievile kHz braucht dein Motor?

[Tobias L. (murxwitz)]

messen?
pinwackeln (an passender Stelle im Programm zb Anfang main()) und die 
Frequenz messen

[Frank M. (ukw) (Moderator)]

Stefan P. schrieb:
> Setz im Programm an den Stellen wo nichts getan wird ein Pin auf High
> und schau Dir das Puls/Pausen-Verhälntnis auf einem Oszi an. Damit
> kannst Du deine µC-Load von 0..100% ausrechnen.

Ich glaube, er will nicht die CPU-Last wissen, sondern wieviel Zeit 
bestimmte Teile seines Programms benötigen.

[Alex H. (sherlock)]

Achso Danke, ich werde erstmal das mit dem Pinwackeln ausprobieren, das 
hört sich am Einfachsten an :)

[kopfkratzer (Gast)]

kopfkratz
Wenn man ja wissen würde wie schnell Dein µC getaktet ist, 1MHz intern 
oder 20MHz extern ?
Was soll Dein Programm tun, eine Rampe für den Motor abbilden ?
Glaskugelbestell

[Alex H. (sherlock)]

start.h:

/*
 * start.h
 *
 * Created: 26.09.2013 08:55:17
 *  Author: Alex
 */ 


#include <avr/io.h>
#include <avr/interrupt.h>
#include <math.h>


#ifndef F_CPU
#define F_CPU           1000000UL //1MHZ
#endif


#ifndef START_H_
#define START_H_





#endif /* START_H_ */









struct Treiber
{
  public:
  
  uint16_t      Anlauf      ( uint16_t drehzahl_soll );
  void        Steps      ( unsigned int anlauf_step, unsigned int interrupt_step, uint8_t pPWM, unsigned int U_interr );
  short        PWM        ( uint8_t vPWM );
  signed long long  TSEC_ber    ( unsigned int degree_ist, unsigned int Umin_soll, unsigned int Umin, unsigned long long t_U );
  unsigned int    Umin_ber    ( unsigned int winkel1 );
  unsigned long long  TimeU      ( unsigned int winkel2 );
  unsigned int    Time_toStep    ( signed long long StepTime, unsigned int BEMFwinkel );
  

  
  
  
  private:
  

  uint8_t vPWMc;
  
  
  
  unsigned long long  t_seq;
  unsigned int    degree_max;
  unsigned int    Umin_max;
  signed int      degree;
  unsigned long long  time;
  unsigned int    U;
  unsigned int    Uret;
  unsigned long long  time2;
  unsigned long long  time_ret;
  unsigned char    ii;  
  unsigned char    iii;
  unsigned char    stepAnlauf;
  unsigned char    go;
  unsigned long long  changeTime;
  unsigned long long  cTime;
  unsigned int    step;
  
  unsigned int sStep;
  
  
  
  unsigned long long W30;
  unsigned int stop1;
  signed long long StepTime1;
  unsigned long long StepTimer1;
  
  unsigned long long W90;
  unsigned int stop2;
  signed long long StepTime2;
  unsigned long long StepTimer2;
  
  unsigned long long W150;
  unsigned int stop3;
  signed long long StepTime3;
  unsigned long long StepTimer3;
  
  unsigned long long W210;
  unsigned int stop4;
  signed long long StepTime4;
  unsigned long long StepTimer4;
        
  unsigned long long W270;
  unsigned int stop5;
  signed long long StepTime5;
  unsigned long long StepTimer5;
  
  unsigned long long W330;
  unsigned int stop6;
  signed long long StepTime6;
  unsigned long long StepTimer6;
  
};

work.cpp

/*
 * work.cpp
 *
 * Created: 26.09.2013 09:00:33
 *  Author: Alex
 */ 



#include "start.h"




#define    phase1m              PC0
#define    phase1p              PC1
#define    phase2m              PC2
#define    phase2p              PC3
#define    phase3m              PC4
#define    phase3p              PC5
#define    maxWinkelBEMF          60
#define    maxDrehzahlUnterschied      50







uint16_t Treiber::Anlauf(uint16_t drehzahl_soll )
{
  uint16_t drehzahl_ist;

  
  if (drehzahl_ist<drehzahl_soll  )
  {
    drehzahl_ist += 1;
  }
  changeTime = 1/(drehzahl_ist/60)*1000000;
  
  cTime++;
  if(cTime > changeTime)
  {
    stepAnlauf++;
    cTime = 0;
  }  
  if(stepAnlauf == 6)
  {
    stepAnlauf == 0;
  }
  
  return stepAnlauf;
}


void Treiber::Steps(unsigned int anlauf_step, unsigned int interrupt_step, uint8_t pPWM, unsigned int U_interr)
{

  if(U_interr == 0)
  {
    step = anlauf_step;
  }
  else
  {
    step = interrupt_step;
  }

  if ( step == 0 && pPWM == 1 )
  {
    PORTC &=   ~( (1<<phase1m)  |  (1<<phase2p)  |  (1<<phase3p)  |  (1<<phase2m) );
    PORTC |=    ( (1<<phase1p)  |  (1<<phase3m) );
    MCUCR &=  ~(  1<<ISC00 );    
  }    


  if ( step == 1 && pPWM == 1 )
  {
    PORTC &=   ~( (1<<phase1m)  |  (1<<phase2p)  |  (1<<phase3p)  |  (1<<phase3m) );
    PORTC |=    ( (1<<phase1p)  |  (1<<phase2m) );
    MCUCR |=   (  1<<ISC10 );
  }



  if ( step == 2 && pPWM == 1 )
  {
    PORTC &=   ~( (1<<phase1m)  |  (1<<phase2p)  |  (1<<phase1p)  |  (1<<phase3m) );
    PORTC |=    ( (1<<phase3p)  |  (1<<phase2m) );
    MCUCSR &=   ~(1<<ISC2);
  }



  if ( step == 3 && pPWM == 1 )
  {

    PORTC &=   ~( (1<<phase1p)  |  (1<<phase2p)  |  (1<<phase2m)  |  (1<<phase3m) );
    PORTC |=    ( (1<<phase1m)  |  (1<<phase3p) );
    MCUCR |=   ( 1<<ISC00);
  }


  if ( step == 4 && pPWM == 1 )
  {
    PORTC &=   ~( (1<<phase1p)  |  (1<<phase2m)  |  (1<<phase3p)  |  (1<<phase3m) );
    PORTC |=    ( (1<<phase1m)  |  (1<<phase2p) );
    MCUCR &=  ~(1<<ISC10);
  }



  if ( step == 5 && pPWM == 1 )
  {
    PORTC &=   ~( (1<<phase1m)  |  (1<<phase2m)  |  (1<<phase3p)  |  (1<<phase1p) );
    PORTC |=    ( (1<<phase2p)  |  (1<<phase3m) );
    MCUCSR |=  ( 1<<ISC2);
  }
  
  
  if(pPWM == 0)
  {
    PORTC &=   ~( (1<<phase1m)  |  (1<<phase2p)  |  (1<<phase3m)  |  (1<<phase2m)  |  (1<<phase3p)  |  (1<<phase1p) );  
  }

}


short Treiber::PWM(uint8_t vPWM)
{
  vPWMc ++;
  if (vPWMc>=100)
  {
    vPWMc = 0;
  }
  if (vPWM>vPWMc)
  {
    return 1;
  }
  else
  {
    return 0;
  }
}


signed long long Treiber::TSEC_ber (unsigned int degree_ist, unsigned int Umin_soll, unsigned int Umin, unsigned long long t_U )
{
  if( (Umin_soll-Umin)/maxDrehzahlUnterschied*maxWinkelBEMF > maxWinkelBEMF ) // 50 maximaler Umin unterschied
  {
    degree = maxWinkelBEMF;
  }
  
  else if( (Umin_soll-Umin)/maxDrehzahlUnterschied*maxWinkelBEMF < -maxWinkelBEMF ) // 50 maximaler Umin unterschied
  {
    degree = -maxWinkelBEMF;
  }
  
  else
  {
    degree = (Umin_soll-Umin)/maxDrehzahlUnterschied*maxWinkelBEMF;  
  }
  
  return (degree_ist+degree)/degree_ist*t_U-t_U;
  
}





unsigned int Treiber::Umin_ber(unsigned int winkel1)
{
  time ++;
  
  
  if (time >= 1000000)
  {
    Uret = U;
    U = 0;
    time = 0;
  }
  
  if (winkel1 == 330 && ii == 0)
  {
    U++;
    ii = 1;
  }
  if( winkel1 != 330 && ii == 1 )
  {
    ii = 0; 
  }
  
  return Uret*60;
}


unsigned long long Treiber::TimeU(unsigned int winkel2)
{
  time2++;

  if( winkel2 == 330 && iii == 0)
  {
    time_ret = time2;
    time2=0;
    iii = 1;    
  }
  if( winkel2 != 330 && iii == 1)
  {
    iii = 0;
  }
  return time_ret; 
}


unsigned int Treiber::Time_toStep(signed long long StepTime, unsigned int BEMFwinkel )
{
  



  
  if( BEMFwinkel == 30 )
  {
    W30++;////////////
    if(stop1 == 0)
    {
      StepTime1 = StepTime; 
      stop1 = 1;    
    }
  }
  else
  {
    stop1 = 0;  
  }
  

  StepTimer1++;
  
  
  if( StepTimer1 >= StepTime1 + ( W330 * 1.5 ) )
  {
    sStep = 1;
    W330 = 0;/////////////////
    StepTimer1 = 0;      
  }
  
  
  
  
  
  
  
  
  
  if( BEMFwinkel == 90 )
  {
    W90++;////////////
    if(stop2 == 0)
    {
      StepTime2 = StepTime; 
      stop2 = 1;    
    }
  }
  else
  {
    stop2 = 0;  
  }
  

  StepTimer2++;
  
  
  if( StepTimer2 >= StepTime2 + ( W30 * 1.5 ) )
  {
    sStep = 2;
    W30 = 0;/////////////////
    StepTimer2 = 0;    
  }  

  
  
  
  
  

      
  if( BEMFwinkel == 150 )
  {
    W150++;////////////
    if(stop3 == 0)
    {
      StepTime3 = StepTime; 
      stop3 = 1;    
    }
  }
  else
  {
    stop3 = 0;  
  }
  

  StepTimer3++;
  
  
  if( StepTimer3 >= StepTime3 + ( W90 * 1.5 ) )
  {
    sStep = 3;
    W90 = 0;/////////////////
    StepTimer3 = 0;    
  }
  
  
  
  
  
  
  
  
  if( BEMFwinkel == 210 )
  {
    W210++;////////////
    if(stop4 == 0)
    {
      StepTime4 = StepTime; 

      stop4 = 1;    
    }
  }
  else
  {
    stop4 = 0;  
  }
  

  StepTimer4++;
  
  
  if( StepTimer4 >= StepTime4 + ( W150 * 1.5 ) )
  {
    sStep = 4;
    W150 = 0;/////////////////
    StepTimer4 = 0;    
  }  
  
  
  
  
  
  

  
  
  if( BEMFwinkel == 270 )
  {
    W270++;////////////
    if(stop5 == 0)
    {
      StepTime5 = StepTime; 

      stop5 = 1;    
    }
  }
  else
  {
    stop5 = 0;  
  }
  

  StepTimer5++;
  
  
  if( StepTimer5 >= StepTime5 + ( W210 * 1.5 ) )
  {
    sStep = 5;
    W210 = 0;/////////////////
    StepTimer5 = 0;  
  }
  
  
  
  
  
  
  
  
  
  if( BEMFwinkel == 330 )
  {
    W330++;////////////
    if(stop6 == 0)
    {
      StepTime6 = StepTime; 
      stop6 = 1;    
    }
  }
  else
  {
    stop6 = 0;  
  }
  

  StepTimer6++;
  
  
  if( StepTimer6 >= StepTime6 + ( W270 * 1.5 ) )
  {
    sStep = 0;
    W270 = 0;/////////////////
    StepTimer6 = 0;  
  }  




  return sStep;
}

BLDC_Driver.cpp

/*
 * work.cpp
 *
 * Created: 26.09.2013 09:00:33
 *  Author: Alex
 */ 



#include "start.h"




#define    phase1m              PC0
#define    phase1p              PC1
#define    phase2m              PC2
#define    phase2p              PC3
#define    phase3m              PC4
#define    phase3p              PC5
#define    maxWinkelBEMF          60
#define    maxDrehzahlUnterschied      50







uint16_t Treiber::Anlauf(uint16_t drehzahl_soll )
{
  uint16_t drehzahl_ist;

  
  if (drehzahl_ist<drehzahl_soll  )
  {
    drehzahl_ist += 1;
  }
  changeTime = 1/(drehzahl_ist/60)*1000000;
  
  cTime++;
  if(cTime > changeTime)
  {
    stepAnlauf++;
    cTime = 0;
  }  
  if(stepAnlauf == 6)
  {
    stepAnlauf == 0;
  }
  
  return stepAnlauf;
}


void Treiber::Steps(unsigned int anlauf_step, unsigned int interrupt_step, uint8_t pPWM, unsigned int U_interr)
{

  if(U_interr == 0)
  {
    step = anlauf_step;
  }
  else
  {
    step = interrupt_step;
  }

  if ( step == 0 && pPWM == 1 )
  {
    PORTC &=   ~( (1<<phase1m)  |  (1<<phase2p)  |  (1<<phase3p)  |  (1<<phase2m) );
    PORTC |=    ( (1<<phase1p)  |  (1<<phase3m) );
    MCUCR &=  ~(  1<<ISC00 );    
  }    


  if ( step == 1 && pPWM == 1 )
  {
    PORTC &=   ~( (1<<phase1m)  |  (1<<phase2p)  |  (1<<phase3p)  |  (1<<phase3m) );
    PORTC |=    ( (1<<phase1p)  |  (1<<phase2m) );
    MCUCR |=   (  1<<ISC10 );
  }



  if ( step == 2 && pPWM == 1 )
  {
    PORTC &=   ~( (1<<phase1m)  |  (1<<phase2p)  |  (1<<phase1p)  |  (1<<phase3m) );
    PORTC |=    ( (1<<phase3p)  |  (1<<phase2m) );
    MCUCSR &=   ~(1<<ISC2);
  }



  if ( step == 3 && pPWM == 1 )
  {

    PORTC &=   ~( (1<<phase1p)  |  (1<<phase2p)  |  (1<<phase2m)  |  (1<<phase3m) );
    PORTC |=    ( (1<<phase1m)  |  (1<<phase3p) );
    MCUCR |=   ( 1<<ISC00);
  }


  if ( step == 4 && pPWM == 1 )
  {
    PORTC &=   ~( (1<<phase1p)  |  (1<<phase2m)  |  (1<<phase3p)  |  (1<<phase3m) );
    PORTC |=    ( (1<<phase1m)  |  (1<<phase2p) );
    MCUCR &=  ~(1<<ISC10);
  }



  if ( step == 5 && pPWM == 1 )
  {
    PORTC &=   ~( (1<<phase1m)  |  (1<<phase2m)  |  (1<<phase3p)  |  (1<<phase1p) );
    PORTC |=    ( (1<<phase2p)  |  (1<<phase3m) );
    MCUCSR |=  ( 1<<ISC2);
  }
  
  
  if(pPWM == 0)
  {
    PORTC &=   ~( (1<<phase1m)  |  (1<<phase2p)  |  (1<<phase3m)  |  (1<<phase2m)  |  (1<<phase3p)  |  (1<<phase1p) );  
  }

}


short Treiber::PWM(uint8_t vPWM)
{
  vPWMc ++;
  if (vPWMc>=100)
  {
    vPWMc = 0;
  }
  if (vPWM>vPWMc)
  {
    return 1;
  }
  else
  {
    return 0;
  }
}


signed long long Treiber::TSEC_ber (unsigned int degree_ist, unsigned int Umin_soll, unsigned int Umin, unsigned long long t_U )
{
  if( (Umin_soll-Umin)/maxDrehzahlUnterschied*maxWinkelBEMF > maxWinkelBEMF ) // 50 maximaler Umin unterschied
  {
    degree = maxWinkelBEMF;
  }
  
  else if( (Umin_soll-Umin)/maxDrehzahlUnterschied*maxWinkelBEMF < -maxWinkelBEMF ) // 50 maximaler Umin unterschied
  {
    degree = -maxWinkelBEMF;
  }
  
  else
  {
    degree = (Umin_soll-Umin)/maxDrehzahlUnterschied*maxWinkelBEMF;  
  }
  
  return (degree_ist+degree)/degree_ist*t_U-t_U;
  
}





unsigned int Treiber::Umin_ber(unsigned int winkel1)
{
  time ++;
  
  
  if (time >= 1000000)
  {
    Uret = U;
    U = 0;
    time = 0;
  }
  
  if (winkel1 == 330 && ii == 0)
  {
    U++;
    ii = 1;
  }
  if( winkel1 != 330 && ii == 1 )
  {
    ii = 0; 
  }
  
  return Uret*60;
}


unsigned long long Treiber::TimeU(unsigned int winkel2)
{
  time2++;

  if( winkel2 == 330 && iii == 0)
  {
    time_ret = time2;
    time2=0;
    iii = 1;    
  }
  if( winkel2 != 330 && iii == 1)
  {
    iii = 0;
  }
  return time_ret; 
}


unsigned int Treiber::Time_toStep(signed long long StepTime, unsigned int BEMFwinkel )
{
  



  
  if( BEMFwinkel == 30 )
  {
    W30++;////////////
    if(stop1 == 0)
    {
      StepTime1 = StepTime; 
      stop1 = 1;    
    }
  }
  else
  {
    stop1 = 0;  
  }
  

  StepTimer1++;
  
  
  if( StepTimer1 >= StepTime1 + ( W330 * 1.5 ) )
  {
    sStep = 1;
    W330 = 0;/////////////////
    StepTimer1 = 0;      
  }
  
  
  
  
  
  
  
  
  
  if( BEMFwinkel == 90 )
  {
    W90++;////////////
    if(stop2 == 0)
    {
      StepTime2 = StepTime; 
      stop2 = 1;    
    }
  }
  else
  {
    stop2 = 0;  
  }
  

  StepTimer2++;
  
  
  if( StepTimer2 >= StepTime2 + ( W30 * 1.5 ) )
  {
    sStep = 2;
    W30 = 0;/////////////////
    StepTimer2 = 0;    
  }  

  
  
  
  
  

      
  if( BEMFwinkel == 150 )
  {
    W150++;////////////
    if(stop3 == 0)
    {
      StepTime3 = StepTime; 
      stop3 = 1;    
    }
  }
  else
  {
    stop3 = 0;  
  }
  

  StepTimer3++;
  
  
  if( StepTimer3 >= StepTime3 + ( W90 * 1.5 ) )
  {
    sStep = 3;
    W90 = 0;/////////////////
    StepTimer3 = 0;    
  }
  
  
  
  
  
  
  
  
  if( BEMFwinkel == 210 )
  {
    W210++;////////////
    if(stop4 == 0)
    {
      StepTime4 = StepTime; 

      stop4 = 1;    
    }
  }
  else
  {
    stop4 = 0;  
  }
  

  StepTimer4++;
  
  
  if( StepTimer4 >= StepTime4 + ( W150 * 1.5 ) )
  {
    sStep = 4;
    W150 = 0;/////////////////
    StepTimer4 = 0;    
  }  
  
  
  
  
  
  

  
  
  if( BEMFwinkel == 270 )
  {
    W270++;////////////
    if(stop5 == 0)
    {
      StepTime5 = StepTime; 

      stop5 = 1;    
    }
  }
  else
  {
    stop5 = 0;  
  }
  

  StepTimer5++;
  
  
  if( StepTimer5 >= StepTime5 + ( W210 * 1.5 ) )
  {
    sStep = 5;
    W210 = 0;/////////////////
    StepTimer5 = 0;  
  }
  
  
  
  
  
  
  
  
  
  if( BEMFwinkel == 330 )
  {
    W330++;////////////
    if(stop6 == 0)
    {
      StepTime6 = StepTime; 
      stop6 = 1;    
    }
  }
  else
  {
    stop6 = 0;  
  }
  

  StepTimer6++;
  
  
  if( StepTimer6 >= StepTime6 + ( W270 * 1.5 ) )
  {
    sStep = 0;
    W270 = 0;/////////////////
    StepTimer6 = 0;  
  }  




  return sStep;
}

Ich konnte den Code noch nicht Testen, daher ist es sehr warscheinlich, 
das sich noch viele fehler darin befinden.
Ich hoffe ihr steigt da durch, und habt nicht allzuviel zu meckern :D



Achja der Motor ist ein Graupner Compact 260 8.4V

Er macht 9100 U/min
Anzahl der Pole: 14

[Andreas B. (bitverdreher)]

So wie ich das sehe, verwendest Du simple Zählervariablen als Timer.
So geht das nicht. Dann sind die Zeiten abhängig vom Programablauf.
Lies Dir mal an, wie man Timer verwendet.
Aber um auf Deine ursprüngliche Frage zurückzukommen: Es kommt auch auf 
die Drehzahl an, die Du erreichen willst. (bzw.der Takt der max. am 
Motor anliegt.) Die konsequente Verwendung von 64 Bit Arithmetik íst 
auch nicht gerade der Geschwindigkeit dienlich. Da solltest Du mal etwas 
mehr Hirnschmalz investieren.
Ich behaupte mal, ordentlich programmiert, reicht 1MHz dicke aus.

Gruß
Andreas

Edit: OK, Motordaten hast Du nachgeliefert. D.h. Du hast einen Takt von 
14x9600/60 = 2123 Hz. Bei 1Mhz hast Du also ca. 470 Prozessor Takte pro 
Motortakt. Mit 64 Bit Arithmetik kannst Du das vergessen.

[Alex H. (sherlock)]

Oh man dann muss ich da wohl nochmal ran...

Danke an alle!

[Andreas B. (bitverdreher)]

Noch ein Tip:
Die Bitfolge der anzusteuernden Pins in ein 8-bit Array abspeichern und 
dann den kompletten Port in einem Rutsch mit dem indizierten Element 
beschreiben. Das braucht man nicht zur Laufzeit zusammenzubasteln.

Gruß
Andreas

[Amateur (Gast)]

In der 4-er Version des Studios konnte man, wenn man sich im Debugger 
die Register angeschaut, feststellen wie viele Taktzyklen eine markierte 
Sequenz benötigt. Also Run von Markierung bis Markierung (Break-Point) 
und Cycle Counter vorher und nachher ablesen.

[Peter D. (peda)]

Alex H. schrieb:
> signed long long  TSEC_ber

Damit versetzt Du dem AVR den Todesstoß.
Es geht schon damit los, daß ihm die Register ausgehen und er 
8Byte-Werte ständig ins RAM und zurück schaufeln muß.

Und die 7kB Code lassen vermuten, Du nimmst noch nen älteren AVR-GCC 
(<4.7), da sind 64Bit so richtig langsam.

[Max D. (max_d)]

Ich würde mir vlt. den Code bestehender AVR-BLDC Projekte nehmen und 
entweder neu formulieren (falls du wegen Copyright nicht kopieren 
kannst) oder einfach die Teile rumschrauben die für dein Projekt anders 
müssen. Ich hatte jetzt nich den Nerv die 3-4 Seiten Code zu 
analysieren, aber das sieht nach einer Drehzahlregelung für den Motor 
aus (wieso du aber etwas an den Winkeln der Kommutierung verändern 
willst versteh ich nicht ganz, das verschwendet nur Leistung. 
Normalerweise nimmt man immer den Winkel mit der höchsten Kraft und 
schaltet dann "an der Spitze" die Power länger oder kürzer durch, 
dadurch kriegst du die besten Nm für dein Ampere.)

[m.n. (Gast)]

Alex H. schrieb:
> #define F_CPU           1000000UL //1MHZ

Solange Dein µC mit angezogener Handbremse fährt, ist Deine Frage 
sinnfrei.
Bei einem ATmega32 sollten da 16MHz und einem ATmega324 (o.ä.) 20MHz 
stehen. Erst wenn das nicht reicht, hast Du ein Problem mit der 
Ausführungsgeschwindigkeit.

[Falk B. (falk)]

@ Alex H. (sherlock)

>Ich hoffe ihr steigt da durch, und habt nicht allzuviel zu meckern :D

Doch. Lange Quelltexte gehören in den Anhang, siehe Netiquette.

>Achja der Motor ist ein Graupner Compact 260 8.4V

>Er macht 9100 U/min
>Anzahl der Pole: 14

Schön. Daraus kann man zumindest überschlägig was abschätzen. 9100U/Min 
= 152 U/s = 151 Hz. Ein normaler BLDC braucht bei Blockkommutierung 6 
Schritte/U, macht also ~1kHz. Das ist für einen heutigen Mikrocontroller 
laaanngsaaam. Selbst 10kHz sind bei halbwegs gescheiter Programmierung 
nicht allzu schnell, das sind immerhin 100us bzw. 2000 Takte bei 20MHz. 
Damit kann man SEHR viel anstellen, auch in C.

Achja, deine Quelltextformatierung ist verbesserungsfähig.

Strukturierte Programmierung auf Mikrocontrollern

[Wolfgang (Gast)]

Alex H. schrieb:
> Ich hoffe ihr steigt da durch, und habt nicht allzuviel zu meckern :D

Doch, was soll das endlose Listing im Thread. Was meinst du, wofür es 
die Funktion "Dateianhang" gibt?

[Mark B. (markbrandis)]

Frank M. schrieb:
> Stefan P. schrieb:
>> Setz im Programm an den Stellen wo nichts getan wird ein Pin auf High
>> und schau Dir das Puls/Pausen-Verhälntnis auf einem Oszi an. Damit
>> kannst Du deine µC-Load von 0..100% ausrechnen.
>
> Ich glaube, er will nicht die CPU-Last wissen, sondern wieviel Zeit
> bestimmte Teile seines Programms benötigen.

Auch das kann man mit der "Pin-High-Pin-Low-und-auf-Oszi-anschauen 
Methode" ermitteln.

[Peter D. (peda)]

Mark Brandis schrieb:
> Auch das kann man mit der "Pin-High-Pin-Low-und-auf-Oszi-anschauen
> Methode" ermitteln.

Man könnte es aber auch ganz profan im Simulator laufen lassen und sich 
wahlweise die Zyklen oder µs zwischen 2 Breakpoints anzeigen lassen.

[MaWin (Gast)]

> Ich konnte den Code noch nicht Testen

Grausamer Code.

Wenn er nicht schnell genau sein sollte, besteht massiv 
Optimierungspotential.

Und er ist nicht schnell genug, das sehe ich so schon:

Zu geringer CPU Takt

Zu grosse Variablenwerte (64 bit)

Zu viele if if if Vergleichsketten obwohl bei einer
Verzweigung ja schon klar ist daß die folgenden nie
dran kommen können (else) und immer wieder dasselbe
geprüft wird.

Und: Wie viele Instanzen von der Klasse sollen denn
gleichzeitig laufen ? Bei nur einem Motor machen
mehrere Instanzen keinen Sinn und damit die Klasse
an sich keinen Sinn.

Und ob das ganze jetzt überhaupt geeignet ist, einen
BLDC Motor zu bedienen, überblicke ich nicht, mir
fehlt der richtige Takt.

[Mark B. (markbrandis)]

MaWin schrieb:
>> Ich konnte den Code noch nicht Testen
>
> Grausamer Code.
>
> Wenn er nicht schnell genau sein sollte, besteht massiv
> Optimierungspotential.

Ich persönlich würde zuerst mal die logischen Fehler beseitigen. Wenn 
der Code korrekt funktioniert im Sinne von: "Das richtige Ergebnis kommt 
heraus", dann würde ich anfangen zu optimieren.

Korrektes Funktionieren im Sinne eines "Unit Tests" muss man im übrigen 
(zunächst) nicht unbedingt auf der Zielplattform prüfen. Das kann man 
auch auf dem PC machen.

Jedenfalls, hier ist z.B. ein logischer Fehler:

uint16_t Treiber::Anlauf(uint16_t drehzahl_soll )
{
  uint16_t drehzahl_ist;

  
  if (drehzahl_ist<drehzahl_soll  )
  {
    drehzahl_ist += 1;
  }

drehzahl_ist ist eine lokale Variable, die auf dem Stack liegt, und 
somit nicht initialisiert. In der bedingten Verzweigung wird sie mit 
einer anderen Variablen verglichen. Wie soll da etwas Vernünftiges bei 
herauskommen?

Ach ja und die gleiche Methode:
uint16_t Treiber::Anlauf(uint16_t drehzahl_soll )
findet sich sowohl in der Datei work.cpp als auch in der Datei 
BLDC_Driver.cpp. Das geht doch so niemals durch Compiler und Linker.

Poste hier mal richtigen Code, als Dateianhang. Dann kann man anfangen 
übers Optimieren nachzudenken.

[Mark B. (markbrandis)]

MaWin schrieb:
> Und: Wie viele Instanzen von der Klasse sollen denn
> gleichzeitig laufen ? Bei nur einem Motor machen
> mehrere Instanzen keinen Sinn und damit die Klasse
> an sich keinen Sinn.

Das kann man so pauschal nicht sagen. Vielleicht hat man im aktuellen 
Projekt tatsächlich nur einen Motor anzusteuern, plant aber schon die 
Erweiterung auf mehrere Motoren. Dann spricht auch nichts dagegen, den 
Code gleich so zu schreiben, dass er in Zukunft leichter erweiterbar 
ist.

Andererseits hab ich nicht den Eindruck, dass der Themenersteller schon 
soweit ist, dass dies sein größtes Problem wäre ;-)

[Walter (Gast)]

Alex H. schrieb:

zum Code haben ja schon bemerkt das er noch großes 
Verbesserungspotenzial besitzt, hier noch ein Anfängerfehler
>   changeTime = 1/(drehzahl_ist/60)*1000000;

das ist meist gleichbedeutend mit
changeTime = 0;

[Alex H. (sherlock)]

changeTime = 1/(drehzahl_ist(500U/min)/60)*1000000;
changeTime = 120000

warum ist das gleichbeduetent mit changeTime = 0?

[Mark B. (markbrandis)]

1 als ganze Zahl geteilt durch eine (meist) viel größere ganze Zahl 
ergibt in Ganzzahlarithmetik nun einmal Null.

[Rolf Magnus (Gast)]

Mark Brandis schrieb:
> 1 als ganze Zahl geteilt durch eine (meist) viel größere ganze Zahl
> ergibt in Ganzzahlarithmetik nun einmal Null.

Ob nun viel größer oder nicht ist egal. Wenn die Zahl betragsmäßig 
größer ist (also bei allem außer -1, 0 und 1), kommt 0 raus.

Alex H. schrieb:
> changeTime = 1/(drehzahl_ist(500U/min)/60)*1000000;
> changeTime = 120000
>
> warum ist das gleichbeduetent mit changeTime = 0?

In Ganzzahlarithmetik:

500/60 = 8
1/8 = 0
0 * 1000000 = 0