////////////////////////////////////////////////////////////////////////////////
// Ein Schrittmotor wird fortlaufend beschleunigt und abgebremst. 
// Es wird eine Anzahl von Schritten vorgefahren und sofort zurueck.
// Danach bleibt der SM fuer ca. 1,5 Sekunde stehen und das Spiel wiederholt sich.
// Im FastPWM-Mode 15 wird eine maximale Frequenz von ca. x kHz erreicht.
//
//#include "Define.h"
#define SM_RICHTUNG_DDR    DDRK
#define SM_RICHTUNG_PORT  PORTK
#define SM_RICHTUNG_PIN    PINK
#define SM_RICHTUNG     ( 1<<PK0 ) // 62
#define SM_DREHEN_STOP  ( 1<<PK1 ) // Schrittmotor Drehen stoppen 


#define SM_SPEED_RANGE      5000    // Drehzahlbereich  bzw. Frequenz
#define SM_SPEED_MAX         271    // Hoechst Drehzahl bzw. Frequenz
#define SM_SPEED_MIN        SM_SPEED_MAX + SM_SPEED_RANGE 

#define SM_SCHRITTANZAHL   SM_SPEED_MIN * 2     // Schrittmotor Verfahrweg
#define SM_PAUSE           1500    // In Millisekunden 


#define SM1_DDR            DDRE
#define SM1_PIN            PINE
#define SM1_PORT          PORTE
#define SM1_TAKT        ( 1<<PE3 ) //5  //( 1<<PE3 )  // OC3A-Pin


//#include "Variablen.h"
volatile  int32_t stepCount;      // Anzahl der Schrittmotorschritte 

          uint8_t  errorZaehler = 1;
          
// Mit hoechsten Wert beginnen, also langsamste Geschwindigkeit
volatile int16_t  rampeArrayZeiger = SM_SPEED_MIN;  // 

////////////////////////////////////////////////////////////////////////////////
// Vorwaertsdeklarationen
//
void    timer3_init( void );
////////////////////////////////////////////////////////////////////////////////
// SETUP
// 
void setup() 
{
  Serial.begin( 9600 );
  
  DDRK   |=  1<< PK0 | 1<< PK1;  // Freigabe und Richtung
  PORTK  &= ~SM_DREHEN_STOP;     // Freigabe des SM-Treibers

  SM_RICHTUNG_DDR   = 0x00;              //  Weil Arduino
  SM_RICHTUNG_PORT  = 0x00;              //  Weil Arduino
  SM_RICHTUNG_DDR  |=  SM_RICHTUNG;      // Schrittmotor Richtung Ausgang
  SM_RICHTUNG_DDR  |=  SM_DREHEN_STOP;   // Schrittmotor Drehen stoppen als Ausgang
  SM_RICHTUNG_PORT |=  SM_RICHTUNG;      // Startrichtung vorgeben

  SM1_DDR  |=  SM1_TAKT;         // PE3 bzw. OC3A als normaler Ausgang
  SM1_PORT &= ~SM1_TAKT;         // Zunaechst Low-Pegel
  
  timer3_init();  // FastPWM-Mode 15

  stepCount = SM_SCHRITTANZAHL;
  
  sei( );         // Globale Freigabe von Interrupts
 
} // Ende void setup()

void loop()
{
  //----------------------------------------------------------------------------
  // 
  // void loop()
  //
  //----------------------------------------------------------------------------
  int32_t tmp;
  
  cli();
  tmp = stepCount;    // Ein verfaelschen durch ISR verhindern
  sei();
  
  if( tmp == 0 ) {
    TIMSK3 &=  ~1<< OCIE3A;     // Output Compare Interrupt sperren    
    
    // Nur jedes 2te mal eine Pause einlegen 
    if( !( SM_RICHTUNG_PORT & SM_RICHTUNG ))  {
          
///*                        
Serial.print  ( errorZaehler );
Serial.print  ( " PAUSE" );  
Serial.print  ( "\t" );         // Neu  
Serial.print  ( "stepCount" );  // Neu
Serial.print  (  stepCount  );  // Neu  
Serial.println( ); 
//*/    
        errorZaehler ++;
        
        delay( SM_PAUSE );
     }
        
        stepCount = SM_SCHRITTANZAHL;  // Variable wird in ISR runtergezaehlt
        // Sofortigen Interrupt verhindern
        TCNT3   =  0;             // Timer ruecksetzen
        TIFR3   =  1<< OCF3A;     // Output Compare Interrupt Flag loeschen
        TIMSK3 |=  1<< OCIE3A;    // Output Compare Interrupt freigeben    
  }
} // Ende void loop() 

//#include "ISR.h";             // Interrupt Service Routinen
ISR( TIMER3_COMPA_vect ) 
{ 
  //-------------------------------------------------------------------------------
  //
  // FastPWM-MODE 15 Normaler Ausgang
  // Kurve abfahren, Schrittmotorschritte runterzaehlen und
  // Schrittimpuls erzeugen.
  //
  //-------------------------------------------------------------------------------
  ///////////////////////////////////////////////////////////////////////////////
  // Hin und her fahren und am Startpunkt wird eine kurze Pause einlegt
  //
  if( stepCount != 0 )  {  
    OCR3A = rampeArrayZeiger; // Per FPWM-Kurve -> fclk_io / N*(1+TOP)
    SM1_PORT &= ~SM1_TAKT;    // Schrittimpuls vorbereiten
    
    // Geschwindigkeit verlangsamen und begrenzen
    if( !( SM_RICHTUNG_PORT &  SM_RICHTUNG )) {
      rampeArrayZeiger ++;

      if( rampeArrayZeiger > SM_SPEED_MIN ) rampeArrayZeiger = SM_SPEED_MIN;
    }     
   
    // Geschwindigkeit erhoehen und begrenzen
    else rampeArrayZeiger --;
     
    if( rampeArrayZeiger < SM_SPEED_MAX ) rampeArrayZeiger = SM_SPEED_MAX;

    stepCount --;             // Schrittmotor Schrittanzahl runterzaehlen

    // Nur jedes 2te mal ist dieses Bit gesetzt bzw. geloescht
    if( stepCount == 0 ) {
      SM_RICHTUNG_PORT ^=  SM_RICHTUNG;  // Schrittmotordrehrichtung aendern
///*
Serial.println( );  
Serial.print  ( "stepCount = " );  
Serial.println(  stepCount     );  
//*/  
    }
   
    SM1_PORT  |=  SM1_TAKT; // Schrittimpuls vollenden
  }
} // Ende ISR( TIMER3_COMPA_vect )

//#include "Ini.h";             // Initialsierungsfunktionen
////////////////////////////////////////////////////////////////////////////////
// FastPWM-Mode 15 OCR3A ist TOP. Normaler Ausgang
//
void timer3_init( void ) 
{
  TCCR3A = 0; // Weil Arduino
  TCCR3B = 0; //
  TCCR3C = 0; //
 
  OCR3A   =  SM_SPEED_MIN;  // Niedrige Frequenz
  TCCR3A |=  0b11<< WGM30;  // Fast PWM Mode 15 Low  Bits
  TCCR3B |=  0b11<< WGM32;  // Fast PWM Mode 15 High Bits
  // Sofortige Interrupt verhindern
  TCNT3   =  0;             // Timer ruecksetzen
  TIFR3   =  1<< OCF3A;     // Output Compare Interrupt Flag loeschen
  TIMSK3 |=  1<< OCIE3A;    // Output Compare Interrupt freigeben  
  TCCR3B |=  0b001<< CS30;  // Vorteiler = 1 und Timer3 starten
}       
     
//#include "Unterprogramme.h";  //