3. Up-Down Counter

Dies ist eine alte Version des Dokuments!

Nach dieser Lektion sollten Sie:

wissen, wie eine Taste eingelesen werden kann

I. Vorarbeiten

Laden Sie folgende Datei herunter:

II. Analyse des fertigen Programms

Initialisieren des Programms
1. Öffnen Sie SimulIDE und öffnen Sie dort mittels die Datei 3_logic_functions.simu
2. Laden Sie 3_logic_functions.hex als firmware auf den 328 Chip
Betrachtung der neuen Komponenten: In der Simulation sind nun neben dem Microcontroller, der LED und dem Display Hd44780 zwei Schalter als neue Komponenten zu sehen, welche mit S1 und S2 bezeichnet sind. Diese werden in diesen Beispiel zur Eingabe genutzt.
Betrachtung des Programmablaufs
1. Zunächst wird eine Startanzeige mit dem Namen des Programms dargestellt.
2. Als nächstes ist ein Displaybild zu sehen, in dem verschiedene logische Formeln mit Ergebnissen abgebildet sind:
  1. AND-Verknüpfung: $S1\&S2$,
  2. OR-Verknüpfung: $S1+S2$,
  3. NOT-Verknüpfung: $/S1$,
  4. XOR-Verknüpfung: $S1 xor S2$
3. Werden die Tasten S1 und S2 gedrückt, so werden die Ergebnisse aktualisiert.
Das Programm zu diesem Hexfile soll nun erstellt werden

III. Eingabe in Atmel Studio

/*=============================================================================

Experiment 3:	Logische Basisfunktionen in Software
=============	====================================

Dateiname:		Logic_Functions.c

Autoren:		Peter Blinzinger
				Prof. G. Gruhler (Hochschule Heilbronn)
				D. Chilachava	 (Georgische Technische Universitaet)

Version:		1.2 vom 27.04.2020

Hardware:		MEXLE2020 Ver. 1.0 oder höher
				AVR-USB-PROGI Ver. 2.0

Software:		Entwicklungsumgebung: AtmelStudio 7.0
				C-Compiler: AVR/GNU C Compiler 5.4.0

Funktion:		Auf dem Display werden Ergebnisse von
				logischen Verknuepfungen (UND, ODER, NOT, XOR) dargestellt.
				Die logischen Eingangssignale werden von den Tasten S1 und S2
				eingelesen.

Displayanzeige:	Start (fuer 2s):		Betrieb:
				+----------------+		+----------------+
				|- Experiment 3 -|		|S1&S2=0  S1+S2=0|
				|Logic Functions |		|/S1=1  S1xorS2=0|
				+----------------+		+----------------+

Tastenfunktion:	S1 und S2 sind die Logikeingaenge. Betrieb ohne Entprellung

Jumperstellung:	keine Auswirkung

Fuses im uC:	CKDIV8: Aus	(keine generelle Vorteilung des Takts)

Header-Files:	lcd_lib_de.h	(Library zur Ansteuerung LCD-Display Ver. 1.3)

=============================================================================*/ 

// Deklarationen ==============================================================

// Festlegung der Quarzfrequenz
#ifndef F_CPU					// optional definieren
#define F_CPU 12288000UL		// MiniMEXLE mit 12,288 MHz Quarz
#endif							

// Include von Header-Dateien
#include <avr/io.h>				// I/O Konfiguration (intern weitere Dateien)
#include <util/delay.h>			// Definition von Delays (Wartezeiten)
#include <stdbool.h> 			// Bibliothek fuer Bit-Variable
#include "lcd_lib_de.h"			// Funktionsbibliothek zum LCD-Display

// Konstanten
#define NULL	0x30			// ASCII-Zeichen '0'
#define EINS	0x31			// ASCII-Zeichen '1'

// Variable
bool sw1 = 0;					// Bitspeicher fuer Taste 1
bool sw2 = 0;					// Bitspeicher fuer Taste 2

// Makros
#define SET_BIT(PORT, BIT)  ((PORT) |= (1<<BIT))	// Einzelbit auf Port SET
#define CLR_BIT(PORT, BIT)  ((PORT) &= ~(1<<BIT))	// Einzelbit auf Port RESET

// Funktionsprototypen
void initDisplay(void);			// Initialisierung Display und Startanzeige
void initTaster(void);			// Initialisierung der Taster
void readButtons(void);			// Einlesen der Tastenwerte

// Hauptprogramm ==============================================================
int main() 						// Start des Hauptprogramms
{	
	initDisplay();				// Initialisierung Display
	initTaster();				// Initialisierung der Buttons
	
	unsigned char temp;			// temporaere Variable definieren

	while(1) 					// unendliche Schleife
	{

		readButtons();			// aktuelle Tastenwerte einlesen
		
		if (sw1&&sw2) temp=EINS; // Ergebnis der UND-Verknuepfung
		else temp=NULL;
		lcd_gotoxy(0,6);
		lcd_putc(temp);			 // auf LCD als Zeichen 0 oder 1 ausgeben

		if (sw1||sw2) temp=EINS; // Ergebnis der ODER-Verknuepfung
		else temp=NULL;
		lcd_gotoxy(0,15);
		lcd_putc(temp);			 // auf LCD als Zeichen 0 oder 1 ausgeben

		if (!sw1) temp=EINS;	 // Ergebnis der Negation
		else temp=NULL;
		lcd_gotoxy(1,4);
		lcd_putc(temp);			 // auf LCD als Zeichen 0 oder 1 ausgeben

		if (sw1^sw2) temp=EINS;	 // Ergebnis der XOR-Verknuepfung
		else temp=NULL;
		lcd_gotoxy(1,15);
		lcd_putc(temp);			 // auf LCD als Zeichen 0 oder 1 ausgeben

		_delay_ms(100);			// Wartezeit 100 ms

	}							// Ende der unendlichen Schleife

}								// Ende des Hauptprogramms

// Funktionen =================================================================

// Initialisierung Display-Anzeige
void initDisplay(void)
{
	lcd_init();					// Initialisierungsroutine aus der lcd_lib
					
	lcd_gotoxy(0,0);		       	// Cursor auf 1. Zeile, 1. Zeichen
	lcd_putstr("- Experiment 3 -"); // Ausgabe Festtext: 16 Zeichen

	lcd_gotoxy(1,0);		       	// Cursor auf 2. Zeile, 1. Zeichen
	lcd_putstr("Logic Functions ");	// Ausgabe Festtext: 16 Zeichen

	_delay_ms(2000);				// Wartezeit 2 s

	lcd_gotoxy(0,0);		       	// Cursor auf 1. Zeile, 1. Zeichen
	lcd_putstr("S1&S2=0  S1+S2=0"); // Ausgabe Festtext: 16 Zeichen

	lcd_gotoxy(1,0);		       	// Cursor auf 2. Zeile, 1. Zeichen
	lcd_putstr("/S1=1  S1xorS2=0");	// Ausgabe Festtext: 16 Zeichen
}

// Initialisierung der Taster
void initTaster(void)
 //   Bitposition im Register:
{//               __76543210 
	DDRB = DDRB & 0b11111001;		// Port B auf Eingabe schalten
	PORTB =       0b00000110;		// Pullup-Rs eingeschaltet

	_delay_us(10);					// Umschalten der Hardware-Signale abwarten
}

// Tastenwerte S1 und S2 (ohne Entprellen) einlesen
void readButtons(void)
{	
	sw1 = !(PINB & (1 << PB1));	// Tasten invertiert in Bitspeicher einlesen
	sw2 = !(PINB & (1 << PB2)); // somit gedrueckte Taste ="1"
}

/*=============================================================================

Ändern Sie auch hier wieder die Beschreibung am Anfang des C-Files, je nachdem was Sie entwickeln

Deklarationen ===================================

Hier wird wieder nach dem Quarz geprüft und ggf. dessen Frequenz eingestellt
Bei den Header-Dateien wird nun die stdbool.h Datei inkludiert. Über diese können die Funktionen der booleschen Algebra genutzt werden.
Als Konstanten werden NULL und EINS definiert. Dieser hexadezimalen Zahlencode 0x30 und 0x31 entsprechen ausgebbare Zeichen nach dem ASCII Standard. Der ASCII Standard gibt für jedes darstellbare Zeichen einen Code vor. In Abbildung 1 ist die ASCII Tabelle gezeigt. Dort ist horizontal die erste Zahl (z.B. 0x30) und vertikal die zweite Zahl (0x30) aufgetragen. Diese führen zu den darstellbaren Zahlen '0' und '1'.
Die Variablen sw1 und sw2 sollen im Folgenden den Zustand des Schalters anzeigen.
Die Makros wurden bereits erklärt
Die Funktionsprototypen zeigen wieder die kommenden Unterprogramme an

Abb. 1: ASCII Tabelle microcontrollertechnik:ascii_tabelle.png

Hauptprogramm =========================

Zunächst werden zwei Initialisierungsroutinen aufgerufen (siehe weiter unten)
Dann wird eine temporäre Variable deklariert, welche im Folgenden die das ASCII-Zeichen der Ergebnisse enthält
In der Endlosschleife wird zunächst die Unterfunktion readButtons() aufgerufen (siehe weiter unten)
die Zeilen 84…102 scheinen sich sehr zu ähneln:
1. Hier steht jeweils zuerst eine if-Anweisung. In Abhängigkeit von der jeweiligen booleschen Funktion wird die temporäre Variable gleich NULL (also das Zeichen '0') oder EINS ('1') gesetzt.
2. Die Funktion lcd_gotoxy(0,6) versetzt wieder die Position am Display und lcd_putc(temp) gibt die temporäre Variable aus.
Für die verschiedenen booleschen Funktionen steht jeweils eine if-Anweisung bereit. Auch die Position am Display ist abhängig von der booleschen Funktion.
In Zeile 104 wird dann eine gewisse Zeit gewartet. Dies vermeidet das „Prellen“ des realen Schalters: In Realität wird bei Tastendruck nicht nur einmal der Kontakt geschlossen, sondern häufig mehrmals. Dies kann aber zu fehlerhaften Zuständen führen.

Funktionen =========================

In initDisplay wird wieder zunächst das Display initialisiert und die Startanzeige mit dem Namen des Programms angezeigt. Nach 2 Sekunden werden dann die booleschen Funktionen auf dem Display dargestellt. Dort sind die Ergebnisse für nicht gedrückte Schalter vorgegeben.
Funktion initTaster
1. Durch die Änderung des Datenrichtungs-Register (DDR) wird die Richtung der Anschlüsse vorgegeben. Diese beiden Anschlüsse sind in der Simulide Umgebung an die Schalter S1 und S2 angeschlossen. Durch die UND-Verknüpfung mit der Maske 0b11111001 werden die Anschlüsse B0 und B3..B7 nicht geändert, sondern nur die Anschlüsse B1 und B2 auf Eingang gesetzt.
2. Mit der Zuweisung von PORTB wurde bisher bei Ausgängen der Ausgabewert vorgegeben. Bei Eingängen wird über diese Zuweisung ein Pullup-Widerstand dazugeschalten. Damit ergibt sich aus dem äußeren Schalter und dem internen Widerstand ein Spannungsteiler. Bei leitfähigem Schalter gibt der Spannungsteiler $0V$ (=logisch $0$) zum Microcontroller aus, bei offenem Schalter $5V$ (=logisch $1$).
Funktion readButtons liest aus dem Register PINB das dem Schalter entsprechende Bit aus. Als Eselsbrücke: PIN steht für Input, PORT für Output.

IV. Ausführung in Simulide

Geben Sie die oben dargestellten Codezeilen nacheinander ein und Kompilieren Sie den Code.
Öffnen Sie Ihre hex-Datei in SimulIDE und testen Sie, ob diese die gleiche Ausgabe erzeugt

Sie sollten sich nach der Übung die ersten Kenntnisse mit dem Umgang der Umgebung angeeignet haben. Bitte arbeiten Sie folgende Aufgaben durch:

Aufgaben

Klicken Sie mit rechter Maustaste bei main() auf WAIT_TIME und dann auf Goto implementation. Sie werden feststellen, dass der Cursor auf die Deklaration des Wertes springt. Versuchen Sie selbiges bei initDisplay an lcd_putstr und wählen Sie die Variante, welche ein {…} angefügt hat. Hier sehen Sie die den Code in der header-Datei, der für die Übergabe des Strings an das Display verantwortlich ist. Dort kann in gleicher Art lcd_putc und lcd_write weiterverfolgt werden. In lcd_write und lcd_enable wird die Übergabe der Werte an das Display abgearbeitet. Dazu werden zunächst die Daten am Datenport ausgegeben und anschließend die Steuerleitung gepulst aktiviert.
Verfolgen Sie lcd_gotoxy nach. Wie wird das übertragen?
Wie ist es möglich bei aufsteigender und abfallender Frequenz einen entsprechenden Text am Display auszugeben? Ändern Sie den Code geeignet.
Versuchen Sie das Programm so zu variieren, dass es ein Martinshorn ausgibt. Suchen Sie dazu zunächst die benötigten Frequenzen und ändern Sie das Programm passend ab.
Können Sie eine kleine Melodie ausgeben? Versuchen Sie z.B. „Alle meine Entchen“, oder eine Melodie ihrer Wahl.

3. Up-Down Counter

Tasten einlesen

Ziele

Video

Übung