3 Logische Funktionen

Tasten einlesen

Ziele

Nach dieser Lektion sollten Sie:

  1. wissen, wie eine Taste eingelesen werden kann

Video

Übung

I. Vorarbeiten
  1. Laden Sie folgende Datei herunter:
    1. 3._logische_funktionen.sim1
    2. 3._logische_funktionen.hex
    3. lcd_lib_de.h
II. Analyse des fertigen Programms
  1. Initialisieren des Programms
    1. Öffnen Sie SimulIDE und öffnen Sie dort mittels simulide_open.jpg die Datei 3._logische_funktionen.sim1
    2. Laden Sie 3._logische_funktionen.hex als firmware auf den atmega 88 Chip
  2. Betrachtung der neuen Komponenten: In der Simulation sind nun neben dem Microcontroller, der LED und dem Display Hd44780 Schalter als neue Komponenten zu sehen, welche mit S1…S2 bezeichnet sind. Diese werden in diesen Beispiel zur Eingabe genutzt.
  3. 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: $\rm S1\&S2$,
      2. OR-Verknüpfung: $\rm S1+S2$,
      3. NOT-Verknüpfung: $\rm /S1$,
      4. XOR-Verknüpfung: $\rm S1\; xor\; S2$
    3. Werden die Tasten S1 und S2 gedrückt, so werden die Ergebnisse aktualisiert.
  4. Das Programm zu diesem Hexfile soll nun erstellt werden
III. Eingabe in Microchip Studio


Achtung

Beachten Sie, dass die lcd_lib_de.h in Microchip Studio wieder importiert werden muss. 

/*=============================================================================
 
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 18432000UL				// ATmega 88 mit 18.432 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 ASC_ZERO    0x30			// ASCII-Zeichen '0'
#define ASC_ONE     0x31			// ASCII-Zeichen '1'
 
// Variable
bool sw1 = 0;						// Bitspeicher fuer Taste 1
bool sw2 = 0;						// Bitspeicher fuer Taste 2
 
// Makros
#define SET_BIT(BYTE, BIT)  ((BYTE) |=  (1 << (BIT))) // Bit Zustand in Byte setzen
#define CLR_BIT(BYTE, BIT)  ((BYTE) &= ~(1 << (BIT))) // Bit Zustand in Byte loeschen
 
// 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
     
    unsigned char temp;				// temporaere Variable definieren
  
    while(1)						// unendliche Schleife
    {
        readButtons();				// aktuelle Tastenwerte einlesen
         
        if (sw1&&sw2) temp=ASC_ONE; // Ergebnis der UND-Verknuepfung
        else          temp=ASC_ZERO;
        lcd_gotoxy(0,6);
        lcd_putc(temp);				// auf LCD als Zeichen 0 oder 1 ausgeben
 
        if (sw1||sw2) temp=ASC_ONE;	// Ergebnis der ODER-Verknuepfung
        else          temp=ASC_ZERO;
        lcd_gotoxy(0,15);
        lcd_putc(temp);				// auf LCD als Zeichen 0 oder 1 ausgeben
 
        if (!sw1)	  temp=ASC_ONE;	// Ergebnis der Negation
        else		  temp=ASC_ZERO;
        lcd_gotoxy(1,4);
        lcd_putc(temp);				// auf LCD als Zeichen 0 oder 1 ausgeben
 
        if (sw1^sw2)  temp=ASC_ONE; // Ergebnis der XOR-Verknuepfung
        else          temp=ASC_ZERO;
        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
}
 
 
// Tastenwerte S1 und S2 (ohne Entprellen) einlesen
void readButtons(void)
 //   Bitposition im Register:
 {//              __76543210
    DDRC = DDRC & 0b11111100;		// Port B auf Eingabe schalten
    PORTC =       0b00000011;		// Pullup-Rs eingeschaltet
    _delay_us(1);					// Umschalten der Hardware-Signale abwarten
    sw1 = !(PINC & (1 << PC0));		// Tasten invertiert in Bitspeicher einlesen
    sw2 = !(PINC & (1 << PC1));		// somit gedrueckte Taste ="1"
    DDRC = DDRC | 0b00000011;		// Port B auf Eingabe schalten
}

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

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


























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

  1. Hier wird wieder nach dem Quarz geprüft und ggf. dessen Frequenz eingestellt
  2. Bei den Header-Dateien wird nun die stdbool.h Datei inkludiert. Mit dieser wird der Datentyp bool definiert.
  3. 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'.
  4. Die Variablen sw1 und sw2 sollen im Folgenden den Zustand des Schalters anzeigen.
  5. Die Makros wurden bereits erklärt
  6. Die Funktionsprototypen zeigen wieder die kommenden Unterprogramme an

Abb. 1: ASCII Tabelle microcontrollertechnik:ascii_tabelle.png

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

  1. Zunächst werden zwei Initialisierungsroutinen aufgerufen (siehe weiter unten)
  2. Dann wird eine temporäre Variable deklariert, welche im Folgenden die das ASCII-Zeichen der Ergebnisse enthält
  3. In der Endlosschleife wird zunächst die Unterfunktion readButtons() aufgerufen (siehe weiter unten)
  4. 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.

  5. Für die verschiedenen booleschen Funktionen steht jeweils eine if-Anweisung bereit. Auch die Position am Display ist abhängig von der booleschen Funktion.





  6. 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 =========================

  1. 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.











  2. Funktion readButtons liest die Schalterstellung aus.
    1. Durch die Änderung des Datenrichtungs-Register (DDR) wird die Richtung der Anschlüsse vorgegeben. Es sollen dabei die Schalter S1 und S2 einlesbar gestellt werden (in Simulide durch die Tasten a und s schaltbar). Durch die UND-Verknüpfung mit der Maske 0b11111100 werden die Anschlüsse C2..C7 nicht geändert, sondern nur die Anschlüsse C0 und C1 auf Eingang gesetzt.
    2. Die Verzögerung _delay_us(1) ist im realen Aufbau notwendig, um keine Störungen über die zuvor anliegenden Spannungen zu sehen. Eingangskapazitäten des Displays werden so entladen.
    3. Mit der Zuweisung von 0b00000011 an PORTC wäre bei Ausgängen der Ausgabewert vorgegeben worden. Bei Eingängen wird über diese Zuweisung jeweils Pullup-Widerstände dazu geschalten. Damit ergibt sich aus dem äußeren Schalter und dem internen Widerstand ein Spannungsteiler. Bei leitfähigem Schalter gibt der Spannungsteiler $0~\rm V$ (=logisch $0$) zum Microcontroller aus, bei offenem Schalter $5~\rm V$ (=logisch $1$).
    4. Im Register PINC liegen die dem Schalter entsprechende Bits. Als Eselsbrücke: PIN steht für Input, PORT für Output.
    5. Zum Schluss müssen die Anschlüsse wieder auf Output geschaltet werden, damit danach die Daten für das Display sinnvoll übertragen werden können.



IV. Ausführung in Simulide
  1. Geben Sie die oben dargestellten Codezeilen nacheinander ein und kompilieren Sie den Code.
  2. Öffnen Sie Ihre hex-Datei in SimulIDE und testen Sie, ob diese die gleiche Ausgabe erzeugt


Bitte arbeiten Sie folgende Aufgaben durch:

Aufgaben
  1. Berechnungen zum _delay_us(1) in der Funktion initTaster
    Die Zeitverzögerung von $1~\rm \mu s$ dient dazu, eine gewisse Zeit abzuwarten bis der Ausgangspin auf der positiven Spannung liegt. Diese Verzögerung ist wichtig, da der interne Pull-up Widerstand und die parasitäre Kapazität des Pins ein RC-Glied erzeugen.
    1. Suchen Sie den Wert des Pull-up Widerstands an einem I/O-Pin im Datenblatt des atmega 88 unter Electrical Characteristics.
    2. Bestimmen Sie $\tau$ aus der Streukapazität von $C_{\rm s} \approx 10~\rm pF$.
    3. die meisten Befehle des AVR-Microcontrollers benötigen 2 Takte. Bei $10~\rm MHz$ benötigt ein Befehl etwa $\rm 2 \cdot {{1}\over{10~ MHz}} = 2 \cdot 10^{-7}~ s = 0,2~ \mu s$.
      Wie weit ist nach einem Befehl der Streukondensator aufgeladen?
    4. Ab wann kann davon ausgegangen werden, dass die parasitäre Kapazität voll aufgeladen ist?
    5. Wie viele Takte entsprechen $1~\rm \mu s$ bei einer Taktfrequenz von $8~\rm MHz$?
    6. Wann wäre die Kapazität aufgeladen, wenn diese sich durch einen externen IC um ein 10faches erhöht?
  2. Die Situation bei einem Eingangspin ist etwas anders: Hier existiert die parasitäre Kapazität auch. Diese wird aber mit ca. $20~\rm mA$ geladen.
    Nehmen Sie eine High Spannung von $5~\rm V$ an.
    1. Wie lange dauert es nun bis die parasitäre Kapazität aufgeladen ist?
    2. Wie viele Takte entspricht das bei $10~\rm MHz$?
    3. Generell müssen intern im Microcontroller in jedem Takt die Kapazitäten von MOSFETs geladen werden.
      Wieso werden bei schnelleren Anwendungen (z.B. Mobilgeräten) geringere Versorgungsspannungen (z.B. $1,8~\rm V$) verwendet?
  3. ASCII Code: Warum können nicht einfach die Zahlen $0...9$ übertragen werden? Stattdessen müssen diese in ein ASCII Format gewandelt werden.
    Was würde ausgegeben werden, wenn tatsächlich die Zahlen $0...9$ gesendet werden würden?
  4. Erweiterung der Schalteranzahl
    1. Fügen Sie zwei weitere Tasten mit Verbindung zu Masse und jeweils den Eingängen C2 und C3 ein - analog zu den vorhandenen Schaltern. Nutzen Sie dazu die auch schon in der Schaltung vorhandenen Komponente Bus (grüne Verbindung mit schwarzen Stummeln) und korrigieren Sie die das Bit, welches aus dem Bus genutzt wird.
    2. Klicken Sie bei den neu eingefügten Schaltern mit Rechtsklick an und wählen Sie im Kontextmenu Properties. Links sollten nun die Eigenschaften des Schalters sichtbar sein. Geben Sie als Label S3 bzw. S4 ein und wählen Sie rechts neben der Labeleingabe Show mit einem Punkt aus. Der Name des Schalters sollte nun sichtbar sein. Übernehmen Sie ansonsten die Schaltung wie bei S0 und S1.
    3. Ändern Sie den Code so, dass diese Schalter eingelesen werden können. Dazu sollten die Funktionen initTaster, readButton und main angepasst werden.
    4. Als ersten Test sollten die booleschen Funktionen statt den Schaltern S1 und S2 die Schalter S3 und S4 als Eingangswerte haben. Testen Sie diese Änderung.
    5. Im nächsten Programm sollen alle Schalter S1…S4 die Eingangswerte darstellen. Es sollen nun alle alle Eingänge per Schalter S1…S4in die verschiedenen booleschen Funktionen eingehen. Also bei z.B. aus $\rm S1\&S2$ wird $\rm S1\&S2\&S3\&S4$. Überlegen Sie sich wie bei XOR vorzugehen ist.