Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen Revision Vorhergehende Überarbeitung
Nächste Überarbeitung 		Vorhergehende Überarbeitung
microcontrollertechnik:5_menuefuehrung [2020/05/14 01:18]
tfischer 		microcontrollertechnik:5_menuefuehrung [2024/03/29 20:24] (aktuell)
mexleadmin
Zeile 1: Zeile 1:
-====== 5. Menüführung ====== +====== 5 Menüführung ======
- +
-<panel type="warning" title="ACHTUNG"> +
-{{fa>spinner?3x&pulse}} (nbsp)(nbsp)(nbsp)(nbsp)Diese Seite ist gerade in Bearbeitung ... +
-</panel>+
  
 ==== Ziele ==== ==== Ziele ====
Zeile 15: Zeile 11:
 --> I. Vorarbeiten # --> I. Vorarbeiten #
   - Laden Sie folgende Datei herunter:    - Laden Sie folgende Datei herunter: 
-    - {{microcontrollertechnik:5_program_menu.simu}} +    - {{microcontrollertechnik:5._menuefuehrung.sim1}} 
-    - {{microcontrollertechnik:5_program_menu.hex}}+    - {{microcontrollertechnik:5._menufuehrung.hex}}
     - {{microcontrollertechnik:lcd_lib_de.h}}     - {{microcontrollertechnik:lcd_lib_de.h}}
  
Zeile 22: Zeile 18:
 --> II. Analyse des fertigen Programms # --> II. Analyse des fertigen Programms #
   - Initialisieren des Programms    - Initialisieren des Programms 
-    - Öffnen Sie SimulIDE und öffnen Sie dort mittels {{microcontrollertechnik:simulide_open.jpg?25}} die Datei ''5_program_menu.simu''  +    - Öffnen Sie SimulIDE und öffnen Sie dort mittels {{microcontrollertechnik:simulide_open.jpg?25}} die Datei ''5._menuefuehrung.sim1''  
-    - Laden Sie ''5_program_menu.hex'' als firmware auf den 328 Chip+    - Laden Sie ''5._menuefuehrung.hex'' als firmware auf den 88 Chip
     - Zunächst wird eine Startanzeige mit dem Namen des Programms dargestellt.     - Zunächst wird eine Startanzeige mit dem Namen des Programms dargestellt.
     - Als nächstes ist im Display ein Menu zu sehen, in dem verschiedene Programme P1 ... P4 durch Tastendruck auswählbar ist. Dadurch sind die bisherigen Programme auswählbar. Im Unterprogramm ermöglicht der Schalter S1 das Zurückspringen ins Menu.     - Als nächstes ist im Display ein Menu zu sehen, in dem verschiedene Programme P1 ... P4 durch Tastendruck auswählbar ist. Dadurch sind die bisherigen Programme auswählbar. Im Unterprogramm ermöglicht der Schalter S1 das Zurückspringen ins Menu.
Zeile 29: Zeile 25:
  
 <-- <--
---> III. Eingabe in Atmel Studio #+--> III. Eingabe in Microchip Studio #
 <WRAP group><WRAP column 40%><sxh c; first-line: 1> <WRAP group><WRAP column 40%><sxh c; first-line: 1>
 /*============================================================================= /*=============================================================================
 +  
 +Experiment 5:   Programm-Menu
 +=============   =============
  
-Experiment 5: Programm-Menu +Dateiname:   Program_Menu.c 
-============= ============= +  
- +
-Dateiname: Program_Menu.c +
 Autoren: Peter Blinzinger Autoren: Peter Blinzinger
  Prof. G. Gruhler (Hochschule Heilbronn)  Prof. G. Gruhler (Hochschule Heilbronn)
- D. Chilachava  (Georgische Technische Universitaet) + D. Chilachava (Georgische Technische Universitaet) 
 +  
 Version: 1.2 vom 29.04.2020 Version: 1.2 vom 29.04.2020
- +   
-Hardware: MEXLE2020 Ver. 1.0 oder höher+Hardware:    MEXLE2020 Ver. 1.0 oder höher
  AVR-USB-PROGI Ver. 2.0  AVR-USB-PROGI Ver. 2.0
- +   
-Software: Entwicklungsumgebung: AtmelStudio 7.0+Software:    Entwicklungsumgebung: AtmelStudio 7.0
  C-Compiler: AVR/GNU C Compiler 5.4.0  C-Compiler: AVR/GNU C Compiler 5.4.0
- +   
-Funktion: Unter einer gemeinsamen Programmoberflaeche werden vier Teil-+Funktion:    Unter einer gemeinsamen Programmoberflaeche werden vier Teil-
  programme verwaltet. Dies sind:  programme verwaltet. Dies sind:
  P1: Blinking LED  P1: Blinking LED
Zeile 59: Zeile 55:
  tasten. Nach dem Abbruch eines Teilprogramms (immer mit S1)  tasten. Nach dem Abbruch eines Teilprogramms (immer mit S1)
  wird wieder die Programmauswahl gestartet.  wird wieder die Programmauswahl gestartet.
- +   
-Displayanzeige: Start (fuer 2s): Betrieb (Hauptebene): +Displayanzeige: Start (fuer 2s): Betrieb (Hauptebene): 
- +----------------+ +----------------+ + +----------------+   +----------------+ 
- |- Experiment 5 -| |   Main Level   | + |- Experiment 5 -|   |   Main Level   | 
- |  Program Menu  | | P1  P2  P3  P4 | + |  Program Menu  |   | P1  P2  P3  P4 | 
- +----------------+ +----------------+ + +----------------+   +----------------+ 
 +  
  Anzeige fuer Teilprogramme siehe bei einzelnen Programmen  Anzeige fuer Teilprogramme siehe bei einzelnen Programmen
- +   
-Tastenfunktion: Im Hauptprogramm rufen S1 .. S4 die 4 Teiprogramme auf.+Tastenfunktion: Im Hauptprogramm rufen S1 .. S4 die 4 Teiprogramme auf.
  Im Teilprogramm ist die Funktion unterschiedlich (siehe dort)  Im Teilprogramm ist die Funktion unterschiedlich (siehe dort)
- +   
-Jumperstellung: Auswirkung nur im Teilprogramm "Sound": +Jumperstellung: Auswirkung nur im Teilprogramm "Sound": 
  Schalter muss fuer des Buzzer zwischen geschlossen sein  Schalter muss fuer des Buzzer zwischen geschlossen sein
- +   
-Fuses im uC: CKDIV8: Aus (keine generelle Vorteilung des Takts) +Fuses im uC: CKDIV8: Aus (keine generelle Vorteilung des Takts) 
- +   
-Header-Files: lcd_lib_de.h (Library zur Ansteuerung LCD-Display Ver. 1.3) +Header-Files:   lcd_lib_de.h (Library zur Ansteuerung LCD-Display Ver. 1.3) 
 +  
 =============================================================================*/  =============================================================================*/ 
- +   
 +  
 // Deklarationen ============================================================== // Deklarationen ==============================================================
 +  
 // Festlegung der Quarzfrequenz // Festlegung der Quarzfrequenz
-#ifndef F_CPU // optional definieren +#ifndef F_CPU    // optional definieren 
-#define F_CPU 12288000UL // MiniMEXLE mit 12,288 MHz Quarz +#define F_CPU 18432000UL // ATmega 88 mit 18,432 MHz Quarz 
-#endif  +#endif    
- +   
 +  
 // Include von Header-Dateien // Include von Header-Dateien
-#include <avr/io.h> // I/O-Konfiguration (intern weitere Dateien) +#include <avr/io.h>    // I/O-Konfiguration (intern weitere Dateien) 
-#include <stdbool.h>  // Bibliothek fuer Bit-Variable+#include <stdbool.h>   // Bibliothek fuer Bit-Variable
 #include <avr/interrupt.h> // Definition von Interrupts #include <avr/interrupt.h> // Definition von Interrupts
-#include <util/delay.h> // Definition von Delays (Wartezeiten) +#include <util/delay.h>    // Definition von Delays (Wartezeiten) 
-#include "lcd_lib_de.h" // Header-Datei fuer LCD-Anzeige +#include "lcd_lib_de.h"  // Header-Datei fuer LCD-Anzeige 
- +   
 +  
 // Makros // Makros
-#define SET_BIT(PORT, BIT) ((PORT) |=  (1 << (BIT))) // Port-Bit Setzen +#define SET_BIT(BYTE, BIT)  ((BYTE) |=  (1 << (BIT))) // Bit Zustand in Byte setzen 
-#define CLR_BIT(PORT, BIT) ((PORT) &= ~(1 << (BIT))) // Port-Bit Loeschen +#define CLR_BIT(BYTE, BIT)  ((BYTE) &= ~(1 << (BIT))) // Bit Zustand in Byte loeschen 
-#define TGL_BIT(PORT, BIT)  ((PORT) ^=  (1 << (BIT))) // Port-Bit Toggeln +#define TGL_BIT(BYTE, BIT)  ((BYTE) ^=  (1 << (BIT))) // Bit Zustand in Byte wechseln (toggle) 
- +#define GET_BIT(BYTE, BIT)  ((BYTE) &   (1 << (BIT))) // Bit Zustand in Byte einlesen 
 +  
 // Konstanten // Konstanten
-#define VORTEILER_WERT  60 // Faktor Vorteiler = 60 +#define VORTEILER_WERT 90  // Faktor Vorteiler = 60 
-#define HUNDERTSTEL_WERT  10 // Faktor Hundertstel = 10 +#define HUNDERTSTEL_WERT 10  // Faktor Hundertstel = 10 
-#define ZEHNTEL_WERT   10 // Faktor Zehntel = 10 +#define ZEHNTEL_WERT 10  // Faktor Zehntel = 10 
- +   
-#define ON_TIME 100 // "Ein-Zeit" in Inkrementen zu 100 ms +#define ON_TIME 100 // "Ein-Zeit" in Inkrementen zu 100 ms 
-#define OFF_TIME 100 // "Aus-Zeit" in Inkrementen zu 100 ms +#define OFF_TIME 100 // "Aus-Zeit" in Inkrementen zu 100 ms 
- +   
-#define MIN_PER 59 // minimale Periodendauer in "Timerticks"  +#define MIN_PER 143 // minimale Periodendauer in "Timerticks"     
-#define MAX_PER 255 // maximale Periodendauer in "Timerticks"  +#define MAX_PER 239 // maximale Periodendauer in "Timerticks"     
-#define WAIT_TIME 2000 // Wartezeit zwischen Flanken in ms +#define WAIT_SND 2000// Wartezeit zwischen zum Tonwechsel in ms 
- +#define WAIT_LED 1000// Wartezeit zwischen zum Blinkwechsel der LED in ms 
-#define NULL 0x30 // ASCII-Zeichen '0' +  
-#define EINS 0x31 // ASCII-Zeichen '1' +#define ASC_ZERO 0x30// ASCII-Zeichen '0' 
- +#define ASC_ONE 0x31// ASCII-Zeichen '1' 
 +   
 +  
 // Variable // Variable
-unsigned char vorteiler  = VORTEILER_WERT; // Zaehlvariable Vorteiler +unsigned char vorteiler   = VORTEILER_WERT;   // Zaehlvariable Vorteiler 
-unsigned char hundertstel  = HUNDERTSTEL_WERT; // Zaehlvariable Hundertstel +unsigned char hundertstel = HUNDERTSTEL_WERT; // Zaehlvariable Hundertstel 
-unsigned char modus   = 0; // Programmmodus +unsigned char modus   = 0; // Programmmodus 
- +   
-int counter = 0000; // Variable fuer Zaehler +int counter = 0000;  // Variable fuer Zaehler 
- +   
-bool timertick; // Bit-Botschaft alle 0,111ms (Timer-Interrupt) +bool timertick;  // Bit-Botschaft alle 0,111ms (Timer-Interrupt) 
-bool takt10ms; // Bit-Botschaft alle 10ms +bool takt10ms;   // Bit-Botschaft alle 10ms 
-bool takt100ms; // Bit-Botschaft alle 100ms +bool takt100ms;  // Bit-Botschaft alle 100ms 
- +   
-bool sw1_neu = 1; // Bitspeicher fuer Taste 1 +bool sw1_neu = 1;    // Bitspeicher fuer Taste 1 
-bool sw2_neu = 1; // Bitspeicher fuer Taste 2 +bool sw2_neu = 1;    // Bitspeicher fuer Taste 2 
-bool sw3_neu = 1; // Bitspeicher fuer Taste 3 +bool sw3_neu = 1;    // Bitspeicher fuer Taste 3 
-bool sw4_neu = 1; // Bitspeicher fuer Taste 4 +bool sw4_neu = 1;    // Bitspeicher fuer Taste 4 
- +   
-bool sw1_alt = 1; // alter Wert von Taste 1 +bool sw1_alt = 1;    // alter Wert von Taste 1 
-bool sw2_alt = 1; // alter Wert von Taste 2 +bool sw2_alt = 1;    // alter Wert von Taste 2 
-bool sw3_alt = 1; // alter Wert von Taste 3 +bool sw3_alt = 1;    // alter Wert von Taste 3 
-bool sw4_alt = 1; // alter Wert von Taste 4 +bool sw4_alt = 1;    // alter Wert von Taste 4 
- +   
-bool sw1_slope = 0; // Flankenspeicher fuer Taste 1 +bool sw1_slope = 0;  // Flankenspeicher fuer Taste 1 
-bool sw2_slope = 0; // Flankenspeicher fuer Taste 2 +bool sw2_slope = 0;  // Flankenspeicher fuer Taste 2 
-bool sw3_slope = 0; // Flankenspeicher fuer Taste 3 +bool sw3_slope = 0;  // Flankenspeicher fuer Taste 3 
-bool sw4_slope = 0; // Flankenspeicher fuer Taste 4 +bool sw4_slope = 0;  // Flankenspeicher fuer Taste 4 
- +   
 +  
 // Funktionsprototypen // Funktionsprototypen
-void initTaster(void); // Taster initialisieren +void initTimer0(void);   // Timer 0 initialisieren (Soundgenerierung) 
-void initTimer0(void); // Timer 0 initialisieren (Soundgenerierung) +void initDisplay(void);  // Initialisierung des Displays 
-void initDisplay(void); // Initialisierung des Displays +  
-void readButton(void); // Tasten einlesen +void readButton(void);   // Tasten einlesen 
-void mainMenu(void); // Hauptmenu bearbeiten +void getChoiceInMainMenu(void); // Hauptmenu bearbeiten 
-void mainDisplay(void); // Anzeige des Hauptmenus +void showMainDisplay(void);  // Anzeige des Hauptmenus 
- +   
-void blinkingLED(void); // Teilprogramm 1: Blinkende LED +void doBlinkingLed(void);    // Teilprogramm 1: Blinkende LED 
-void blinkingLED_Display(void); // Anzeige zu Teilprogramm 1 +void showBlinkingLedDisplay(void); // Anzeige zu Teilprogramm 1 
- +   
-void sound(void); // Teilprogramm 2: Soundgenerierung +void doSound(void);  // Teilprogramm 2: Soundgenerierung 
-void sound_Display(void); // Anzeige zu Teilprogramm 2 +void showSoundDisplay(void); // Anzeige zu Teilprogramm 2 
- +   
-void logicFunctions(void); // Teilprogramm 3: Logische Funktionen +void doLogicFunctions(void); // Teilprogramm 3: Logische Funktionen 
-void logic_Display(void); // Anzeige zu Teilprogramm 3 +void showLogicDisplay(void); // Anzeige zu Teilprogramm 3 
- +   
-void counterProg(void); // Teilprogramm 4: Zaehler +void doCounterProg(void);    // Teilprogramm 4: Zaehler 
-void counter_Display(void); // Anzeige zu Teilprogramm 4 +void showCounterDisplay(void);  // Anzeige zu Teilprogramm 4 
 +  
 // Hauptprogramm ============================================================== // Hauptprogramm ==============================================================
 +  
 int main() int main()
-{ +{
- initTaster(); // Taster initialisieren+
  initDisplay(); // Initialisierung LCD-Anzeige  initDisplay(); // Initialisierung LCD-Anzeige
- +   
  TCCR2A = 0; // Timer 2 auf "Normal Mode": Basistakt  TCCR2A = 0; // Timer 2 auf "Normal Mode": Basistakt
  TCCR2B |= (1<<CS01); // mit Prescaler /8 betreiben  TCCR2B |= (1<<CS01); // mit Prescaler /8 betreiben
  TIMSK2 |= (1<<TOIE2); // Overflow-Interrupt aktivieren  TIMSK2 |= (1<<TOIE2); // Overflow-Interrupt aktivieren
 +  
  sei(); // generell Interrupts einschalten  sei(); // generell Interrupts einschalten
 +  
  while(1) // unendliche Schleife  while(1) // unendliche Schleife
  {  {
  switch(modus) // Programmverteiler: Variable "modus"  switch(modus) // Programmverteiler: Variable "modus"
  {  {
- case 0: // Modus 0: Hauptmenu + case 0: // Modus 0: Hauptmenu 
- mainMenu();+ showMainDisplay(); 
 + getChoiceInMainMenu();
  break;  break;
 +  
  case 1: // Modus 1: Blinkende LED  case 1: // Modus 1: Blinkende LED
- blinkingLED(); // Programm laeuft bis zum Abbruch+ doBlinkingLed(); // Programm laeuft bis zum Abbruch
  modus = 0; // danach auf Hauptmenu zurueckschalten  modus = 0; // danach auf Hauptmenu zurueckschalten
- mainDisplay(); 
  break;  break;
 +  
  case 2: // Modus 2: Soundgenerierung  case 2: // Modus 2: Soundgenerierung
- sound(); // Programm laeuft bis zum Abbruch+ doSound(); // Programm laeuft bis zum Abbruch
  modus = 0; // danach auf Hauptmenu zurueckschalten  modus = 0; // danach auf Hauptmenu zurueckschalten
- mainDisplay(); 
  break;  break;
 +  
  case 3: // Modus 3: Logische Funktionen  case 3: // Modus 3: Logische Funktionen
- logicFunctions(); // Programm laeuft bis zum Abbruch+ doLogicFunctions(); // Programm laeuft bis zum Abbruch
  modus = 0; // danach auf Hauptmenu zurueckschalten  modus = 0; // danach auf Hauptmenu zurueckschalten
- mainDisplay(); 
  break;  break;
- +   
  case 4: // Modus 4: Up-Down-Counter  case 4: // Modus 4: Up-Down-Counter
- counterProg(); // Programm laeuft bis zum Abbruch+ doCounterProg(); // Programm laeuft bis zum Abbruch
  modus = 0; // danach auf Hauptmenu zurueckschalten  modus = 0; // danach auf Hauptmenu zurueckschalten
- mainDisplay(); 
  break;  break;
  }  }
Zeile 214: Zeile 207:
  return 0;  return 0;
 } }
- +   
 +  
 // Interrupt-Routine ========================================================== // Interrupt-Routine ==========================================================
 ISR(TIMER2_OVF_vect) ISR(TIMER2_OVF_vect)
 +  
 // In der Interrupt-Routine sind die Softwareteiler realisiert, durch die Takt- // In der Interrupt-Routine sind die Softwareteiler realisiert, durch die Takt-
 // botschaften (10ms, 100ms) erzeugt werden. Die Interrupts werden von Timer 2 // botschaften (10ms, 100ms) erzeugt werden. Die Interrupts werden von Timer 2
 // ausgeloest. // ausgeloest.
 +  
 { {
  timertick = 1; // Botschaft 0,166ms senden  timertick = 1; // Botschaft 0,166ms senden
Zeile 228: Zeile 221:
  if (vorteiler==0) // wenn 0 erreicht: 10ms abgelaufen  if (vorteiler==0) // wenn 0 erreicht: 10ms abgelaufen
  {  {
- vorteiler = VORTEILER_WERT; //    Vorteiler auf Startwert + vorteiler = VORTEILER_WERT; // Vorteiler auf Startwert 
- takt10ms = 1; //    Botschaft 10ms senden+ takt10ms = 1; // Botschaft 10ms senden
  readButton();  readButton();
- --hundertstel; //    Hunderstelzaehler dekrementieren + --hundertstel; // Hunderstelzaehler dekrementieren 
-  +    
- if (hundertstel==0) // wenn 0 erreicht: 100ms abgelaufen+ if (hundertstel==0) // wenn 0 erreicht: 100ms abgelaufen
  {  {
  hundertstel = HUNDERTSTEL_WERT; // Teiler auf Startwert  hundertstel = HUNDERTSTEL_WERT; // Teiler auf Startwert
- takt100ms = 1; //    Botschaft 100ms senden + takt100ms = 1; // Botschaft 100ms senden 
-  +    
- } + }   
  }  }
 } }
  
-// Taster initialisieren ======================================================= +  
-void initTaster(void) +
-{ +
- DDRB = DDRB & 0xE1; // Port B auf Eingabe schalten +
- PORTB |= 0x1E; // Pullup-Rs eingeschaltet +
- _delay_us(10); // Wartezeit Umstellung Hardware-Signal +
-} +
 // Funktion Tasten einlesen =================================================== // Funktion Tasten einlesen ===================================================
 void readButton(void) void readButton(void)
 { {
 + //   Bitposition im Register:
 + // __76543210
 + DDRC = DDRC & 0b11110000; // Zunaechst Port B auf Eingabe schalten
 + PORTC = 0b00001111; // Pullup-Rs eingeschaltet
 + _delay_us(1); // Umschalten der Hardware-Signale abwarten
 +
  // Einlesen der 4 Tastensignale  // Einlesen der 4 Tastensignale
- sw1_neu = (PINB & (1 << PB1)); + sw1_neu = (PINC & (1 << PC0)); 
- sw2_neu = (PINB & (1 << PB2)); + sw2_neu = (PINC & (1 << PC1)); 
- sw3_neu = (PINB & (1 << PB3)); + sw3_neu = (PINC & (1 << PC2)); 
- sw4_neu = (PINB & (1 << PB4));+ sw4_neu = (PINC & (1 << PC3)); 
 +   
 + DDRC = DDRC | 0b00001111;    // Am Ende Port B wieder auf Ausgabe schalten
  
  // Auswerten der Flanken beim Druecken  // Auswerten der Flanken beim Druecken
- +   
- if ((sw1_neu==0)&(sw1_alt==1)) // wenn Taste 1 soeben gedrueckt wurde:  + if ((sw1_neu==0)&(sw1_alt==1))  // wenn Taste 1 soeben gedrueckt wurde:  
- sw1_slope = 1; //    Flankenbit Taste 1 setzen + sw1_slope = 1; // Flankenbit Taste 1 setzen 
- +   
- if ((sw2_neu==0)&(sw2_alt==1)) // wenn Taste 2 eben gedrueckt wurde: + if ((sw2_neu==0)&(sw2_alt==1))  // wenn Taste 2 eben gedrueckt wurde: 
- sw2_slope = 1; //    Flankenbit Taste 2 setzen + sw2_slope = 1; // Flankenbit Taste 2 setzen 
-  +    
- if ((sw3_neu==0)&(sw3_alt==1)) // wenn Taste 3 eben gedrueckt wurde: + if ((sw3_neu==0)&(sw3_alt==1))  // wenn Taste 3 eben gedrueckt wurde: 
- sw3_slope = 1; //    Flankenbit Taste 3 setzen + sw3_slope = 1; // Flankenbit Taste 3 setzen 
-  +    
- if ((sw4_neu==0)&(sw4_alt==1)) // wenn Taste 4 eben gedrueckt wurde: + if ((sw4_neu==0)&(sw4_alt==1))  // wenn Taste 4 eben gedrueckt wurde: 
- sw4_slope = 1; //    Flankenbit Taste 4 setzen + sw4_slope = 1; // Flankenbit Taste 4 setzen 
- +   
- // Zwischenspeichern aktuelle Tastenwerte + // Zwischenspeichern aktuelle Tastenwerte
  sw1_alt = sw1_neu; // aktuelle Tastenwerte speichern  sw1_alt = sw1_neu; // aktuelle Tastenwerte speichern
- sw2_alt = sw2_neu; //    in Variable fuer alte Werte+ sw2_alt = sw2_neu; // in Variable fuer alte Werte
  sw3_alt = sw3_neu;  sw3_alt = sw3_neu;
- sw4_alt = sw4_neu; + sw4_alt = sw4_neu;  
 } }
  
- +  
 // Initialisierung Display-Anzeige ============================================ // Initialisierung Display-Anzeige ============================================
-void initDisplay() // Start der Funktion+void initDisplay()   // Start der Funktion
 { {
- lcd_init(); // Initialisierungsroutine aus der lcd_lib + lcd_init();  // Initialisierungsroutine aus der lcd_lib 
-  +    
- lcd_gotoxy(0,0);         // Cursor auf 1. Zeile, 1. Zeichen+ lcd_gotoxy(0,0); // Cursor auf 1. Zeile, 1. Zeichen
  lcd_putstr("- Experiment 5 -"); // Ausgabe Festtext: 16 Zeichen  lcd_putstr("- Experiment 5 -"); // Ausgabe Festtext: 16 Zeichen
- +   
- lcd_gotoxy(1,0);         // Cursor auf 2. Zeile, 1. Zeichen + lcd_gotoxy(1,0); // Cursor auf 2. Zeile, 1. Zeichen 
- lcd_putstr("  Program Menu  "); // Ausgabe Festtext: 16 Zeichen + lcd_putstr("  Program Menu  "); // Ausgabe Festtext: 16 Zeichen 
 +  
  _delay_ms(2000); // Wartezeit nach Initialisierung  _delay_ms(2000); // Wartezeit nach Initialisierung
- +   
- mainDisplay();+ showMainDisplay();
 } }
- +   
 +  
 // Anzeige Hauptmenu ========================================================== // Anzeige Hauptmenu ==========================================================
-void mainDisplay()+void showMainDisplay()
 { {
- lcd_gotoxy(0,0);         // Cursor auf 1. Zeile, 1. Zeichen+ lcd_gotoxy(0,0); // Cursor auf 1. Zeile, 1. Zeichen
  lcd_putstr("   Main Level   "); // Ausgabe Festtext: 16 Zeichen  lcd_putstr("   Main Level   "); // Ausgabe Festtext: 16 Zeichen
- +   
- lcd_gotoxy(1,0);         // Cursor auf 2. Zeile, 1. Zeichen + lcd_gotoxy(1,0); // Cursor auf 2. Zeile, 1. Zeichen 
- lcd_putstr(" P1  P2  P3  P4 "); // Ausgabe Festtext: 16 Zeichen + lcd_putstr(" P1  P2  P3  P4 "); // Ausgabe Festtext: 16 Zeichen 
- +   
-} // Ende der Funktion +}    // Ende der Funktion 
- +  
- +  
 /* Teilprogramm 1: Blinkende LED ============================================== /* Teilprogramm 1: Blinkende LED ==============================================
- +   
-Funktion: Die gelbe LED (LED 3) auf dem MiniMEXLE-Board blinkt mit einer+Funktion:    Die gelbe LED (LED 3) in der Schaltung blinkt mit einer
  Periodendauer von 2 Sekunden (1 s ein, 1 s aus). Auf dem LCD-  Periodendauer von 2 Sekunden (1 s ein, 1 s aus). Auf dem LCD-
  Display wird rechts unten der Wert der LED ("1" oder "0") als  Display wird rechts unten der Wert der LED ("1" oder "0") als
  Zahl dargestellt. Abbruch mit Taste S1 nach voller Periode.  Zahl dargestellt. Abbruch mit Taste S1 nach voller Periode.
- +   
-Displayanzeige: +----------------++Displayanzeige: +----------------+
  |P1: Blinking LED|  |P1: Blinking LED|
- |Home           1|+ |Home    1|
  +----------------+  +----------------+
- +   
-Tastenfunktion: S1 Flanke: zurueck zur Hauptprogrammebene +Tastenfunktion: S1 Flanke: zurueck zur Hauptprogrammebene 
 +  
 ============================================================================ */ ============================================================================ */
-void blinkingLED()+void doBlinkingLed()
 { {
- +   
- blinkingLED_Display(); // Initialisierung Display + showBlinkingLedDisplay();   // Initialisierung Display 
- SET_BIT(DDRB, DDB0);  // Port B, Pin 2 (LED3) auf Ausgang schalten + SET_BIT(DDRB, DDB2); // Port B, Pin 0 (LED3) auf Ausgang schalten 
-  +    
- while(!sw1_slope)  // unendliche Schleife+ while(!sw1_slope)    // unendliche Schleife
  {  {
- SET_BIT(PORTB,PB0); // Port B, Pin 2 auf LOW: LED einschalten+ SET_BIT(PORTB,PB2);  // Port B, Pin 0 auf LOW: LED einschalten
  lcd_gotoxy(1,15);  lcd_gotoxy(1,15);
- lcd_putc(EINS); // Anzeige LED-Wert "1" auf Display + lcd_putc(ASC_ONE);  // Anzeige LED-Wert "1" auf Display 
- +   
- _delay_ms(1000); + _delay_ms(WAIT_LED); 
- +   
- CLR_BIT(PORTB, PB0); // Port B, Pin 2 auf HIGH: LED ausschalten+ CLR_BIT(PORTB, PB2); // Port B, Pin 0 auf HIGH: LED ausschalten
  lcd_gotoxy(1,15);  lcd_gotoxy(1,15);
- lcd_putc(NULL); // Anzeige LED-Wert "0" auf Display + lcd_putc(ASC_ZERO);  // Anzeige LED-Wert "0" auf Display 
- +   
- _delay_ms(1000); + _delay_ms(WAIT_LED); 
- +   
- } // Ende der Warteschleife + }    // Ende der Warteschleife 
- +   
- sw1_slope = 0; // Alle Flankenbits loeschen+ sw1_slope = 0;   // Alle Flankenbits loeschen
  sw2_slope = 0;  sw2_slope = 0;
  sw3_slope = 0;  sw3_slope = 0;
  sw4_slope = 0;  sw4_slope = 0;
-} // zurück zur Hauptschleife +}    // zurück zur Hauptschleife 
- +   
 +  
 // Anzeige zu Teilprogramm 1 // Anzeige zu Teilprogramm 1
-void blinkingLED_Display() // Start der Funktion+void showBlinkingLedDisplay()   // Start der Funktion
 { {
- lcd_init(); // Initialisierungsroutine aus der lcd_lib + lcd_gotoxy(0,0); // Cursor auf 1. Zeile, 1. Zeichen
-  +
- lcd_gotoxy(0,0);         // Cursor auf 1. Zeile, 1. Zeichen+
  lcd_putstr("P1: Blinking LED"); // Ausgabe Festtext: 16 Zeichen  lcd_putstr("P1: Blinking LED"); // Ausgabe Festtext: 16 Zeichen
- +   
- lcd_gotoxy(1,0);         // Cursor auf 2. Zeile, 1. Zeichen + lcd_gotoxy(1,0); // Cursor auf 2. Zeile, 1. Zeichen 
- lcd_putstr("Home            "); // Ausgabe Festtext: 16 Zeichen + lcd_putstr("Home            "); // Ausgabe Festtext: 16 Zeichen 
- +   
-} // Ende der Funktion +}    // Ende der Funktion 
- +   
- +  
- +
 /* Teilprogramm 2: Soundgenerierung =========================================== /* Teilprogramm 2: Soundgenerierung ===========================================
- +   
-Funktion: Auf dem kleinen Lautsprecher des MiniMEXLE-Boards (Buzzer) +Funktion:    Auf dem kleinen Lautsprecher (Buzzer) in der Schaltung 
  wird ein sirenenartiger Sound ausgegeben. Zwischen den auf-  wird ein sirenenartiger Sound ausgegeben. Zwischen den auf-
  und absteigenden Tönen bleibt die Frequenz kurz stabil.  und absteigenden Tönen bleibt die Frequenz kurz stabil.
Zeile 382: Zeile 369:
  Die jeweilige Periodendauer wird dreistellig in Timerticks   Die jeweilige Periodendauer wird dreistellig in Timerticks 
  auf der Anzeige rechts unten dargestellt.  auf der Anzeige rechts unten dargestellt.
- +   
-Displayanzeige: +----------------++Displayanzeige: +----------------+
  |P2: Create Sound|  |P2: Create Sound|
- |Home         123|+ |Home  123|
  +----------------+  +----------------+
- +   
-Tastenfunktion: S1 Flanke: zurueck zur Hauptprogrammebene nach Ablauf des+Tastenfunktion: S1 Flanke: zurueck zur Hauptprogrammebene nach Ablauf des
  gesamten Sound-Zyklus  gesamten Sound-Zyklus
 +  
 ============================================================================ */ ============================================================================ */
-void sound()+void doSound()
 { {
- unsigned char temp = 0; // lokale Variable + unsigned char temp = 0;  // lokale Variable 
- +   
- sound_Display(); // Anzeige zum Programm + showSoundDisplay(); // Anzeige zum Programm 
 +  
  // Ports initialisieren  // Ports initialisieren
- +   
- DDRB |= (1<<DDB0); // Port B, Pin 0 (zur LED) auf Ausgang+ DDRB |= (1<<DDB2); // Port B, Pin 0 (zur LED) auf Ausgang
  DDRD |= (1<<DDD5); // Port D, Pin 5 (zum Buzzer) auf Ausgang  DDRD |= (1<<DDD5); // Port D, Pin 5 (zum Buzzer) auf Ausgang
-  +    
- initTimer0(); // Timer 0 fuer Soundgenerierung + initTimer0();    // Timer 0 fuer Soundgenerierung 
- +   
- while(!sw1_slope) // Solange keine Flanke auf SW1: Warteschleife+ while(!sw1_slope)    // Solange keine Flanke auf SW1: Warteschleife
  {  {
  for (OCR0A=MAX_PER; OCR0A>=MIN_PER; OCR0A--) // Frequenz erhoehen  for (OCR0A=MAX_PER; OCR0A>=MIN_PER; OCR0A--) // Frequenz erhoehen
  {  {
- temp = OCR0A; // Anzeige des aktuellen Periodenzaehlers+ temp = OCR0A;    // Anzeige des aktuellen Periodenzaehlers
  lcd_gotoxy(1,13);  lcd_gotoxy(1,13);
- lcd_putc(temp/100 + NULL); // Hunderter als ASCII ausgeben+ lcd_putc(temp/100 + ASC_ZERO);  // Hunderter als ASCII ausgeben
  temp = temp%100; // Rest = Zehner, Einer  temp = temp%100; // Rest = Zehner, Einer
- lcd_putc(temp/10 + NULL); // Zehner als ASCII ausgeben + lcd_putc(temp/10 + ASC_ZERO);   // Zehner als ASCII ausgeben 
- lcd_putc(temp%10 + NULL); // Einer als ASCII ausgeben + lcd_putc(temp%10 + ASC_ZERO);   // Einer als ASCII ausgeben 
- +   
- _delay_ms(100); // in Schritten von 100 ms  + _delay_ms(100);  // in Schritten von 100 ms   
-  +    
- if(sw1_slope) // Schleifenabbruch, wenn Taster S1 gedrückt wird+ if(sw1_slope)    // Schleifenabbruch, wenn Taster S1 gedrückt wird
  {  {
- TCCR0A = 0; // Timer 0 stoppen: Sound ausschalten + TCCR0A = 0;  // Timer 0 stoppen: Sound ausschalten 
-  +    
- sw1_slope = 0; // alle Flankenbits loeschen+ sw1_slope = 0;   // alle Flankenbits loeschen
  sw2_slope = 0;  sw2_slope = 0;
  sw3_slope = 0;  sw3_slope = 0;
  sw4_slope = 0;  sw4_slope = 0;
- +   
  return;  return;
- } + }   
  }  }
- _delay_ms(WAIT_TIME); // Wartezeit hohe Frequenz + _delay_ms(WAIT_SND);   // Wartezeit hohe Frequenz 
- +   
- for (OCR0A=MIN_PER; OCR0A<MAX_PER; OCR0A++) // Frequenz absenken+ for (OCR0A=MIN_PER; OCR0A<MAX_PER; OCR0A++)  // Frequenz absenken
  {  {
- temp = OCR0A; // Anzeige des aktuellen Periodenzaehlers+ temp = OCR0A;    // Anzeige des aktuellen Periodenzaehlers
  lcd_gotoxy(1,13);  lcd_gotoxy(1,13);
- lcd_putc(temp/100 + NULL); // Hunderter als ASCII ausgeben+ lcd_putc(temp/100 + ASC_ZERO);  // Hunderter als ASCII ausgeben
  temp = temp%100; // Rest = Zehner, Einer  temp = temp%100; // Rest = Zehner, Einer
- lcd_putc(temp/10 + NULL); // Zehner als ASCII ausgeben + lcd_putc(temp/10 + ASC_ZERO);   // Zehner als ASCII ausgeben 
- lcd_putc(temp%10 + NULL); // Einer als ASCII ausgeben + lcd_putc(temp%10 + ASC_ZERO);   // Einer als ASCII ausgeben 
- +   
- _delay_ms(100); // in Schritten von 100 ms + _delay_ms(100);  // in Schritten von 100 ms 
-  +    
- if(sw1_slope) // Schleifenabbruch, wenn Taster S1 gedrückt wird+ if(sw1_slope)    // Schleifenabbruch, wenn Taster S1 gedrückt wird
  {  {
- TCCR0A = 0; // Timer 0 stoppen: Sound ausschalten + TCCR0A = 0;  // Timer 0 stoppen: Sound ausschalten 
-  +    
- sw1_slope = 0; // alle Flankenbits loeschen+ sw1_slope = 0;   // alle Flankenbits loeschen
  sw2_slope = 0;  sw2_slope = 0;
  sw3_slope = 0;  sw3_slope = 0;
  sw4_slope = 0;  sw4_slope = 0;
- +   
  return;  return;
  }  }
  }  }
- _delay_ms(WAIT_TIME); // Wartezeit niedrige Frequenz + _delay_ms(WAIT_SND);   // Wartezeit niedrige Frequenz 
- +   
- } // Ende der unendlichen Schleife + }    // Ende der unendlichen Schleife 
- +   
  // Nach Erkennen der Flanke von SW1  // Nach Erkennen der Flanke von SW1
-  +    
- TCCR0A = 0; // Timer 0 stoppen: Sound ausschalten + TCCR0A = 0;  // Timer 0 stoppen: Sound ausschalten 
- +   
- sw1_slope = 0; // alle Flankenbits loeschen+ sw1_slope = 0;   // alle Flankenbits loeschen
  sw2_slope = 0;  sw2_slope = 0;
  sw3_slope = 0;  sw3_slope = 0;
  sw4_slope = 0;  sw4_slope = 0;
-} // zurück zur Hauptschleife +}    // zurück zur Hauptschleife 
 +  
 // Intialisierung des Timers 0 fuer Sounderzeugung // Intialisierung des Timers 0 fuer Sounderzeugung
 void initTimer0() void initTimer0()
 { {
- TCCR0A = (1<<WGM01) |(1<<COM0B0);  // CTC Mode waehlen + TCCR0A = (1<<WGM01) |(1<<COM0B0);   // CTC Mode waehlen 
- TCCR0B = (1<<CS01 | 1<<CS00); // Timer-Vorteiler /64 + TCCR0B = (1<<CS01 | 1<<CS00);    // Timer-Vorteiler /64 
 +  
  OCR0A = MAX_PER; // Start mit tiefstem Ton  OCR0A = MAX_PER; // Start mit tiefstem Ton
 } }
 +  
 // Anzeige zu Teilprogramm 2 // Anzeige zu Teilprogramm 2
-void sound_Display() // Start der Funktion+void showSoundDisplay() // Start der Funktion
 { {
- lcd_gotoxy(0,0);         // Cursor auf 1. Zeile, 1. Zeichen+ lcd_gotoxy(0,0); // Cursor auf 1. Zeile, 1. Zeichen
  lcd_putstr("P2: Create Sound"); // Ausgabe Festtext: 16 Zeichen  lcd_putstr("P2: Create Sound"); // Ausgabe Festtext: 16 Zeichen
- +   
- lcd_gotoxy(1,0);         // Cursor auf 2. Zeile, 1. Zeichen + lcd_gotoxy(1,0); // Cursor auf 2. Zeile, 1. Zeichen 
- lcd_putstr("Home            "); // Ausgabe Festtext: 16 Zeichen + lcd_putstr("Home            "); // Ausgabe Festtext: 16 Zeichen 
- +   
-} // Ende der Funktion +}    // Ende der Funktion 
 +  
 /* Teilprogramm 3: Logische Funktionen ======================================== /* Teilprogramm 3: Logische Funktionen ========================================
- +   
-Funktion: Auf dem Display des MiniMEXLE Boards werden Ergebnisse von+Funktion:    Auf dem Display werden Ergebnisse von
  logischen Verknuepfungen (UND, ODER, NOT, XOR) dargestellt.  logischen Verknuepfungen (UND, ODER, NOT, XOR) dargestellt.
  Die logischen Eingangssignale werden von den Tasten S3 und S4  Die logischen Eingangssignale werden von den Tasten S3 und S4
  eingelesen.  eingelesen.
- +   
-Displayanzeige: Start Nach 2 s: +Displayanzeige: Start    Nach 2 s: 
- +----------------+ +----------------+ + +----------------+   +----------------+ 
- |P3: Logic Funct.| |S3&S4=0  S3+S4=0| + |P3: Logic Funct.|   |S3&S4=0  S3+S4=0| 
- |Home            | |/S3=0  S3xorS4=0| + |Home |   |/S3=0  S3xorS4=0| 
- +----------------+ +----------------+ + +----------------+   +----------------+ 
- +   
-Tastenfunktion: S1 Flanke: zurueck zur Hauptprogrammebene +Tastenfunktion: S1 Flanke: zurueck zur Hauptprogrammebene 
- S3: Logischer Eingang (ohne Entprellung)+ S3: Logischer Eingang (ohne Entprellung)
  S4: Logischer Eingang (ohne Entprellung)  S4: Logischer Eingang (ohne Entprellung)
 +  
 ============================================================================ */ ============================================================================ */
-void logicFunctions()+void doLogicFunctions()
 { {
- unsigned char temp = 0; // lokale Variable + unsigned char temp = 0;  // lokale Variable 
- +   
- logic_Display(); // Anzeige initialisieren + showLogicDisplay(); // Anzeige initialisieren 
- +   
- while(!sw1_slope)  // Solange keine Flanke auf SW1: Warteschleife+ while(!sw1_slope)    // Solange keine Flanke auf SW1: Warteschleife
  {  {
- if ((!sw3_alt)&&(!sw4_alt)) temp=EINS; // Ergebnis der UND-Verknuepfung + if ((!sw3_alt)&&(!sw4_alt)) temp=ASC_ONE; // Ergebnis der UND-Verknuepfung 
- else temp=NULL;+ else temp=ASC_ZERO;
  lcd_gotoxy(0,6);  lcd_gotoxy(0,6);
- lcd_putc(temp);  // auf LCD als Zeichen 0 oder 1 ausgeben + lcd_putc(temp);   // auf LCD als Zeichen 0 oder 1 ausgeben 
- +   
- if ((!sw3_alt)||(!sw4_alt)) temp=EINS; // Ergebnis der ODER-Verknuepfung + if ((!sw3_alt)||(!sw4_alt)) temp=ASC_ONE; // Ergebnis der ODER-Verknuepfung 
- else temp=NULL;+ else temp=ASC_ZERO;
  lcd_gotoxy(0,15);  lcd_gotoxy(0,15);
- lcd_putc(temp);  // auf LCD als Zeichen 0 oder 1 ausgeben + lcd_putc(temp);   // auf LCD als Zeichen 0 oder 1 ausgeben 
- +   
- if (sw3_alt) temp=EINS; // Ergebnis der Negation + if (sw3_alt) temp=ASC_ONE;  // Ergebnis der Negation 
- else temp=NULL;+ else temp=ASC_ZERO;
  lcd_gotoxy(1,4);  lcd_gotoxy(1,4);
- lcd_putc(temp);  // auf LCD als Zeichen 0 oder 1 ausgeben + lcd_putc(temp);   // auf LCD als Zeichen 0 oder 1 ausgeben 
- +   
- if ((!sw3_alt)^(!sw4_alt)) temp=EINS;  // Ergebnis der XOR-Verknuepfung + if ((!sw3_alt)^(!sw4_alt)) temp=ASC_ONE; // Ergebnis der XOR-Verknuepfung 
- else temp=NULL;+ else temp=ASC_ZERO;
  lcd_gotoxy(1,15);  lcd_gotoxy(1,15);
- lcd_putc(temp);  // auf LCD als Zeichen 0 oder 1 ausgeben + lcd_putc(temp);   // auf LCD als Zeichen 0 oder 1 ausgeben 
- +   
- _delay_ms(100); // Wartezeit 100 ms vor neuer Auswertung+ _delay_ms(100);  // Wartezeit 100 ms vor neuer Auswertung
  }  }
- +   
- sw1_slope = 0; // alle Flankenbits loeschen+ sw1_slope = 0;   // alle Flankenbits loeschen
  sw2_slope = 0;  sw2_slope = 0;
  sw3_slope = 0;  sw3_slope = 0;
  sw4_slope = 0;  sw4_slope = 0;
-} // zurück zur Hauptschleife +}    // zurück zur Hauptschleife 
- +   
 +  
 // Anzeige zu Teilprogramm 3 // Anzeige zu Teilprogramm 3
-void logic_Display()+void showLogicDisplay()
 { {
- lcd_gotoxy(0,0);         // Cursor auf 1. Zeile, 1. Zeichen+ lcd_gotoxy(0,0); // Cursor auf 1. Zeile, 1. Zeichen
  lcd_putstr("P3: Logic Funct."); // Ausgabe Festtext: 16 Zeichen  lcd_putstr("P3: Logic Funct."); // Ausgabe Festtext: 16 Zeichen
- +   
- lcd_gotoxy(1,0);         // Cursor auf 2. Zeile, 1. Zeichen + lcd_gotoxy(1,0); // Cursor auf 2. Zeile, 1. Zeichen 
- lcd_putstr("Home            "); // Ausgabe Festtext: 16 Zeichen + lcd_putstr("Home            "); // Ausgabe Festtext: 16 Zeichen 
 +  
  _delay_ms(2000); // Wartezeit 2 s  _delay_ms(2000); // Wartezeit 2 s
- +   
- lcd_gotoxy(0,0);         // Cursor auf 1. Zeile, 1. Zeichen+ lcd_gotoxy(0,0); // Cursor auf 1. Zeile, 1. Zeichen
  lcd_putstr("S3&S4=0  S3+S4=0"); // Ausgabe Festtext: 16 Zeichen  lcd_putstr("S3&S4=0  S3+S4=0"); // Ausgabe Festtext: 16 Zeichen
- +   
- lcd_gotoxy(1,0);         // Cursor auf 2. Zeile, 1. Zeichen + lcd_gotoxy(1,0); // Cursor auf 2. Zeile, 1. Zeichen 
- lcd_putstr("/S3=0  S3xorS4=0"); // Ausgabe Festtext: 16 Zeichen+ lcd_putstr("/S3=0  S3xorS4=0"); // Ausgabe Festtext: 16 Zeichen
 } }
- +   
 +  
 /* Teilprogramm 4: Up-Down-Counter ============================================ /* Teilprogramm 4: Up-Down-Counter ============================================
- +   
-Funktion: Es wird ein 4-stelliger Dezimal-Zaehler (0000..9999) mit +Funktion:    Es wird ein 4-stelliger Dezimal-Zaehler (0000..9999) mit 
  Anzeige und Ueber-/ Unterlauf realisiert. Das Aufwaerts- und   Anzeige und Ueber-/ Unterlauf realisiert. Das Aufwaerts- und 
  Abwaertszaehlen wird mit zwei Tasten (S3: +) (S4: -) gesteuert.  Abwaertszaehlen wird mit zwei Tasten (S3: +) (S4: -) gesteuert.
  Es werden die Flanken beim Druecken der Tasten ausgewertet.   Es werden die Flanken beim Druecken der Tasten ausgewertet. 
  Die Taste S2 dient zum Ruecksetzen des Zaehlers auf 0000.  Die Taste S2 dient zum Ruecksetzen des Zaehlers auf 0000.
- +   
-Displayanzeige: +----------------++Displayanzeige: +----------------+
  |P4: Counter 0000|  |P4: Counter 0000|
  |Home RES  +   - |  |Home RES  +   - |
  +----------------+  +----------------+
- +   
-Tastenfunktion: S1 Flanke: zurueck zur Hauptprogrammebene+Tastenfunktion: S1 Flanke: zurueck zur Hauptprogrammebene
  S2 Reset Counter (ohne Entprellung)   S2 Reset Counter (ohne Entprellung) 
  S3 Flanke: Counter++ (mit Entprellung)  S3 Flanke: Counter++ (mit Entprellung)
  S4 Flanke: Counter-- (mit Entprellung)  S4 Flanke: Counter-- (mit Entprellung)
 +  
 ============================================================================ */ ============================================================================ */
-void counterProg()+void doCounterProg()
 { {
- int temp; // lokale Variable + int temp;    // lokale Variable 
-  +    
- counter_Display(); // Anzeige initialisieren + showCounterDisplay();   // Anzeige initialisieren 
 +  
  // Auswertung der Tasten  // Auswertung der Tasten
- +   
- while(!sw1_slope) // Solange keine Flanke auf SW1: Warteschleife+ while(!sw1_slope)    // Solange keine Flanke auf SW1: Warteschleife
  {  {
- if (sw2_alt==0) // solange Taste 1 gedrueckt:  + if (sw2_alt==0)  // solange Taste 1 gedrueckt:  
- counter = 0000; //    Counter auf 0000 setzen + counter = 0000;  // Counter auf 0000 setzen 
- +   
- if (sw3_slope) // wenn Taste 2 eben gedrueckt wurde:+ if (sw3_slope)   // wenn Taste 2 eben gedrueckt wurde:
  {  {
- sw3_slope = 0; //    Flankenbit loeschen + sw3_slope = 0;   // Flankenbit loeschen 
- +   
- counter++; //    Counter hochzaehlen, Überlauf bei 9999+ counter++;   // Counter hochzaehlen, Überlauf bei 9999
  if (counter==10000)  if (counter==10000)
- counter = 0000; //  auf 0000 setzen+ counter = 0000; //    auf 0000 setzen
  }  }
-  +    
- if (sw4_slope) // wenn Taste 3 eben gedrueckt wurde:+ if (sw4_slope)   // wenn Taste 3 eben gedrueckt wurde:
  {  {
- sw4_slope = 0; //    Flankenbit loeschen + sw4_slope = 0;   // Flankenbit loeschen 
- +   
- counter--; //    Counter herunterzaehlen, Unterlauf bei 0+ counter--;   // Counter herunterzaehlen, Unterlauf bei 0
  if (counter<0000)  if (counter<0000)
- counter = 9999; //      auf 9999 setzen+ counter = 9999; //    auf 9999 setzen
  }  }
- +   
- _delay_ms(100); // Auswertung alle 100 ms + _delay_ms(100);  // Auswertung alle 100 ms 
- +   
  // Anzeige der Werte  // Anzeige der Werte
- +   
- lcd_gotoxy(0,12);  + lcd_gotoxy(0,12);     
- +   
  temp = counter;  temp = counter;
- lcd_putc(temp/1000+NULL); // Tausender ausgeben + lcd_putc(temp/1000+ASC_ZERO); // Tausender ausgeben 
- +   
- temp = temp%1000;  // Rest = Hunderter, Zehner, Einer + temp = temp%1000; // Rest = Hunderter, Zehner, Einer 
- lcd_putc(temp/100+NULL); // Hunderter ausgeben + lcd_putc(temp/100+ASC_ZERO); // Hunderter ausgeben 
 +  
  temp = temp%100; // Rest = Zehner. Einer  temp = temp%100; // Rest = Zehner. Einer
- lcd_putc(temp/10+NULL); // Zehner ausgeben + lcd_putc(temp/10+ASC_ZERO); // Zehner ausgeben 
- lcd_putc(temp%10+NULL); // Einer ausgeben+ lcd_putc(temp%10+ASC_ZERO); // Einer ausgeben
  }  }
- +   
- sw1_slope = 0; // alle Flankenbits loeschen+ sw1_slope = 0;   // alle Flankenbits loeschen
  sw2_slope = 0;  sw2_slope = 0;
  sw3_slope = 0;  sw3_slope = 0;
  sw4_slope = 0;  sw4_slope = 0;
-} // zurück zur Hauptschleife +}    // zurück zur Hauptschleife 
- +   
 +  
 // Anzeige zu Teilprogramm 4 // Anzeige zu Teilprogramm 4
-void counter_Display()+void showCounterDisplay()
 { {
- lcd_gotoxy(0,0);         // Cursor auf 1. Zeile, 1. Zeichen+ lcd_gotoxy(0,0); // Cursor auf 1. Zeile, 1. Zeichen
  lcd_putstr("P4: Counter 0000"); // Ausgabe Festtext: 16 Zeichen  lcd_putstr("P4: Counter 0000"); // Ausgabe Festtext: 16 Zeichen
- +   
- lcd_gotoxy(1,0);         // Cursor auf 2. Zeile, 1. Zeichen + lcd_gotoxy(1,0); // Cursor auf 2. Zeile, 1. Zeichen 
- lcd_putstr("Home RES  +   - "); // Ausgabe Festtext: 16 Zeichen+ lcd_putstr("Home RES  +   - "); // Ausgabe Festtext: 16 Zeichen
 } }
- +   
-// Hauptmenu ================================================================== +// Auswahl im Hauptmenu ermitteln ======================================================= 
-void mainMenu()+void getChoiceInMainMenu()
 { {
- if (sw1_slope) // Wenn Flanke auf Taste 1+ if (sw1_slope)   // Wenn Flanke auf Taste 1
  {  {
- sw1_slope=0; //   Flankenbit loeschen + sw1_slope=0; // Flankenbit loeschen 
- modus=1; //    neuer Modus 1+ modus=1; // neuer Modus 1
  }  }
-  +    
- if (sw2_slope) // Wenn Flanke auf Taste 2+ if (sw2_slope)   // Wenn Flanke auf Taste 2
  {  {
- sw2_slope=0; //    Flankenbit loeschen + sw2_slope=0; // Flankenbit loeschen 
- modus=2; //    neuer Modus 2+ modus=2; // neuer Modus 2
  }  }
-  +    
- if (sw3_slope) // Wenn Flanke auf Taste 3+ if (sw3_slope)   // Wenn Flanke auf Taste 3
  {  {
- sw3_slope=0; //    Flankenbit loeschen + sw3_slope=0; // Flankenbit loeschen 
- modus=3; //    neuer Modus 3+ modus=3; // neuer Modus 3
  }  }
-  +    
- if (sw4_slope) // Wenn Flanke auf Taste 4+ if (sw4_slope)   // Wenn Flanke auf Taste 4
  {  {
- sw4_slope=0; //    Flankenbit loeschen + sw4_slope=0; // Flankenbit loeschen 
- modus=4; //    neuer Modus 4+ modus=4; // neuer Modus 4
  }  }
 } }
Zeile 684: Zeile 671:
 \\ \\ \\ \\
   - Hier wird wieder geprüft ob die Frequenz des Quarz bereits eingestellt wurde und - falls nicht - dessen Frequenz eingestellt. \\ \\ \\ \\   - Hier wird wieder geprüft ob die Frequenz des Quarz bereits eingestellt wurde und - falls nicht - dessen Frequenz eingestellt. \\ \\ \\ \\
-  - Die Header-Dateien entsprechen denen der letzten Programme. \\ \\ \\ \\ \\ \\  +  - Die Header-Dateien entsprechen denen der letzten Programme. \\ \\ \\ \\ \\  
-  - Auch die Makros entsprechen denen der letzten Programme. \\ \\ \\ \\  +  - Auch die Makros entsprechen denen der letzten Programme. \\ \\ \\ \\ \\  
-  - Die Konstanten entsprechen denen der letzten Programme. \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\  +  - Die Konstanten entsprechen denen der letzten Programme. \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\  
-  - Auch die Variablen entsprechen denen der letzten Programme. Hierbei sind alle vier Schalter berücksichtigt +  - Auch die anfänglichen Variablen entsprechen denen der letzten Programme. Hierbei sind alle vier Schalter berücksichtigt.\\ \\ \\ \\ \\ \\ \\  
- +  - Wird die Taste S1 gedrückt, so wird ''sw1_neu'' gesetzt. ''sw1_alt'' entspricht dem vorherigen Wert. Gleiches gibt es für die anderen Taster. \\ \\ \\ \\ \\ \\ \\  
-  - ''timertick'', ''takt10ms'', ''takt100ms'' sind Bit-Botschaften (auch Flag genannt). Diese Boolewerte geben bescheid, ob die Interrupt Service Routine aufgerufen wurde (timertick), oder ob 10ms oder 100ms abgelaufen ist. \\ \\ +  - Wird eine ansteigende Flanke der Taste S1 gedrückt, so wird ''sw1_slope'' gesetzt. Das heißt, wenn die Taste gerade von 'nicht gedrückt' auf 'gedrückt' gewechselt hat, so wird ''sw1_slope'' gesetzt. Gleiches gibt es für die anderen Taster. \\ \\ \\   
-  - Wird die Taste S1 gedrückt, so wird ''sw1_neu'' gesetzt. ''sw1_alt'' entspricht dem vorherigen Wert. Gleiches gibt es für die anderen Taster. \\ \\ \\  +  - Bei den Funktionsprototypen sind einige bekannte Unterprogramme vorhanden. Details werden weiter unten erklärt. \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\
-  - Die Makros wurden bereits erklärt \\ \\ \\ \\ +
-  - Die Funktionsprototypen zeigen wieder die kommenden Unterprogramme an \\ \\  +
  
 ''Hauptprogramm ========================='' ''Hauptprogramm =========================''
  
   - Zunächst werden zwei Initialisierungsroutinen aufgerufen (siehe weiter unten)   - Zunächst werden zwei Initialisierungsroutinen aufgerufen (siehe weiter unten)
-  - Dann werden die "__T__imer/__C__ounter __C__ontrol __R__egister" des Timers __0__ ''TCCR0A'' und ''TCCR0B'' gesetzt. Im verwendeten "Normal Mode" zählt der ein Timer (=Zählerbaustein) im Microprozessor hoch. Die entspricht etwa dem a=a+1 im C Code, nur, dass der Microprozessor dafür keinen Code ausführen muss. Das Register ''TCCR0B'' gibt mit dem Prescaler an, dass das Hochzählen um ein nur alle 8 Prozessortakte erfolgen soll. Der verwendete Timer 0 ist ein 8-Bit Timer. Er zählt also von 0 bis 255, läuft dann über und beginnt wieder bei 0. +  - Dann werden die "__T__imer/__C__ounter __C__ontrol __R__egister" des Timers __2__ ''TCCR2A'' und ''TCCR2B'' gesetzt. Der Timer 2 ist im wesentlichen mit dem Timer 0 aus dem [[4_up_down_counter|Up/Down Counter]] vergleichbar. Er ist ein 8-Bit Timer und auch hier wird der "Normal Mode" zum hochzählen genutzt. Auch hier gibt das Register ''TCCR2B'' den Prescaler an. 
-  - ''TIMSK0'' ist die "__T__imer __I__nterrupt __M__a__SK__" des Timers __0__. Damit kann angegeben werden, ob und wenn ja, welcher Interrupt ausgelöst werden soll. Timer kann damit so konfiguriert werden, dass er keinen Interrupt auslöst, oder einen Interrupt bei einem bestimmten Wert auslöst, oder einen Interrupt beim Überlauf auslöst. \\ Mit dem Bit ''TOIE0'' wird der Interrupt bei Überlauf aktiviert (vgl. [[1https://www-user.tu-chemnitz.de/~heha/viewchm.php/hs/ATmegaX8.chm/15.htm|ATmegaX8 Datenblatt (Kap. 15.9.6)]] oder [[http://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf#page=88|ATmega328 Datasheet (Kap. 14.9.6)]]). +  - Auch hier gibt es eine "__T__imer __I__nterrupt __M__a__SK__" ''TIMSK2''. Auch hier wird mit dem Bit ''TOIE2'' ("__T__imer __O__verflow __I__nterrupt __E__nable") der Interrupt bei Überlauf aktiviert. 
-  - erst mit dem Befehl ''sei()'' wird die Bearbeitung von Interrupts aktiv +  - Mit dem Befehl ''sei()'' wird die Bearbeitung von Interrupts aktiv 
-  - in der Endlosschleife sind zwei if-Befehle zu finden, welche über Flags prüfen, ob $10ms$ oder $100ms$ abgelaufen sind. Wenn ja, wird als erstes das Flag zurückgesetzt und dann die gewünschte Unterfunktion aufgerufen. +  - in der Endlosschleife ist nur eine switch-case Anweisung zu finden. Diese stellt den Auswahlteil einer Zustandsmaschine dar: \\ {{drawio>Zustandsmaschine.svg}} \\ Aus jedem Unterprogramm wird wieder zurück ins Hauptmenü gesprungen. 
-  - Die Abfrage der Tasten soll entprellt geschehen. Das ist durch das Abtasten / Einlesen des Signals alle $10ms$ möglich. +  - Beim ''case 1...4'' wird zunächst das jeweilige Programm aufgerufen. Nachdem Rückkehr aus diesem Programm wird zunächst der ''modus'' wieder auf 0 zurückgesetzt, sodass beim nächsten Durchlauf der Schleife der ''case 0'' ausgeführt wird. Jeder case wird mit ''break'' beendet.  
-  - Für die Textanzeige ist eine keine ruckelfreie Darstellung notwendig. Damit kann für die Darstellung der Wert von $30 Hz$ unterschritten werden, über dem ein Bild als flüssig animiert war genommen wird. Eine Anzeige alle $100ms$ ist also ausreichend +
 ''Interrupt Routine ========================='' ''Interrupt Routine =========================''
-  - Mit dem Befehl ''ISR()'' wird eine Interrupt Service Routine angelegt. Das verwendete ''TIMER0_OVF_vect'' spezifiziert den gewünschten Interrupt, hier den __OV__er__F__low Interrupt für __TIMER0__.  +  - Mit dem Befehl ''ISR()'' wird eine Interrupt Service Routine für den  __OV__er__F__low Interrupt für __TIMER2__ angelegt.  
-  - Der Überlauf-Interrupt durch den Timer0 wird erst bei Überlauf des 8-Bit Wert ausgeführt. Das entspricht alle $t_{ISR}=\frac{256 \cdot Prescaler}{f_{Quarz}} = \frac{256 \cdot 8}{12'288'000 Hz} = 0,16\bar{6}ms$. +  - Der Überlauf-Interrupt durch den Timer2 wird erst bei Überlauf des 8-Bit Wert ausgeführt. Auch hier ergibt sich durch den Prescaler und Modus (''TCCR2A'' und ''TCCR2B'') eine Periode von $T_{\rm ISR}= 0,16\bar{6}~\rm ms$. 
-  - Als erstes wird beim Ausführen die boole-Variable ''tick'' gesetzt. Diese gibt an: ISR wurde aufgerufen. +  - Die Ermittlung von ''Timertick'', ''vorteiler'', ''takt10ms'', ''hundertstel'' und ''takt100ms'' ist hier wieder gleich dem im [[4_up_down_counter|Up/Down Counter]].  
-  - Die Variable ''vorteiler'' ist auch ein Zähler, welcher mit jedem Aufruf von ISR heruntergezählt wird. Mit ''vorteiler = VORTEILER_WERT'' als Ausgangswert (Zeile 65) zählt ''vorteiler'' von 60 herunter. Da ISR alle $0,16\bar{6}ms$ aufgerufen wird, wird ''vorteiler'' alle $60\cdot0,16\bar{6}ms=10ms$ gleich 0. +  - Eine große Änderung ist, dass bereits im Interrupt alle 10ms die Unterfunktion ''readButton()'' aufgerufen wird.  \\ \\ \\ \\ \\ \\ \\ \\ \\ \\  \\ \\ \\ \\ \\ \\ 
-  - Wenn ''vorteiler'' 0 erreicht wird die Variable wieder auf den Startwert zurückgesetzt und der das Flag für das Erreichen der $10ms$ gesetzt. Um auch $10\cdot10ms$ abzählen zu können, muss nach $10ms$ ''hundertstel'' auch herunter gezählt werden. +'' Funktion Tasten einlesen ==============''
-  - Erreicht ''hundertstel'' den Wert 0, so wird auch diese Variable auf 0 und ebenso das Flag für das erreichen von $100ms$ zurückgesetzt  +
-  - Mit dieser Methode erzeugt der Interrupt nur 3 Flags, die anderweitig ausgelesen werden können, z.B. in ''main()''. Die ISR bleibt also sehr schlank. Wäre in der ISR() viel Code auszuführen, so würde der Prozessor zwischen zwei Interrupts kaum noch Zeit haben, um sich dem unterbrochenen Programm zu widmen.  +
-''Taster initialisieren =============='' +
-  - Das Einstellen des Data Direction Registers und der Pullups wurde bereits in vorherigen Programmen erklärt. \\ \\ +
-''Zaehlfunktion ==============''+
 \\ \\ \\ \\ \\ \\
-  - Zunächst werden die einzelnen Tastenstellungen mittels verUNDen einer Bitmaske für den jeweiligen Taster aus ''PINB'' in die Variable ausgelesen. \\ \\ \\ +  - In dieser Funktion werden zunächst die Stellungen aller Taster eingelesen (vgl. ''counterCounting(void)'' bei [[4_up_down_counter|Up/down Counter]]). \\ \\ \\ 
-  - Für die Reaktion auf einen Tastendruck gibt es nun zwei Varianten: \\ a. immer wenn erkannt wird, dass die Taste gedrückt ist (der Schalter geschlossen ist), wird reagiert. \\b. nur beim Wechsel von 'Taster nicht gedrückt' zu 'Taster gedrückt' (Flanke von ''0'' auf ''1'') wird reagiert. \\ Das Zurücksetzen auf 0 soll immer ausgelöst werden; entsprechend wird hier Variante a. gewählt. Der Zähler soll nur zu dem Zeitpunkt Herauf-/Herunterzählen, wenn der Schalter gerade geschlossen wurde; entsprechend wird hier Variante b. gewählt. \\ \\ +  - Neu hier ist, dass über ''if ( (sw1_neu==0) & (sw1_alt==1) )'' die positive Flanke (=aufsteigende Flanke) erkannt wird und dies im Flag ''sw1_slope'' gespeichert wird. \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\
-  - Im Falle das Heraufzählens, ist ein Überlauf bei 10000 vorhanden. Im Falle des Herunterzählens, gibt es einen Unterlauf für werte kleiner als 0 - dann wird auf 9999 gesprungen. \\ \\ \\  +
-  - Zum Ende dieser Funktion müssen die Schalterstellungen in die Variablen ''sw1_alt'' bis ''sw3_alt'' gespeichert werden. Damit kann beim nächsten Aufruf die Flankendetektion stattfinden. +
-\\ \\ +
-''Anzeige Zaehler ========================='' +
-  - Zur Ausgabe des Zählerwerts wird eine Hilfsvariable angelegt und auf eine Position unten rechts auf dem Display gesprungen +
-  - Um den Wert ''3456'' auszugeben, wird dieser Schritt für Schritt im Display aufgebaut. Für die Tausenderstelle wird zunächst der Wert $3456/1000$ ohne Nachkommastellen ausgerechnet. Für die Anzeige muss dieser Wert in einen ASCII-Wert umgewandelt werden. Dazu muss ''0x30'' addiert werden.  +
-  - Für die Hunderterstelle von ''3456'' muss nun vom Tausender-Rest ''456'' wieder die höchste Stelle ausgegeben werden. Der Tausender-Rest kann über die Modulo-Funktion (im Code mittels ''%'') ermittelt werden. Für Zehner- und Einerwert kann aus dem Hunderter-Rest direkt Division durch 10 ohne Rest und gerade dieser Rest verwendet werden+
  
 ''Initialisierung Display-Anzeige ========================='' ''Initialisierung Display-Anzeige =========================''
-  - Hier wird wieder die Startanzeige mit dem Namen des Programms generiert+  - Die Funktion ''initDisplay()'' wird zu Beginn des Programms aufgerufen und führt zunächst die Initialisierung des Displays aus. 
 +  - Danach wird der erste Text auf den Bildschirm geschrieben und damit der Programmname dargestellt. 
 +  - Nach zwei Sekunden wird der Auswahlbildschirm angezeigt.
  
 +\\ \\ \\ \\ \\ \\
  
 +''Anzeige Hauptmenu =========================''
 +  - Da der Auswahlbildschirm mit dem Hauptmenu nicht nur beim Start, sondern auch nach jeder Rückkehr aus Unterprogrammen dargestellt werden muss, wird der Auswahlbildschirm in einem neuen Unterprogramm angezeigt.
 +
 +\\ \\ \\ \\ \\
 +
 +''/* Teilprogramm 1: Blinkende LED =====''
 +
 +Hier ist das Programm der [[1_hello_blinking_world|Blinking LED]] etwas angepasst eingefügt. 
 +\\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ 
 +  - Zunächst wird ein Unterprogramm zur Anzeige das Displays aufgerufen
 +  - ''SET_BIT(DDRB, DDB0)'' wandelt den Anschluss B0 in einen Ausgang um
 +  - Die Schleife wird solange ausgeführt, bis die Flanke des Schalters 1 über ''sw1_slope'' erkannt wurde
 +  - Beim Aktivieren der LED wird auch auf dem Display eine ''1'' geschrieben.  \\ \\ \\ \\
 +  - Nach einer Sekunde wird die LED ausgeschalten und auf dem Display eine ''0'' geschrieben.  \\ \\ \\ \\
 +  - Nach Beendigung der Schleife werden alle Flanken gelöscht. Damit wird verhindert, dass beim Aufruf des Hauptmenus sofort ein Sprung in ein Unterprogramm ausgeführt wird.
 +
 +\\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\
 +''/* Teilprogramm 2: Soundgenerierung ====''
 +
 +Hier ist das Programm [[2_sound_und_timer|Sound und Timer]] etwas angepasst eingefügt. 
 +\\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\
 +
 +  - Die Port Initialisierung, um Lautsprecher und LED anzusteuern, wurde übernommen.
 +  - Hier wird Timer 0 genutzt, um das gepulste Signal an den Lautsprecher zu verändern.
 +  - Die while-Schleife wird wieder abgebrochen, wenn die Taste 1 gedrückt wurde.
 +  - Neben dem Herunterzählen der Periodenlänge (über ''OCR0A--''), wird auch der Periodenzähler ausgegeben. Die Ausgabe ähnelt ''counterDisplay'' aus dem Programm [[4_up_down_counter|Up/Down Counter]].
 +  - Da die for-Schleife zum Herunterzählen der Periodenlänge sehr lange dauert (etwa 2 Sekunden) wird auch darin der Tastendruck der Taste 1 abgefragt werden. \\ \\ \\ \\ \\ 
 +  - Falls die Taste 1 gedrückt wurde, wird sowohl __in der for__-Schleife, als auch __nach der while__-Schleife der Timer gestoppt und die Flanken zurückgesetzt. \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\
 +  - Das Heraufzählen der Frequenz gleich dem Herunterzählen, bis auf die Werte der for-Schleife.
 +
 +\\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\
 +''/* Teilprogramm 3: Logische Funktionen ====''
 +
 +Hier ist das Programm [[3_logische_funktionen|Logische Funktionen]] etwas angepasst eingefügt. 
 +\\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\
 +
 +  - Durch den Anschluss des Tasters zwischen Port und Masse erzeugt ein geschlossener ein LOW Signal (logisch 0). Hier sollen aber nun der Tastendruck dem Wert HIGH (logisch 1) entsprechen. Aus diesem Grund sind die Tasterwerte in den Bedingungen negiert, z.B. ''(__**!**__sw3_alt)&&(__**!**__sw4_alt)''
 +
 +\\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\
 +''/* Teilprogramm 4: Up-Down-Counter ====''
 +
 +Hier ist das Programm [[4_up_down_counter|Up/Down Counter]] etwas angepasst eingefügt. 
 +\\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\
 +
 +  - Im wesentlichen gleicht das Programm dem bereits bekanntem. Es kann aber auf die bereits berechnete Flanken ''sw2_slope'' bis ''sw4_slope'' zurückgegriffen.
 +
 +\\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\
 +''Auswahl im Hauptmenu ermitteln ==========''
 +
 +  - Je nach gedrückter Taste wird hier die Variable ''modus'' gesetzt
 + 
 </WRAP></WRAP> </WRAP></WRAP>
 +
 <-- <--
 --> IV. Ausführung in Simulide # --> IV. Ausführung in Simulide #
-  - Geben Sie die oben dargestellten Codezeilen nacheinander ein und kompilieren Sie den Code.+  - Geben Sie die oben dargestellten Codezeilen ein und kompilieren Sie den Code.
   - Öffnen Sie Ihre hex-Datei in SimulIDE und testen Sie, ob diese die gleiche Ausgabe erzeugt   - Öffnen Sie Ihre hex-Datei in SimulIDE und testen Sie, ob diese die gleiche Ausgabe erzeugt
  
Zeile 742: Zeile 769:
  
 --> Aufgaben# --> Aufgaben#
-  - Erweiterung der des Zählers: 
-    - Bauen Sie den Zähler so um, dass er jede Sekunde um 1 nach oben zählt. 
-    - Ändern Sie die Funktionsweise der Tasten S2 und S3 so, dass diese die Zählrichtung angeben. 
-  - Variation der Eingabe 
-    - Fügen Sie einen weiteren Schalter S4 hinzu.  
-    - Mit diesem Schalter  soll nun die Stelle (Einer, Zehner, Hunderter, Tausender) ausgewählt werden, die geändert werden soll. Die Funktion soll der in folgender hex-Datei entsprechen: {{microcontrollertechnik:4_up-down-counter_mit_stellenvorgabe.hex}} 
-    - ++ Tipp 1| Ändern Sie das herauf-/herunterzählen in counterCounting so, dass eine Variable addiert bzw. subtrahiert wird. Überprüfen Sie am besten bereits diese Änderung ohne weitere Funktionalitäten. ++ 
-    - ++ Tipp 2| Wie muss die neue Variable bei Tastendruck auf S4 geändert werden? Wann muss die neue Variable wieder zurückgesetzt werden?  ++ 
  
-<--+Vielleicht haben Sie es schon bemerkt: gelegentlich scheint das Display für einen kurzen Augenblick einzelne falsche Zeichen anzuzeigen.  
 +Der Grund dafür ist, dass das Auslesen der Taster und die Datenübertragung an das Display über die gleichen Pins stattfindet und nicht synchronisiert ist. 
 +Um dies zu beheben ist eine Verbesserung des Programms notwendig.
  
 +Speicherauslastung und Programmoptimierung: 
 +    - Merken Sie sich die Speicherauslastung des bisherigen Programms. Diese finden Sie z.B. über den Solution Explorer: ''Output Files'' >> ''5_Program_Menu.elf'' >> rechte Maustaste (Kontextmenu) >> ''Properties'' >> ''Flash size'' und ''RAM size'' (in Bytes).
 +    - Der oben gezeigte Code wurde in zwei Schritten optimiert: Erster Schritt war {{microcontrollertechnik:5_program_menu_opt.c}} . Aus funktionaler Sicht sind alle Programme gleich. Kompilieren Sie diesen Code und überprüfen Sie die Speicherauslastung.
 +      - Wie funktioniert die optimierte Funktionen ''void getPressedButton()''?
 +      - Für was wird der Array ''DisplayText'' verwendet? 
 +    - Für zweite Version wurde gänzlich auf Delays im Millisekundenbereich verzichtet: {{microcontrollertechnik:5_program_menu_opt_v2.rar}}
 +      - Analysieren Sie die ''main.c''. Was macht die Unterfunktion ''doCycle10ms''? Was der Array ''runSubFuncPointer''?
 +      - Alle Unterfunktionen wurden in separate Dateien ausgelagert. ''BlinkingLed.c'' ist hierbei wieder die einfachste Funktion. Analysieren Sie, wie diese funktioniert.
 +
 +<--