main.c

#include "msp430f5529.h"            // Einbinden der Definitionen

#define  T_OnOff   0x02     // Taster an P1.1

#define  T_Step    0x02     // Taster an P2.1, Veränderung Pulsbreite bzw. Frequenz

#define  LED_On    0x80     // LED 2 an P4.7

#define  LED_WG    0x10     // Signal sowohl an LED als auch am Pin 7.4

#define  N_Blinken 3 * 2    // 3x ON 3x OFF ....

#define  N_2Hz     5        // 5x wait_0s1 = 0,5s ==> 2Hz

// __________ Prototypen der verwenndeten Funktionen _________________

//Alle Funktionen, welche im Programm verwendet werden

//sind dem Compiler bekann zu machen.

void Entprell(void);      // Entprellen der Taster

void Ports (void);         // Initialisierung der Ports

void TimerA1 (void);       // Init des Timers A1

void TimerB0 (void);

void INIT_TA2(void);

void INIT_TA0(void);

void Ausgabe_Pulsbreite (unsigned int Zahl);

void Ausgabe_Frequenz (unsigned int Zahl);

void Ausgabe_Fvorgegeben (unsigned int Zahl);

void Ausgabe_Pvorgegeben (unsigned int Zahl);

//void Ausgabe_Modus (unsigned int Zahl);

//void Pulswobbel (void);

//void Frequenzwobbel (void);

void Modiwechsel (void);

void System_Start(void);

void System_Stop(void);

void System_Err(void);

void ZahlToEinerZehner(unsigned int);

void ZahlToString(unsigned int);

extern void INIT_UART1(void);

extern void TX_String(unsigned char *cx);

extern void TX_BYTE(unsigned char xc);

// ___________  Globale Variablen ______________________________________

unsigned int ZustandProg = 0;  // Zustans-Merker des Programms

                               // 0 : deaktiv

                               // 1 : im Hochlauf

                               // 2 : aktiv

                               // 3 : im Runterlauf

unsigned int Counter = 0;      // Zähler mit Startwert = 0 (0...65535)

unsigned int tx = 0;           // Aktions-Merker für Timer

unsigned int Frequenz = 20960;        // 50 Hz, 0,02 -> (1,048 MHZ/ 50 HZ)

unsigned int Periodendauer = 20960;

unsigned int Frequenz_Ak = 50;

unsigned int Frequenz_Step = 10;   // Schrittweite 10 Prozent von Frequenz

unsigned int Frequenz_Min = 10;       // Maximale Frequenz von 100 HZ

unsigned int Frequenz_Max = 90;       // Minimale Frequenz von 10 HZ

unsigned int Pulsbreite_Ak = 50;

unsigned int Pulsbreite_Step = 10;

unsigned int Pulsbreite_Min = 10;

unsigned int Pulsbreite_Max = 90; 

unsigned int PWM_Min = 5;               // Parameter für Pulswobbel

unsigned int PWM_Max = 95;

unsigned int PWM_Aktuell = 5;

unsigned int PWM_Step = 5;

unsigned int FRQ_Min = 5;               // Parameter für Frequenzwobbel

unsigned int FRQ_Max = 95;

unsigned int FRQ_Aktuell = 5;

unsigned int FRQ_Step = 5;

unsigned int PWM_Step_Dir = 1;       // Schrittrichtung

                                     // 0 : Rückwärts

                                     // 1 : Vorwärts

unsigned int FRQ_Step_Dir = 1;       // Schrittrichtung 

                                     // 0 : Rückwärts

                                     // 1 : Vorwärts

unsigned int FRQ_Dir = 1;            // Wobbelrichtung 

                                     // 0: Rückwärts (d.h. von FRQ_Max

                                     //                      zu FRQ_Min); 

                                     // 1: Vorwärts

unsigned int PWM_Dir = 1;

unsigned int Zahl = 0;

unsigned int Einer = 0;

unsigned int Zehner = 0;

unsigned int Modus = 0;  // Wahl zwischen Frequenzwobbel und Pulswobbel 

                         // 0: Kein Wobbel aktiv

                         // 1: Pulswobbel aktiv

                         // 2: Frequenzwobbel aktiv

// __________ HAUPT-PROGRAMM __________________________

int main( void )

{

  WDTCTL = WDTPW + WDTHOLD;  // WatchDogTimer abschalten

  INIT_UART1();

  Ports ();

  ZustandProg = 0; 

  tx = 0;

  TX_String("    >>>>>> System neu aktiviert <<<<<<<<\n\n");

  TX_String("\n   Start mit T_OnOff\n\n");

   _BIS_SR(GIE);

  while(1)

   {

      _NOP();  // tue nichts

      if(tx == 1)   // wird durch dem TimerA1 Interrupt gesetzt

      {  

         switch(ZustandProg)

         {

            case 1:  // wenn von AUS --> EIN

                   System_Start();

                   Modus = 1;

                   tx = 0;

                   break;  

            case 2:  // in Betrieb  ==> EIN

                   _NOP();

                   _NOP();

                   tx = 0;

                   break;

           case 3:  // wenn von EIN --> AUS

                   System_Stop();

                   Modus = 0;

                   tx = 0;

                   break;     

           default:

                   // dieser Zustand dürfte normalerweise nie auftreten, wenn

                   // doch, dann liegt wohl ein Fehler vor. In diesem Fall:

                   System_Err();

                   Modus = 0;

                   tx = 0;

                   break;

         }

      }

      _NOP();

      _NOP();

   } 

}

// __________ Funktionen __________________________

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Funktion: PORTS()

// +     Stand .....: 31.12.2019  / JP

// +

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void Ports(void)

{

 // Port 1

 P1SEL &= ~ T_OnOff;

 P1DIR &= ~ T_OnOff;

 P1REN |=  T_OnOff;

 P1OUT |= T_OnOff;

 P1IES &= ~ T_OnOff;

 P1IE  |= T_OnOff;

 P1IFG &= ~ T_OnOff;

 // Port 2

 P2SEL &= ~ T_Step;  

 P2DIR &= ~ T_Step;

 P2REN |= T_Step;

 P2OUT |= T_Step;

 P2IES |= T_Step;

 P2IE &=~ T_Step;

 P2IFG &=~ T_Step;

 // Port 4

 P4SEL  &= ~(LED_On);         

 P4DIR  |= LED_On;             

 P4OUT  &= ~(LED_On);

}

// +----------------------------------------------------------------------

// |  SubRoutine zum Entprellen eines Tastes 

// |     08.12.2019 /JP

// +----------------------------------------------------------------------

void Entprell(void)     // Künstliche Programmpause

{

  unsigned int k = 0x0FFF;

  while(k > 0) k--;

}

// +----------------------------------------------------------------------

// |  SubRoutinen zur Ausgabe einer Zahl im ZehnerEiner-Format

// |    

// +----------------------------------------------------------------------

//Für Pulswobbel

void Ausgabe_Pulsbreite(unsigned int Zahl)

{

  Zehner = 0;

  Einer = Zahl;

  while(Einer > 9)

  {

    Zehner++;

    Einer = Einer - 10;

  }

  TX_String("Aktuelle Pulsbreite = ");

  ZahlToString(Zehner);

  ZahlToString(Einer);

  TX_String("%\n");

}

// Für Frequenzwobbel

void Ausgabe_Frequenz(unsigned int Zahl)

{

  Zehner = 0;

  Einer = Zahl;

  while(Einer > 9)

  {

    Zehner++;

    Einer = Einer - 10;

  }

  TX_String("Aktuelle Frequenz = ");

  ZahlToString(Zehner);

  ZahlToString(Einer);

  TX_String("%\n");

}

// Für Ausgabe der aktuell eingestellten Periodendauer in Prozent

void Ausgabe_Pvorgegeben(unsigned int Zahl)

{

  Zehner = 0;

  Einer = Zahl;

  while(Einer > 9)

  {

    Zehner++;

    Einer = Einer - 10;

  }

  TX_String("Aktuell eingestellte Pulsbreite = ");

  ZahlToString(Zehner);

  ZahlToString(Einer);

  TX_String("%\n");

}

// Für Ausgabe der aktuell eingestellten Frequenz in Prozent

void Ausgabe_Fvorgegeben(unsigned int Zahl)

{

  Zehner = 0;

  Einer = Zahl;

  while(Einer > 9)

  {

    Zehner++;

    Einer = Einer - 10;

  }

  TX_String("Aktuell eingestellte Frequenz= ");

  ZahlToString(Zehner);

  ZahlToString(Einer);

  TX_String("%\n");

}

void ZahlToString(unsigned int Zahl)

{

  if(Zahl == 0) { TX_String("0"); }

  else if(Zahl == 1) { TX_String("1"); }

  else if(Zahl == 2) { TX_String("2"); }

  else if(Zahl == 3) { TX_String("3"); }

  else if(Zahl == 4) { TX_String("4"); }

  else if(Zahl == 5) { TX_String("5"); }

  else if(Zahl == 6) { TX_String("6"); }

  else if(Zahl == 7) { TX_String("7"); }

  else if(Zahl == 8) { TX_String("8"); }

  else if(Zahl == 9) { TX_String("9"); }

}

// +----------------------------------------------------------------------

// |  SubRoutine zum Initialisiern und starten des Timers A1 Frequenzwobbel

// |     01.01.2019 / JP

// +----------------------------------------------------------------------            

void TimerA1 (void)

{

  TA1CTL = TACLR;       // Timer-Counter RESET auf Null

  TA1CCR0 = (int) ((float) (FRQ_Aktuell) / 100 *(float)(Periodendauer));

  TA1CCTL0 = OUTMOD_7;       // Interrupt bei TA1CCR0

  TA1CCR1 = Periodendauer; 

  TA1CTL = TASSEL_2;      // Taktquelle SMCLK; 1,048 MHz kHz

  TA1CTL = ID_0;         // Teiler 1

  TA1CTL = MC_1;         // UP-Modus gewählt    

}

// +----------------------------------------------------------------------

// |  SubRoutine zum Initialisiern und starten des Timers B0 Pulswobbel

// |     01.01.2019 / JP

// +----------------------------------------------------------------------  

void TimerB0 (void)

{

  TB0CTL = TBCLR; 

  TB0CCR0 = Frequenz; 

  TB0CCTL2 = OUTMOD_7; 

  TB0CCR2 = (int)((float)(PWM_Aktuell) / 100 * (float)(Frequenz));

  TB0CTL = TBSSEL_2 + MC_1 + ID_0;   // SMCLK, 1:1, UP-Mode

}

// +----------------------------------------------------------------------

// |  SubRoutine zum Initialisiern und starten des Timers

// |     

// +----------------------------------------------------------------------

void INIT_TA2(void)

{

  TA2CTL = TACLR;   // Timer-Counter RESET auf Null

  TA2CCR0 = 16384;  // für 0,5s bei ACLKK, 1:1 und UP-Mode

  TA2CCTL0 = CCIE;  // Interrupt wenn Timer-Counter == TA1CCR0

  TA2CTL = TASSEL_1 + ID_0 + MC_1;

}

// +----------------------------------------------------------------------

// |  SubRoutine zum Initialisiern und starten des Timers

// |     

// +----------------------------------------------------------------------

void INIT_TA0(void)

{

  TA0CTL = TACLR;                               // Timer-Counter RESET auf Null

  TA0CCR0 = 65535;                              // 2s

  TA0CCTL0 = CCIE;                              // Interrupt bei TA2CCR0

  TA0CTL = TASSEL_1 + ID_0 + MC_1;              // ACLKK, 1:1, UP-Mode

}

  // +----------------------------------------------------------------------

// |  SubRoutine beim System aktivieren von Zustand AUS --> EIN

// |     05.01.2020/ JP

// +----------------------------------------------------------------------

void System_Start(void)

{

   if(P4OUT & LED_On)   // wenn LED_ON = EIN

   {

     P4OUT &= ~(LED_On);

     TX_BYTE('o');

   }

   else

   {

     P4OUT |= LED_On;

   }

   Counter++;   // Erhöhe Blink-Zähler um 1

   if(Counter  >= N_Blinken)

   {

     ZustandProg = 2;     // Zustand: EIN

     TA2CTL = 0x00;       // Timer für Start / Stop = AUS

     tx = 1;              // weil über den Timer nicht mehr gesetzt wird

     P7SEL |= LED_WG;   // LED_WG = Spez. Out 

     P7DIR |= LED_WG;   // LED_WG auf Timer TB0

     // Hier Grundeinstellung auf Pulswobbel

     TimerB0();              // START Timer Pulswobbel

     Modus = 1;              // Modus Pulswobbel

     PWM_Dir = 1,            // Pulsbreite wird größer 

     P2IFG &= ~(T_Step);

     P2IE |= T_Step;       // Freigebe Taster für Interrupt

     P4OUT |= LED_On;     // LED_ON sicher auf EIN setzen

     TX_String("\n\nSystem aktiviert\n\n");

     Ausgabe_Pulsbreite(PWM_Aktuell);

     if(PWM_Step_Dir == 0)

     {TX_String("T_Step : +5%\n\n");}

     else

     {TX_String("T_Step : +5%\n\n");}

   }  

}

// +----------------------------------------------------------------------

// |  SubRoutine beim System deaktivieren von Zustand EIN --> AUS

// |     05.01.2020/ JP

// +----------------------------------------------------------------------

void System_Stop(void)

{

    P7SEL &= ~(LED_WG);            // LED_WG = Spez. Out 

    P7DIR |= LED_WG;            // LED_WG auf Timer TB0  

   if(P4OUT & LED_On)   // wenn LED_On = EIN

   {

     // LED's EIN, dann --> AUS

     P4OUT &= ~(LED_On);

     P7OUT &= ~(LED_WG);

     TX_BYTE('o');

   }

   else

   {

     // LED's AUS, dann --> EIN

     P4OUT |= LED_On;

     P7OUT |= LED_WG;

   }

   Counter++;   // ERhöhe Blink-Zähler um 1

   if( Counter  >= N_Blinken)

   {

      ZustandProg = 0;

      TA2CTL = 0x00;       // // Timer für Start / Stop = AUS

      TX_String("\n\n System = AUS\n");

      TX_String("\nStart mit T_OnOff\n\n");

      if ( Modus == 1)

      {

        TB0CTL = 0x00;          // Timer = AUS

        Modus = 0;

      }            

      else if (Modus ==2 )

      {

        TA1CTL = 0x00;             

        Modus = 0;              // Doppelt? Siehe Main

      }

      //unabhängig vom Modus Reset durchführen

      PWM_Aktuell = 5;       // PWM Reset

      FRQ_Aktuell = 5;

      P2IFG &= ~(T_Step);

      P2IE &= ~(T_Step);    // Freigebe Interrupt sperren Taster T_SET 

      P4OUT &= ~(LED_On);  // LED_ON sicher auf AUS setzen

      P7OUT &= ~(LED_WG);   // LED_WG sicher auf AUS setzen

   }

}

// +----------------------------------------------------------------------

// |  SubRoutine wenn ein falscher Zustand aktiv sein sollte, dann

// |          System auf "sofort AUS"

// |     05.01.2020

// +----------------------------------------------------------------------                     

void System_Err(void)

{

   // dieser Zustand dürfte normalerweise nie auftreten, wenn

   // doch, dann liegt wohl ein Fehler vor. In diesem Fall:

   TA2CTL = 0x00;     // Timer = AUS

   tx = 0;

   ZustandProg = 0;

   Modus = 0;

   P2IFG &= ~(T_Step);

   P2IE &= ~(T_Step);    // Freigebe Interrupt sperren Taster T_SET               

   P1IFG &= ~(T_OnOff);

   P4OUT &= ~(LED_On);  // LED_ON sicher auf AUS setzen

   P7OUT &= ~(LED_WG);  // LED_WG sicher auf AUS setzen              

   Counter = 0;    

}

// +----------------------------------------------------------------------

// |  SubRoutine zum Wechsel zwischen den beiden Modi

// |     07.01.2020/ JP

// +----------------------------------------------------------------------

 void Modiwechsel (void)

 {

   // Von Pulswobbel auf Frequenzwobbel

   if ( Modus == 1 && P1IFG & T_OnOff && P2IFG & T_Step)

   {

     TB0CTL = 0x00;  // TimerB0 ausschalten

     Modus = 2;

     TimerA1();      // TimerA1 einschalten

     FRQ_Dir = 1;    // zuerst wird Frequenz vergrößert

   }

   // Von Frequenzwobbel auf Pulswobbel

   else if (Modus == 2 && P1IFG & T_OnOff && P2IFG & T_Step)

   {

     TA1CTL = 0x00;

     Modus = 1;

     TimerB0();

     PWM_Dir = 1;   // Pulsweite wird vergrößert

   }  

   // Flankenereignisse löschen

   P1IFG &=~ T_OnOff;

   P2IFG &=~ T_Step;

 }

//__________ Interrupt-Funktionen __________________________

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Funktion: TimerB0_B1_ISR()

// +     Stand .....: 05.01.2020

// +

// + 

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//void Pulswobbel (void)

#pragma vector = TIMER0_B1_VECTOR

 __interrupt void TIMER0_B1_ISR (void)

{

  switch (TB0IV)

  {

  case TB0IV_TBCCR2:                 // TB0CCR2 

    {

      if (PWM_Aktuell < PWM_Max && PWM_Dir == 1)

     {

       PWM_Aktuell += PWM_Step;

     }

     else if(PWM_Aktuell > PWM_Max && PWM_Dir == 1)

     {

      PWM_Aktuell -= PWM_Step;

      PWM_Dir = 0;

     }

     if (PWM_Aktuell > PWM_Min && PWM_Dir == 0)

     {

       PWM_Aktuell -= PWM_Step;

     }

     else if(PWM_Aktuell < PWM_Min && PWM_Dir == 0)

     {

      PWM_Aktuell += PWM_Step;

      PWM_Dir = 0;

     }

     break;

    }

  }

}

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Funktion: TimerA1_A0_ISR()

// +     Stand .....: 05.01.2020

// +

// +   

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//void Frequenzwobbel (void)

#pragma vector = TIMER1_A0_VECTOR

__interrupt void Timer1_A0_ISR( void )

{

  if (FRQ_Aktuell < FRQ_Max && FRQ_Dir == 1)

  {

    FRQ_Aktuell += FRQ_Step;

  }

  else if(FRQ_Aktuell > FRQ_Max && FRQ_Dir == 1)

  {

   FRQ_Aktuell -= FRQ_Step;

   FRQ_Dir = 0;

  }

  if (FRQ_Aktuell > FRQ_Min && FRQ_Dir == 0)

  {

    FRQ_Aktuell -= FRQ_Step;

  }

  else if(FRQ_Aktuell < FRQ_Min && FRQ_Dir == 0)

  {

   FRQ_Aktuell += FRQ_Step;

   FRQ_Dir = 1;

  }

}

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Funktion: TimerA1_0_ISR()

// +    

// +

// +     Wenn dT erreicht wurde

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

#pragma vector=TIMER2_A0_VECTOR

__interrupt void TA2_0_ISR()

{

  tx = 1;

}

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Funktion: TimerA1_0_ISR()

// +     

// +

// +     Wenn dT erreicht wurde

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

#pragma vector=TIMER0_A0_VECTOR

__interrupt void TA0_0_ISR()

{

  P2IES |= T_Step;      // Zurück auf negative Flanke

  // für Freque

  if ( Modus == 1)

  {

   if(PWM_Step_Dir == 0)

   {

    PWM_Step_Dir = 1;

    TX_String("\nT_SET: +5%\n");

   }

   else

   {

    PWM_Step_Dir = 0;

    TX_String("\nT_SET: -5%\n");

   }

  }

  // für Frequenzwobbel

  else if ( Modus == 2)

  {

    if(FRQ_Step_Dir == 0)

   {

    FRQ_Step_Dir = 1;

    TX_String("\nT_SET: +5%\n");

   }

   else

   {

    FRQ_Step_Dir = 0;

    TX_String("\nT_SET: -5%\n");

   }

  }

  P2IFG &= ~(T_Step); 

}

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Funktion: P1_ISR()

// +     

// +

// +     Abfrage von Taster T_OnOff

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

#pragma vector=PORT1_VECTOR

__interrupt void P1_ISR()

{

  Entprell();

  if (P1IFG & T_OnOff)

  {

  // Negation des Taster T_Step, für Modiwechsel relevant

  if(P1IFG & T_OnOff && !(P2IFG & T_Step))   // Wenn Int. von T_OnOff, dann 

  {

    // hier weiter

    if((ZustandProg == 1)|| (ZustandProg ==2)) // TEST ob Programm bereists aktiv

    {

      // wenn ja, dann EIN --> AUS

      P2IFG &= ~(T_Step);    // Flanken ereignis löschen

      P2IE  &= ~(T_Step);    // Taster T_SET Interrupt sperren

      P7OUT |= LED_WG;

      P4OUT |= LED_On;

        if ( Modus == 1)

      {

        TB0CTL = 0x00;          // Timer = AUS

        Modus = 0;

      }            

      else if (Modus ==2 )

      {

        TA1CTL = 0x00;

        Modus = 0;              

      }

      TX_String("\nSystem wird herunter gefahren\n");

      ZustandProg = 3;

      Counter = 0;      

      tx = 0;  // das statische tx auf aus, übernimmt jetzt der Timer

    }

    else

    {

      // wenn nein, dann AUS --> EIN  (war im Zustand 0 oder 3)

      P2IFG &= ~(T_Step);    // Flanken ereignis löschen

      TX_String("System wird hoch gefahren\n");

      ZustandProg = 1;

      Counter = 0;

      Modus = 1;   // ist doch doppelt? SIEHE MAIN

    }

    INIT_TA2();             // Initialisiuerung und Start des Timers

  }

   void Modiwechsel();

   P1IFG &= ~(T_OnOff);    // Flanken Ereignis löschen

}

}

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Funktion: P2_ISR()

// +     

// +

// +     Abfrage von Taster T_Step

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

#pragma vector=PORT2_VECTOR

__interrupt void P2_ISR()

{

  Entprell();

  if (P2IFG & T_Step)

  {

  // Logisches Nicht des Tasters T_On Off, für Modiwechsel relevant

  if(P2IFG & T_Step && !(P1IFG & T_OnOff) )       // Wenn Int. von T_Step, dann

  {

    if(P2IES && 0x02 == T_Step)   // Wenn T_Step in P1IES == 1 ist, negative Flanke

    {

      INIT_TA0();               // aktiviere 2s-Timer

      P2IES &= ~(T_Step);        // Int. bei positiver Flanke

    }

    else                        

    {

      // kurz gedrückt

      TA0CTL = 0x00;                            // Timer Stopp

      P2IES |= T_Step;                           // Zurück auf negative Flanke

      // für Pulswobbel

      if ( Modus == 1)

      {

        if(PWM_Step_Dir == 1)                     // Vorwärts

       {

        Frequenz_Ak += Frequenz_Step;           

        if (Frequenz_Ak > Frequenz_Max)

        {Frequenz_Ak = Frequenz_Min;}

       }

       else                                      // Rückwärts        

       {

        Frequenz_Ak -= Frequenz_Step;

        if (Frequenz_Ak < Frequenz_Min)

        {Frequenz_Ak = Frequenz_Max;}

       }

       Frequenz =  Frequenz_Ak / 100 * Frequenz;

       TB0CCR0 = Frequenz;

       // Ausgabe für Einstellung der vorgegeben Frequenz in Prozent 

       Ausgabe_Fvorgegeben (Frequenz_Ak);

      }

      // für Frequenzwobbel

      else if ( Modus == 2)

      {

         if(FRQ_Step_Dir == 1)                     // Vorwärts

       {

        Pulsbreite_Ak += Pulsbreite_Step;       

        if (Pulsbreite_Ak > Pulsbreite_Max)

        {Pulsbreite_Ak = Pulsbreite_Min;}

       }

       else                                      // Rückwärts        

       {

        Pulsbreite_Ak -= Pulsbreite_Step;

        if (Pulsbreite_Ak < Pulsbreite_Min)

        {Pulsbreite_Ak = Pulsbreite_Max;}

       }

        Periodendauer = Pulsbreite_Ak / 100 *  Periodendauer;

        TA1CCR1 = Periodendauer; 

       // Ausgabe für Einstellung der vorgegeben periodendauer in Prozent

       Ausgabe_Pvorgegeben(Pulsbreite_Ak);   

      }

    }

  }

       void Modiwechsel ();

     P2IFG &= ~(T_Step);                          // Flanken Ereignis löschen

  }

}