Das erste Symbol benutzt man, um den Start einer Funktion
darzustellen. Hier wird die Main-Funktion gestartet.
Um ein Unterprogramm dazustellen, benutzt man die drei-geteilten Rechtecke. im ersten Unterprogramm wird die Initialisierung gestartet.

Dann wird in einem weitern Unterprogramm die FrontLED gestartet.

Die "normalen" Rechtecke beschreiben jeweils eine Anweisung (bzw. einen Befehl), z. B. der Zähler wird auf "0" gesetzt.

Mit der Raute beschreibt man eine Bedingung, die erfüllt sein
muss, um den folgenden Befehl auszuführen. Hier fragt man,
ob der Zähler den Wert < 10 erreicht hat.

Wenn die Bedingung nicht erfüllt ist, soll der Wert um 1 erhöht werden und dann nochmals auf Wahrheit geprüft werden.

Wenn die Bedingung erfüllt ist, dann schaltet sich die FrontLED aus.

Nun wird in einem weitern Unterprogramm der Zähler wieder auf "0" gesetzt.

Nun muss wieder eine Bedingung erfüllt werden.
Hier fragt man, ob der Zähler den Wert < 20 erreicht hat.

Wenn die Bedingung nicht erfüllt ist, soll der Wert um 1 erhöht werden und dann nochmals auf Wahrheit geprüft werden.

Wenn die Bedingung wahr ist wird die Schleife neu gestartet, indem die

 
 #include <asuro.h>                                     // asuro.h einbinden, Header-bzw.
                                                        // Bibliotheksdatei
 int main ( void )       
 {

     Init ();                                           // Funktionen definieren
    
     int zaehler;                                       // int ist Datentyp Integer
                                                        // ganze Zahlen von -32768 bis +32767
     while( 1 )                                         // => 2 Byte = 16 Bit
     {
         FrontLED ( ON );

         for ( zaehler=0 ; zaehler<=10 ; zaehler++ )     // for-Schleife 10 mal durchlaufen
         {                  
             Sleep ( 225 );                              // ~ 3 ms durch Sleep-Funktion
         }                                               // ergibt 3 ms x 10 = 0,030 s

                                                         // oder erledigt das die folgende
         FrontLED ( OFF );                               // for-Schleife nicht so wie so?

         for ( zaehler=0 ; zaehler<=20 ; zaehler++ )     // for-Schleife 20 mal durchlaufen
         {
             Sleep ( 225 );                              // ~ 3 ms durch Sleep-Funktion
         }                                               // ergibt 3 ms x 20 = 0,060 s

         FrontLED ( ON );

         for ( zaehler=0 ; zaehler<=10 ; zaehler++ )     // for-Schleife 10 mal durchlaufen
         {
             Sleep ( 225 );                              // ~ 3 ms durch Sleep-Funktion
         }                                               // ergibt 3 ms x 10 = 0,030 s

         FrontLED ( OFF );

         for ( zaehler=0 ; zaehler<=500 ; zaehler++ )    // for-Schleife 500 mal durchlaufen
         {
             Sleep ( 225 );                              // ~ 3 ms durch Sleep-Funktion
         }                                               // ergibt 3 ms x 500 = 1,5 s


     }  

     return 0;                                          // Der Rückgabewert der
                                                        // main-Funktion mit dem
 }                                                      // Datentyp int gibt 0 zurück

 

Programmablaufplan als Dateityp *.dia

und hier die Software, um den Programmablaufplan zu bearbeiten:
Dia für Windows

                                                                                                 
 

  #include <avr/io.h>                 // io.h einbinden, Header-bzw. Bibliotheksdatei
 
 int main ( void )                   // jedes C-Programm hat eine main-Funktion
 {                                   // beim Aufrufen der main-Funktion wird nichts
                                     // (engl. void) übergeben
 
   DDRD  = 0b01000000;               // Daten-Richtung einstellen, Bit 6  auf 1 (Ausgang)
   PORTD = 0b00000000;               // Port ausschalten, Port D6
                                     // Zählung von rechts beginnend mit Bit 0

   long zaehler;                     // long ist Datentyp long (dt. lang)    
                                     // ganze Zahlen von -??? bis +???
                                     // => 8 Byte = 64 Bit
     while ( 1 )
     {
         PORTD = 0b01000000;                             // FrontLED EIN, 1. Blitzen

         for ( zaehler=0 ; zaehler<=6977 ; zaehler++ )   // for-Schleife 6977 mal durchlaufen
         {                                               // ein Schleifendurchlauf 4,38 µs
              asm volatile ( "nop":: ) ;                 // "tue nichts", no Operation
         }                                               // ergibt 4,38 µs x 6977 = 0,030 s
                            
         PORTD = 0b00000000;                             // FrontLED AUS, kurze Pause

         for ( zaehler=0 ; zaehler<=13954 ; zaehler++ )  // for-Schleife 13954 mal durchlaufen
         {                                               // ein Schleifendurchlauf 4,38 µs
              asm volatile ( "nop":: ) ;                 // "tue nichts", no Operation
         }                                               // ergibt 4,38 µs x 13954 = 0,060 s

         PORTD = 0b01000000;                             // FrontLED EIN, 2. Blitzen

         for ( zaehler=0 ; zaehler<=6977 ; zaehler++ )   // for-Schleife 6977 mal durchlaufen
         {                                               // ein Schleifendurchlauf 4,38 µs
              asm volatile ( "nop":: ) ;                 // "tue nichts", no Operation
         }                                               // ergibt 4,38 µs x 6977 = 0,030 s


         PORTD = 0b00000000;                             // FrontLED AUS, lange Pause

         for ( zaehler=0 ; zaehler<=348837 ; zaehler++ ) // for-Schleife 348837 mal durchlaufen
         {                                               // ein Schleifendurchlauf 4,38 µs
              asm volatile ( "nop":: ) ;                 // "tue nichts", no Operation
         }                                               // ergibt 4,38 µs x 348837 = 1,5 s


     }                                                   // an den Anfang von while(1)zurück

    
     return 0;               
 }                 


 

Informationen zum Thema